# packages

pkgId: 261594c760b8d644038125bbfe111cc4a372f564d5ba2626b0069245f5c61fec
name: python-deepquantum-help
arch: noarch
version: 3.4.1
epoch: 0
release: 1
summary: Development documents and examples for deepquantum
url: https://deepquantum.turingq.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-deepquantum-3.4.1-1.src.rpm
location_href: Packages/python-deepquantum-help-3.4.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/TuringQ/deepquantum">
      <img width=70% src="docs/assets/deepquantum_logo_light_v1.png" alt="DeepQuantum logo"/>
    </a>
  </p>

  [![docs](https://img.shields.io/badge/docs-link-blue.svg)](https://dqapi.turingq.com/)
  [![PyPI](https://img.shields.io/pypi/v/deepquantum.svg?logo=pypi)](https://pypi.org/project/deepquantum/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/deepquantum)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg?logo=apache)](./LICENSE)
  [![Downloads](https://img.shields.io/pypi/dm/deepquantum.svg)](https://pypi.org/project/deepquantum/)
  [![Downloads](https://static.pepy.tech/badge/deepquantum)](https://pepy.tech/project/deepquantum)

  DeepQuantum is a platform that integrates artificial intelligence (AI) and quantum computing (QC). It is an efficient programming framework designed for quantum machine learning and photonic quantum computing. By leveraging the PyTorch deep learning platform for QC, DeepQuantum provides a powerful and easy-to-use tool for creating and simulating quantum circuits and photonic quantum circuits. This makes it ideal for developers to quickly get started and explore the field in depth. It also serves as a valuable learning platform for quantum computing enthusiasts.



  - **AI-Enhanced Quantum Computing Framework**: Seamlessly integrated with PyTorch, it utilizes technologies such as automatic differentiation, vectorized parallelism, and GPU acceleration for efficiency. It facilitates the easy construction of hybrid quantum-classical models, enabling end-to-end training and inference.
  - **User-Friendly API Design**: The API is designed to be simple and intuitive, making it easy to initialize quantum neural networks and providing flexibility in data encoding.
  - **Photonic Quantum Computing Simulation**: The Photonic module includes both Fock and Gaussian backends, catering to different simulation needs in photonic quantum computing. It comes with built-in optimizers to support on-chip training of photonic quantum circuits.
  - **Large-Scale Quantum Circuit Simulation**: Based on tensor networks, it enables the simulation of 100+ qubits on a laptop, leading the industry in both simulation efficiency and scale.



  Before installing DeepQuantum, we recommend first manually installing PyTorch 2.
  If the latest version of PyTorch is not compatible with your CUDA version, manually install a compatible PyTorch 2 version.

  The PyTorch installation instructions currently recommend:
  1. Install [Miniconda](https://docs.anaconda.com/miniconda/) or [Anaconda](https://www.anaconda.com/download).
  2. Setup conda environment. For example, run `conda create -n <ENV_NAME> python=3.10` and `conda activate <ENV_NAME>`.
  3. Install PyTorch following the [PyTorch installation instructions](https://pytorch.org/get-started/locally/).
  Currently, this suggests running `conda install pytorch -c pytorch`.

  If you want to customize your installation, please follow the [PyTorch installation instructions](https://pytorch.org/get-started/locally/) to build from source.

  To install DeepQuantum with `pip`, run

  ```bash
  pip install deepquantum

  pip install deepquantum[dev]

  pip install deepquantum -i https://pypi.tuna.tsinghua.edu.cn/simple
  ```

  Alternatively, to install DeepQuantum from source, run

  ```bash
  git clone https://github.com/TuringQ/deepquantum.git
  cd deepquantum
  pip install -e .

  pip install -e . -i https://pypi.tuna.tsinghua.edu.cn/simple
  ```



  To begin, please start with the tutorials (CN) on [basics](./docs/basics.ipynb) and [photonic basics](./docs/photonic_basics.ipynb).

  Below are some minimal demos to help you get started.

  - Quantum circuit

  ```python
  import deepquantum as dq
  cir = dq.QubitCircuit(2)
  cir.h(0)
  cir.cnot(0, 1)
  cir.rx(1, 0.2)
  cir.observable(0)
  print(cir())
  print(cir.expectation())
  ```

  - Quantum circuit based on matrix product state

  You can simply set `mps=True` in `QubitCircuit` and adjust the bond dimension `chi` to control the complexity.

  ```python
  cir = dq.QubitCircuit(2, mps=True, chi=4)
  cir.h(0)
  cir.cnot(0, 1)
  cir.rx(1, 0.2)
  cir.observable(0)
  print(cir())
  print(cir.expectation())
  ```

  - Photonic quantum circuit with the Fock backend, based on Fock basis state

  ```python
  cir = dq.QumodeCircuit(2, [1,1])
  cir.dc([0,1])
  cir.ps(0, 0.1)
  cir.bs([0,1], [0.2,0.3])
  print(cir())
  print(cir.measure())
  ```

  - Photonic quantum circuit with the Fock backend, based on Fock state tensor

  ```python
  cir = dq.QumodeCircuit(2, [(1, [1,1])], basis=False)
  cir.dc([0,1])
  cir.ps(0, 0.1)
  cir.bs([0,1], [0.2,0.3])
  print(cir())
  print(cir.measure())
  ```

  - Photonic quantum circuit with the Gaussian backend

  ```python
  cir = dq.QumodeCircuit(2, 'vac', cutoff=10, backend='gaussian')
  cir.s(0, 0.1)
  cir.d(1, 0.1)
  cir.bs([0,1], [0.2,0.3])
  print(cir())
  print(cir.measure())
  print(cir.photon_number_mean_var(wires=0))
  print(cir.measure_homodyne(wires=1))
  ```



  DeepQuantum is open source, released under the Apache License, Version 2.0.


pkgId: 293c369464be0810f4ff0d99a8981fa78e73cdb23868440e30677652529ab078
name: python-deepview-profile-help
arch: noarch
version: 0.14.5
epoch: 0
release: 1
summary: Development documents and examples for deepview-profile
url: https://github.com/CentML/DeepView.Profile
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-deepview-profile-0.14.5-1.src.rpm
location_href: Packages/python-deepview-profile-help-0.14.5-1.noarch.rpm
checksum_type: sha256
description:
  ![DeepView](https://raw.githubusercontent.com/CentML/DeepView.Profile/main/assets/deepview.png)
  [![License](https://img.shields.io/badge/license-Apache--2.0-green?style=flat)](https://github.com/CentML/DeepView.Profile/blob/main/LICENSE)
  ![](https://img.shields.io/pypi/pyversions/deepview-profile.svg)
  [![](https://img.shields.io/pypi/v/deepview-profile.svg)](https://pypi.org/project/deepview-profile/)

  DeepView.Profile is a tool to profile and debug the training performance of [PyTorch](https://pytorch.org) neural networks.

  - [Installation](#installation)
  - [Usage example](#getting-started)
  - [Development Environment Setup](#dev-setup)
  - [Release History](#release-history)
  - [Meta](#meta)
  - [Contributing](#contributing)

  <h2 id="installation">Installation</h2>

  DeepView.Profile works with *GPU-based* neural networks that are implemented in [PyTorch](https://pytorch.org).

  To run DeepView.Profile, you need:
  - A system equipped with an NVIDIA GPU
  - Python 3.9+
  - PyTorch 1.1.0+ with CUDA
    - **NOTE:**  We assume you have the correct version of PyTorch installed for their GPU. Default PyTorch installation on Linux distros might not have CUDA support. If you see error similar to below, your PyTorch version is incompatible with your version of CUDA. You can download the appropriate version from the [PyTorch site](https://pytorch.org/get-started/locally/)
      ```NVIDIA GeForce RTX 3060 Ti with CUDA capability sm_86 is not compatible with the current PyTorch installation.
      The current PyTorch install supports CUDA capabilities sm_37 sm_50 sm_60 sm_70.
      If you want to use the NVIDIA GeForce RTX 3060 Ti GPU with PyTorch, please check the instructions at https://pytorch.org/get-started/locally/
      ```
  - **For new RTX 4000 GPUs you need to install pytorch with cuda11.8 [pip install torch==2.0.1+cu118 torchvision==0.15.2+cu118 torchaudio==2.0.2 --index-url https://download.pytorch.org/whl/cu118] otherwise CUPTI will not initialize correctly**



  Installing with [Pip](https://packaging.python.org/en/latest/tutorials/installing-packages/#use-pip-for-installing)
  ```zsh
  pip install deepview-profile
  ```


  ```bash
  git clone https://github.com/CentML/DeepView.Profile
  cd DeepView.Profile
  poetry install
  poetry run deepview --help
  ```

  <h2 id="getting-started">Usage example</h2>

  To use DeepView.Profile in your project, you need to first write an entry point file, which is a regular Python file that describes how your model is created and trained. See the [Entry Point](docs/providers.md) for more information.

  Once your entry point file is ready, there are two ways to profile interactive profiling and standalone profiling.


  Interactive profiling is done with VSCode with the [DeepView.Explore](https://github.com/CentML/DeepView.Explore) plugin. Install the plugin in VSCode and run the profiling session to interactively profile your models.
  ```zsh
  python3 -m deepview_profile interactive
  ```


  Standalone profiling is useful when you just want access to DeepView.Profile's profiling functionality. DeepView.Profile will save the profiling results (called a "report") into a [SQLite database file](https://www.sqlite.org/) that you can then query yourself. We describe the database schema for DeepView.Profile's run time and memory reports in the [Run Time Report Format](docs/run-time-report.md) and [Memory Report Format](docs/memory-report.md) pages respectively.

  To have DeepView.Profile perform run time profiling, you use the `deepview time`
  subcommand. In addition to the entry point file, you also need to specify the
  file where you want DeepView.Profile to save the run time profiling report using the
  `--output` or `-o` flag.

  ```zsh
  python3 -m deepview_profile time entry_point.py --output my_output_file.sqlite
  ```

  Launching memory profiling is almost the same as launching run time profiling.
  You just need to use `deepview memory` instead of `deepview time`.

  ```zsh
  python3 -m deepview_profile memory entry_point.py --output my_output_file.sqlite
  ```

  To export various available analysis to json file, you may use `deepview analysis --all` command for exact entry point and output file. It is required to later view the analysis on the web viewer.

  It is also possible to run several optional analysis. There are such analysis available: `--measure-breakdown`, `--measure-throughput`, `--habitat-predict`, `--measure-utilization`, `--energy-compute`, `--exclude-source`

  ```zsh
  python3 -m deepview_profile analysis entry_point.py --all --exclude-source --output=complete_analysis.json
  ```

  `--exclude-source` option allows not adding `encodedFiles` section to output, that is available for `--measure-breakdown` analysis

  or various combinations of optional analysis

  ```zsh
  python3 -m deepview_profile analysis entry_point.py --measure-breakdown --measure-throughput --habitat-predict --measure-utilization --energy-compute --output=various_analysis.json
  ```

  <h2 id="dev-setup">Development Environment Setup</h2>

  From the project root, do
  ```zsh
  poetry install
  ```

  <h2 id="release-history">Release History</h2>

  See [Releases](https://github.com/CentML/DeepView.Profile/releases)

  <h2 id="meta">Meta</h2>

  DeepView.Profile began as a research project at the [University of Toronto](https://web.cs.toronto.edu) in collaboration with [Geofrey Yu](mailto:gxyu@cs.toronto.edu), [Tovi Grossman](https://www.tovigrossman.com) and [Gennady Pekhimenko](https://www.cs.toronto.edu/~pekhimenko/).

  The accompanying research paper appears in the proceedings of UIST'20. If you are interested, you can read a preprint of the paper [here](https://arxiv.org/pdf/2008.06798.pdf).

  If you use DeepView.Profile in your research, please consider citing our paper:

  ```bibtex
  @inproceedings{skyline-yu20,
    title = {{Skyline: Interactive In-Editor Computational Performance Profiling
      for Deep Neural Network Training}},
    author = {Yu, Geoffrey X. and Grossman, Tovi and Pekhimenko, Gennady},
    booktitle = {{Proceedings of the 33rd ACM Symposium on User Interface
      Software and Technology (UIST'20)}},
    year = {2020},
  }
  ```

  It is distributed under Apache 2.0 license. See [LICENSE](LICENSE) and [NOTICE](NOTICE) for more information.

  <h2 id="contributing">Contributing</h2>

  Check out [CONTRIBUTING.md](CONTRIBUTING.md) for more information on how to help with DeepView.Profile.


pkgId: 8b090af50497bfe353f4dd3bc184d392ab424e801d270a0c5311ad15bab253f5
name: python-delb-help
arch: noarch
version: 0.4
epoch: 0
release: 1
summary: Development documents and examples for delb
url: https://pypi.org/project/delb/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-delb-0.4-1.src.rpm
location_href: Packages/python-delb-help-0.4-1.noarch.rpm
checksum_type: sha256
description:
  |latest-version| |rtd| |python-support| |license| |black|
  ``delb`` is a library that provides an ergonomic model for XML encoded text
  documents (e.g. TEI-XML_) for the Python programming language.
  It fills a gap for the humanities-related field of software development towards
  the excellent (scientific) communities in the Python ecosystem.
  For a more elaborated discussion see the *Design* chapter of the documentation.


pkgId: 421cbd2a39bb91498fafb09682553f75e7328cb1ab2152dde921ab0593eb2a18
name: python-delos-cosmos-help
arch: noarch
version: 0.1.9
epoch: 0
release: 1
summary: Development documents and examples for delos-cosmos
url: https://pypi.org/project/delos-cosmos/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-delos-cosmos-0.1.9-1.src.rpm
location_href: Packages/python-delos-cosmos-help-0.1.9-1.noarch.rpm
checksum_type: sha256
description:
  To **check the health** of the server and the validity of your API key:
  ```python
  response = client.status_health_request()
  if response:
      print(f"Response: {response}")


pkgId: 59415d372b0ed82909c79c581aff5235bb04d46cc6c16447884250fd740443ac
name: python-delos-llmax-help
arch: noarch
version: 0.11.10
epoch: 0
release: 1
summary: Development documents and examples for delos-llmax
url: https://pypi.org/project/delos-llmax/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-delos-llmax-0.11.10-1.src.rpm
location_href: Packages/python-delos-llmax-help-0.11.10-1.noarch.rpm
checksum_type: sha256
description:
  Python package to manage most external and internal LLM APIs fluently.




  To install, run the following command:

  ```bash
  python3 -m pip install delos-llmax
  ```



  You first have to define a list of `Deployment` as such, where you need to specify the endpoints, key and deployment_name. Then create the client:

  ```python
  from llmax.clients import MultiAIClient
  from llmax.models import Deployment, Model

  deployments: dict[Model, Deployment] = {
          "gpt-4o": Deployment(
              model="gpt-4o",
              provider="azure",
              deployment_name="gpt-4o-2024-05-13",
              api_key=os.getenv("LLMAX_AZURE_OPENAI_SWEDENCENTRAL_KEY", ""),
              endpoint=os.getenv("LLMAX_AZURE_OPENAI_SWEDENCENTRAL_ENDPOINT", ""),
          ),
          "whisper-1": Deployment(
              model="whisper-1",
              provider="azure",
              deployment_name="whisper-1",
              api_key=os.getenv("LLMAX_AZURE_OPENAI_SWEDENCENTRAL_KEY", ""),
              endpoint=os.getenv("LLMAX_AZURE_OPENAI_SWEDENCENTRAL_ENDPOINT", ""),
              api_version="2024-02-01",
          ),
      }

  client = MultiAIClient(
          deployments=deployments,
      )
  ```

  Then you should define your input (that can be a text, image or audio, following the openai documentation for instance).

  ```python
  messages = [
          {"role": "user", "content": "Raconte moi une blague."},
      ]
  ```

  And finally get the response:

  ```python
  response = client.invoke_to_str(messages, model)
  print(response)
  ```



  When creating the client, you can also specify two functions, *increment_usage* and *get_usage*.
  The first one is **Callable[[float, Model], bool]** while the second is **Callable[[], float]**.
  *increment_usage* is a function that is called after a call of the llm. The float is the price and Model, the model used. It can therefore be used to update your database. *get_usage* returns whether a condition is met. For instance, it can be a function that calls your database and returns whether the user is still active.


pkgId: 0859e3a028f70763c739923a3caace7e98d175e0aac1385c3a039dfc31b16d9f
name: python-deltachat-rpc-client-help
arch: noarch
version: 1.152.1
epoch: 0
release: 1
summary: Development documents and examples for deltachat-rpc-client
url: https://pypi.org/project/deltachat-rpc-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-deltachat-rpc-client-1.152.1-1.src.rpm
location_href: Packages/python-deltachat-rpc-client-help-1.152.1-1.noarch.rpm
checksum_type: sha256
description:
  RPC client connects to standalone Delta Chat RPC server `deltachat-rpc-server`
  and provides asynchronous interface to it.



  To use Delta Chat RPC client, first build a `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`
  or download a prebuilt release.
  Install it anywhere in your `PATH`.

  [Create a virtual environment](https://docs.python.org/3/library/venv.html)
  if you don't have one already and activate it.
  ```
  $ python -m venv env
  $ . env/bin/activate
  ```

  Install `deltachat-rpc-client` from source:
  ```
  $ cd deltachat-rpc-client
  $ pip install .
  ```



  1. Build `deltachat-rpc-server` with `cargo build -p deltachat-rpc-server`.
  2. Install tox `pip install -U tox`
  3. Run `CHATMAIL_DOMAIN=nine.testrun.org PATH="../target/debug:$PATH" tox`.

  Additional arguments to `tox` are passed to pytest, e.g. `tox -- -s` does not capture test output.



  Setup a development environment:
  ```
  $ tox --devenv env
  $ . env/bin/activate
  ```

  ```
  $ python
  >>> from deltachat_rpc_client import *
  >>> rpc = Rpc()
  >>> rpc.start()
  >>> dc = DeltaChat(rpc)
  >>> system_info = dc.get_system_info()
  >>> system_info["level"]
  'awesome'
  >>> rpc.close()
  ```


pkgId: 805a315e5c75d4dc7652e5e15efd7d29866a90cce345dba3030896b8bbc6e6ec
name: python-deltafi-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for deltafi
url: https://pypi.org/project/deltafi/
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-deltafi-2.2.0-1.src.rpm
location_href: Packages/python-deltafi-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This project provides a Python implementation of the DeltaFi Action Kit. The DeltaFi Action Kit is a setup of modules which simplify the creation of a DeltaFi Plugin.


pkgId: 73d8cb705ddeb5dc4bf322fc33f68a84d7b5f65bc8bac78fe902e4d940fbc61b
name: python-deluge-utilities-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for deluge-utilities
url: https://github.com/GitBib/deluge-utilities
rpm_license: Apache License, Version 2.0, see LICENSE file
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-deluge-utilities-0.0.4-1.src.rpm
location_href: Packages/python-deluge-utilities-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  **deluge-utilities** – is a set of utilities to help you work with Deluge.
  Example of work
  ```python
  from deluge_utilities import Deluge
  session = Deluge("login", "password")
  session.old_torrent_search()
  ```


pkgId: 4ec22c796d570a153ee81887f0828df57b85e66187ef48f3d461b36b81a2d5b2
name: python-densired-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for densired
url: https://github.com/PhilJahn/DENSIRED
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-densired-1.2.0-1.src.rpm
location_href: Packages/python-densired-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This package provides a data generator for density-based data, described in the ECML PKDD 24 paper "Data with Density-Based Clusters: A Generator for Systematic Evaluation of Clustering Algorithms" by Philipp Jahn$^{1,2}$ , Christian M. M. Frey$^{3}$, Anna Beer$^{4}$, Collin Leiber$^{1,2}$, and Thomas Seidl$^{1,2,3}$.

  (1 LMU Munich, Munich, Germany; 2 Munich Center for Machine Learning (MCML), Munich, Germany; 3 Fraunhofer IIS, Erlangen, Germany; 4 University of Vienna, Vienna, Austria.)



  The current stable version can be installed by the following command:

  pip install densired



  Use the following code to generate a skeleton. Parameters are listed at our Github Repository (https://github.com/PhilJahn/DENSIRED).

  ```
  skeleton = datagen.densityDataGen()
  ```

  Use the following code to obtain a dataset with *n* points from a skeleton. There are additional parameters, that are also listed below.

  ```
  data = skeleton.generate_data(n)
  datax = data[:,0:-1]
  datay = data[:,-1]
  ```

  To visualize the skeleton, call the following code. For higher-dimensionalities, either specify *dcount* to get all pairs of the *dc* most spread out dimensions or specify the desired dimensions directly with *dims*.
  ```
  skeleton.display_cores(dims=[d1,d2,...], dcount=dc)
  ```

  To visualize a dataset, call the following. Give the dataset as *data*. The flags *show_radius* and *show_core* decide whether to display the core radii and core centers, respectively. For higher-dimensionalities, as with dispaly_cores, either specify *dcount* to get all pairs of the *dc* most spread out dimensions or specify the desired dimensions directly with *dims*.
  ```
  skeleton.display_data(data, show_radius=False, show_core=False, dims=[d1,d2,...], dcount=dc)
  ```

  To initialize a stream, call the following function. The *command*-String controls the stream behavior. The *default_duration* is the default duration of a block of the stream. default_duration does not need to be specified, in which case it has a value of 1000. The *command*-String will be explained in more detail further below.
  ```
  skeleton.init_stream(command=commandstring, default_duration = 1000)
  ```

  In order to get an element from the stream, just use the skeleton as an iterator
  ```
  x = skeleton.next()
  ```

  To visualize a data stream, call the following.
  ```
  skeleton.display_current_stream()
  ```

  Alternatively, use this to set a stream command and display it in one command. Parameters are analogous to *init_stream*.
  ```
  skeleton.display_stream(command=commandstring, default_duration = 1000)
  ```


pkgId: 95f61f8ab7c460326f6871e58c737df76c5eadeb31d18c68d65a79fffac241c3
name: python-denvr-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for denvr
url: https://pypi.org/project/denvr/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-denvr-0.1.0-1.src.rpm
location_href: Packages/python-denvr-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This package is largely autogenerated from our [Denvr Cloud API Spec](https://api.cloud.denvrdata.com/swagger/v1/swagger.json)

  ```console
  pip install denvr
  ```

  Getting started with the `denvr` python sdk just involves loading and calling the `client` builder function, which returns a `Client` object for each denvr service (e.g., `clusters`, `vpcs`, `servers/virtual`).
  ```python
  >>> import json
  >>> from denvr.client import client
  >>> virtual = client('servers/virtual')
  ```
  Lets start by fetching some of Denvr's VM configurations.
  We'll use `json.dumps` to make the output a bit easier to read.
  ```python
  >>> print(json.dumps(virtual.get_configurations(), indent=2))
  {
    "items": [
      {
        "id": 5,
        "user_friendly_name": "A100_40GB_PCIe_1x",
        "name": "A100_40GB_PCIe_1x",
        "description": null,
        "os_version": "20.04",
        "os_type": "Ubuntu",
        "storage": 1700,
        "gpu_type": "nvidia.com/A100PCIE40GB",
        "gpu_family": "NVIDIA A100",
        "gpu_brand": "Nvidia",
        "gpu_name": "A100 40GB PCIe",
        "type": "nvidia.com/A100PCIE40GB",
        "brand_family": "NVIDIA A100",
        "brand": "Nvidia",
        "text_name": "A100 40GB PCIe",
        "gpus": 1,
        "vcpus": 14,
        "memory": 112,
        "price": 2.05,
        "compute_network": null,
        "is_gpu_platform": true,
        "clusters": [
          "Hou1",
          "Msc1"
        ]
      },
      {
        "id": 6,
        "user_friendly_name": "A100_40GB_PCIe_2x",
        "name": "A100_40GB_PCIe_2x",
        "description": null,
        "os_version": "20.04",
        "os_type": "Ubuntu",
        "storage": 3400,
        "gpu_type": "nvidia.com/A100PCIE40GB",
        "gpu_family": "NVIDIA A100",
        "gpu_brand": "Nvidia",
        "gpu_name": "A100 40GB PCIe",
        "type": "nvidia.com/A100PCIE40GB",
        "brand_family": "NVIDIA A100",
        "brand": "Nvidia",
        "text_name": "A100 40GB PCIe",
        "gpus": 2,
        "vcpus": 28,
        "memory": 224,
        "price": 4.1,
        "compute_network": null,
        "is_gpu_platform": true,
        "clusters": [
          "Hou1",
          "Msc1"
        ]
      },
  ```
  Next we'll try Creating a new virtual machine:
  ```python
  >>> print(json.dumps(
      virtual.create_server(
          name="api-test",
          rpool="on-demand",
          vpc="denvr",
          configuration="H100_80GB_SXM_8x",
          cluster="Hou1",
          ssh_keys=["ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAA..."],
          operating_system_image="Ubuntu 22.04.4 LTS",
          root_disk_size=500,
      ),
      indent=2
  ))
  {
    "username": "rory@denvrdata.com",
    "tenancy_name": "denvr",
    "rpool": "on-demand",
    "direct_attached_storage_persisted": false,
    "id": "api-test",
    "namespace": "denvr",
    "configuration": "H100_80GB_SXM_8x",
    "storage": 20000,
    "gpu_type": "nvidia.com/H100SXM480GB",
    "gpus": 8,
    "vcpus": 200,
    "memory": 940,
    "ip": "",
    "private_ip": "172.16.0.84",
    "image": "Ubuntu_22.04.4_LTS",
    "cluster": "Hou1",
    "status": "na",
    "storage_type": "na"
  }
  ```
  Similarly, we can also fetch info about a specific vm.
  ```python
  >>> print(json.dumps(virtual.get_server(id='rofinn-intel-dev', namespace='denvr', cluster='Hou1'), indent=2))
  {
    "username": "rory@denvrdata.com",
    "tenancy_name": "denvr",
    "rpool": "reserved-denvr",
    "direct_attached_storage_persisted": false,
    "id": "rofinn-intel-dev",
    "namespace": "denvr",
    "configuration": "15",
    "storage": 27000,
    "gpu_type": "intel/GAUDI2",
    "gpus": 8,
    "vcpus": 152,
    "memory": 940,
    "image": "habana-1.16.2",
    "cluster": "Hou1",
    "status": "ONLINE",
    "storage_type": "na"
  }
  ```
  A different example using our applications service.
  ```python
  >>> print(json.dumps(
  {
    "id": "api-test",
    "cluster": "Msc1",
    "status": null,
    "tenant": "denvr",
    "created_by": "rory@denvrdata.com",
    "private_ip": "172.16.0.180",
    "public_ip": "",
    "resource_pool": "on-demand",
    "dns": "",
    "ssh_username": "",
    "application_catalog_item_name": "jupyter-notebook",
    "application_catalog_item_version_name": "python-3.11.9",
    "hardware_package_name": "g-nvidia-1xa100-40gb-pcie-14vcpu-112gb",
    "persisted_direct_attached_storage": false,
    "personal_shared_storage": false,
    "tenant_shared_storage": false
  }
  >>> print(json.dumps(app.get_applications(), indent=2))
  {
    "items": [
      {
        "id": "api-test",
        "cluster": "Msc1",
        "status": "ONLINE",
        "tenant": "denvr",
        "createdBy": "rory@denvrdata.com",
        "privateIp": "172.16.0.180",
        "publicIp": "130.250.171.126",
        "resourcePool": "on-demand",
        "dns": "https://YYC-130-250-171-126.cloud.denvrdata.com/",
        "sshUsername": "",
        "applicationCatalogItemName": "jupyter-notebook",
        "applicationCatalogItemVersionName": "python-3.11.9",
        "hardwarePackageName": "g-nvidia-1xa100-40gb-pcie-14vcpu-112gb",
        "persistedDirectAttachedStorage": false,
        "personalSharedStorage": false,
        "tenantSharedStorage": false
      }
    ]
  }
  ```


pkgId: 95f7d4a30d6a4f29d732543cb03da4f34396ef2c6240a4b90ca1dfa18dcd8ce3
name: python-depcon-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for depcon
url: https://github.com/lancereinsmith/depcon
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-depcon-0.1.3-1.src.rpm
location_href: Packages/python-depcon-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  `depcon` is a tool designed to simplify the migration of dependency specifications from traditional `requirements.txt`, `requirements.in`, `requirements-dev.txt`, and `requirements-dev.in` files into the modern `pyproject.toml` format created using the [`uv`](https://docs.astral.sh/uv/) or [`hatch`](https://github.com/pypa/hatch) tools. This allows for a streamlined, standardized, and more maintainable approach to dependency management in Python projects.



  Traditional `requirements.txt` files are widely used to manage dependencies in Python projects, but they have limitations:

  - They do not natively integrate with modern Python packaging tools.
  - Managing separate files for base and development dependencies can be error-prone.
  - Adding, updating, or syncing dependencies requires external tools like `pip-tools`.

  By migrating dependencies to `pyproject.toml`, you can leverage a unified and declarative format for dependency and project configuration. This format is now the standard for Python packaging and works seamlessly with tools like `hatch`, `poetry`, and `uv`.



  You can install `depcon` via [pipx](https://pypa.github.io/pipx/) or the `uvx` plugin manager:

  ```bash

  uvx install depcon


  pipx install depcon
  ```



  `depcon` integrates into a workflow involving `uv` for project initialization and management. Here’s how you can use it:

  Workflow Overview
  1.	Initialize your project with uv init.
  2.	Migrate your dependencies with depcon.
  3.	Sync and lock your dependencies with uv sync.



  1. Initialize your Project

  Start by creating a pyproject.toml file for your project using uv init:

  ```
  uv init
  ```

  This will create a pyproject.toml file with basic metadata for your project.

  2. Migrate Dependencies with depcon

  Run depcon to migrate dependencies from existing requirements files into your pyproject.toml file. For example:

  * Migrate base dependencies from requirements.txt:

  ```
  depcon -r requirements.txt
  ```
  or
  ```
  depcon -r requirements.in
  ```

  * Migrate development dependencies from requirements-dev.txt:

  ```
  depcon -d requirements-dev.txt
  ```
  or
  ```
  depcon -r requirements.txt -d requirements-dev.txt
  ```

  By default, `depcon` will add dependencies to the [project.dependencies] section for base dependencies, and to [tool.uv.dev-dependencies] for development dependencies.

  3. Sync and Lock Dependencies

  Once dependencies are migrated, sync and lock them with uv:

  ```
  uv sync
  ```

  This will resolve, install, and lock all dependencies into a hatch.lock or requirements.lock file.

  Additional Options

  * Specify requirements.in files for pinned dependency resolution:

  ```
  depcon -r requirements.in
  ```

  * Use depcon with different tools (e.g., poetry) by specifying custom behavior (future support planned).



  * Unified Configuration: Manage dependencies and metadata in a single pyproject.toml file.
  * Modern Tools: Leverage the power of uv, hatch, and modern packaging workflows.
  * Ease of Use: Simplify the migration and maintenance of dependencies.



  - `-r`, `--requirements`: Path to requirements.txt file
  - `-d`, `--requirements-dev`: Path to requirements-dev.txt file
  - `-p`, `--pyproject`: Path to target pyproject.toml file (default: ./pyproject.toml)



  ```
  depcon -r requirements.txt -d requirements-dev.txt -p pyproject.toml
  depcon -r requirements.in -p pyproject.toml
  depcon -r requirements.txt
  ```



  Contributions are welcome! If you’d like to improve depcon or add features, feel free to submit an issue or pull request on the GitHub repository.



  depcon is licensed under the MIT License. See the LICENSE file for details.


pkgId: b2652461eea47dfb7a0cb4369b388ddfa3c246e0234d5e659c94e47521a5d2b2
name: python-depio-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for depio
url: https://github.com/noppelmax/depio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-depio-0.0.5-1.src.rpm
location_href: Packages/python-depio-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  <h4 align="center">
    <a href="https://#">Install</a>
    ·
    <a href="https://#">Configure</a>
    ·
    <a href="https://#">Docs</a>
  </h4>



  ![python-package.yml](https://github.com/noppelmax/depio/actions/workflows/python-package.yml/badge.svg)

  A simple task manager with slurm integration.


  We start with setting up a **Pipeline**:
  ```python
  from depio.Pipeline import Pipeline
  from depio.Executors import ParallelExecutor

  defaultpipeline = Pipeline(depioExecutor=ParallelExecutor())
  ```
  To this pipeline object you can now add **Task**s.
  There are two ways how you can add tasks.
  The first (1) is via decorators and the second (2) is a function interface.
  Before we consider the differences we start with parts that are similar for both.


  To add tasks via decorators you need use the `@task("datapipeline")` decorator from `depio.decorators.task`:
  ```python
  import time
  import pathlib
  from typing import Annotated

  from depio.Pipeline import Pipeline
  from depio.Executors import ParallelExecutor
  from depio.Task import Product, Dependency
  from depio.decorators import task

  defaultpipeline = Pipeline(depioExecutor=ParallelExecutor())

  BLD = pathlib.Path("build")
  BLD.mkdir(exist_ok=True)

  print("Touching an initial file")
  (BLD/"input.txt").touch()

  @task("datapipeline")
  def slowfunction(output: Annotated[pathlib.Path, Product],
              input: Annotated[pathlib.Path, Dependency] = None,
              sec:int = 0
              ):
      print(f"A function that is reading from {input} and writing to {output} in {sec} seconds.")
      time.sleep(sec)
      with open(output,'w') as f:
          f.write("Hallo from depio")

  defaultpipeline.add_task(slowfunction(BLD/"output1.txt",input=BLD/"input.txt", sec=2))
  defaultpipeline.add_task(slowfunction(BLD/"output2.txt",input=BLD/"input.txt", sec=3))
  defaultpipeline.add_task(slowfunction(BLD/"final1.txt",BLD/"output1.txt", sec=1))

  exit(defaultpipeline.run())
  ```

  First, we add a folder `build` in which we want to produce our artifacts.
  Then, we create an initial artifact `build/input.txt` via `touch`.
  Thereafter, begins the interesting part:
  We define a function `slowfunction` that takes a couple of seconds to produce a output file from a given input file.
  We annotate function with the `@task` decorator and use the `typing.Annotated` type to tell depio which arguments are depencendies and which are product of the function.
  depion will parse this for us and setup the dependencies between the tasks.
  Finally, we add the function calls to the pipeline via `add_task` and `run` the pipeline.





  ```python
  import time
  import pathlib
  from typing import Annotated

  from depio.Pipeline import Pipeline
  from depio.Executors import ParallelExecutor
  from depio.Task import Product, Dependency
  from depio.Task import Task

  defaultpipeline = Pipeline(depioExecutor=ParallelExecutor())

  BLD = pathlib.Path("build")
  BLD.mkdir(exist_ok=True)

  print("Touching an initial file")
  (BLD/"input.txt").touch()

  def slowfunction(
              input: Annotated[pathlib.Path, Dependency],
              output: Annotated[pathlib.Path, Product],
              sec:int = 0
              ):
      print(f"A function that is reading from {input} and writing to {output} in {sec} seconds.")
      time.sleep(sec)
      with open(output,'w') as f:
          f.write("Hallo from depio")


  defaultpipeline.add_task(Task("functionaldemo1", slowfunction, [BLD/"input.txt", BLD/"output1.txt", ], { "sec": 2}))
  defaultpipeline.add_task(Task("functionaldemo2", slowfunction, [BLD/"output1.txt", BLD/"final1.txt", ],{ "sec": 1}))

  exit(defaultpipeline.run())
  ```

  This will produce the following output:
  ```
  Tasks:
    ID  Name             Slurm ID    Slurm Status    Status       Task Deps.    Path Deps.             Products
     1  functionaldemo1                              FINISHED     []            ['build/input.txt']    ['build/output1.txt']
     2  functionaldemo2                              FINISHED     [1]           ['build/output1.txt']  ['build/final1.txt']
  All jobs done! Exit.
  ```

  The main difference is that you have to pass the args and kwargs manually, but therefore can also overwrite the task name.
  However you can also define the DAG by yourself:
  ```python
  import time

  from depio.Pipeline import Pipeline
  from depio.Executors import ParallelExecutor
  from depio.Task import Task

  defaultpipeline = Pipeline(depioExecutor=ParallelExecutor())

  def slowfunction(sec:int = 0):
      print(f"A function that is doing something for {sec} seconds.")
      time.sleep(sec)

  t1 = defaultpipeline.add_task(Task("functionaldemo1", slowfunction, [1]))
  t2 = defaultpipeline.add_task(Task("functionaldemo1", slowfunction, [1]))
  t3 = defaultpipeline.add_task(Task("functionaldemo1", slowfunction, [1]))
  t4 = defaultpipeline.add_task(Task("functionaldemo2", slowfunction, [2], depends_on=[t3]))
  t5 = defaultpipeline.add_task(Task("functionaldemo3", slowfunction, [3], depends_on=[t4]))

  exit(defaultpipeline.run())
  ```

  This should produce the following output:
  ```
  Tasks:
    ID  Name             Slurm ID    Slurm Status    Status       Task Deps.    Path Deps.    Products
     1  functionaldemo1                              FINISHED     []            []            []
     2  functionaldemo2                              FINISHED     [1]           []            []
     3  functionaldemo3                              FINISHED     [2]           []            []
  All jobs done! Exit.
  ```

  Notice how it produced only three tasks instead of five.
  The reason is that the first three task are the same function with the same arguments.
  depio is merging these together.
  When using the functional interface as above with hard coded dependencies between the task (`depends_on`), the `add_task` function will return the earliest registered task with the given function and arguments.
  You hence have to save the return value as the task object and relate to this object.


  You just have to replace the pipeline with a slurm pipeline like so:
  ```python
  import os
  from typing import Annotated
  import pathlib
  import submitit
  import time

  from depio.Executors import SubmitItExecutor
  from depio.Pipeline import Pipeline
  from depio.decorators import task
  from depio.Task import Product, Dependency

  BLD = pathlib.Path("build")
  BLD.mkdir(exist_ok=True)

  SLURM = pathlib.Path("slurm")
  SLURM.mkdir(exist_ok=True)



  os.environ["SBATCH_RESERVATION"] = "<your reservation>"
  defaultpipeline = Pipeline(depioExecutor=SubmitItExecutor(folder=SLURM))


  @task("datapipeline")
  def slowfunction(
              input: Annotated[pathlib.Path, Dependency],
              output: Annotated[pathlib.Path, Product],
              sec:int = 0
              ):
      print(f"A function that is reading from {input} and writing to {output} in {sec} seconds.")
      time.sleep(sec)
      with open(output,'w') as f:
          f.write("Hallo from depio")

  defaultpipeline.add_task(slowfunction(BLD/"input.txt", BLD/"output1.txt",sec=2))
  defaultpipeline.add_task(slowfunction(BLD/"input.txt", BLD/"output2.txt",sec=3))
  defaultpipeline.add_task(slowfunction(BLD/"output1.txt", BLD/"final1.txt",sec=1))

  exit(defaultpipeline.run())
  ```


  Here is how you can use it with hydra:
  ```python
  import os
  from typing import Annotated
  import pathlib
  import submitit
  import time

  from omegaconf import DictConfig, OmegaConf
  import hydra

  from depio.Executors import SubmitItExecutor
  from depio.Pipeline import Pipeline
  from depio.decorators import task
  from depio.Task import Product, Dependency, IgnoredForEq

  SLURM = pathlib.Path("slurm")
  SLURM.mkdir(exist_ok=True)

  CONFIG = pathlib.Path("config")
  CONFIG.mkdir(exist_ok=True)


  os.environ["SBATCH_RESERVATION"] = "isec-team"
  defaultpipeline = Pipeline(depioExecutor=SubmitItExecutor(folder=SLURM))


  @task("datapipeline")
  def slowfunction(
              input: Annotated[pathlib.Path, Dependency],
              output: Annotated[pathlib.Path, Product],
              cfg: Annotated[DictConfig,IgnoredForEq],
              sec:int = 0
              ):
      print(f"A function that is reading from {input} and writing to {output} in {sec} seconds.")
      time.sleep(sec)
      with open(output,'w') as f:
          f.write(OmegaConf.to_yaml(cfg))

  @hydra.main(version_base=None, config_path=str(CONFIG), config_name="config")
  def my_hydra(cfg: Annotated[DictConfig,IgnoredForEq]) -> None:

      BLD = pathlib.Path(cfg["bld_path"])
      BLD.mkdir(exist_ok=True)

      defaultpipeline.add_task(slowfunction(None, BLD/f"input.txt", cfg, sec=4))
      defaultpipeline.add_task(slowfunction(BLD/"input.txt", BLD/f"output_{cfg['attack'].name}.txt", cfg, sec=2))
      defaultpipeline.add_task(slowfunction(BLD/f"output_{cfg['attack'].name}.txt", BLD/f"final_{cfg['attack'].name}.txt", cfg, sec=1))


  if __name__ == "__main__":
      my_hydra()
      exit(defaultpipeline.run())
  ```

  Then you can run hydra's multiruns to generate a bunch of tasks:
  ```bash
  python demo_hydra.py -m attack=ours,otherattack1,otherattack2
  ```

  Or you can use it for sweeps also.



  To use different skip and build mode you can set the `buildmode` parameter, when creating the task.

  ```python
  @task("datapipeline", buildmode=BuildMode.ALWAYS)
  def funcdec(output: Annotated[pathlib.Path, Product]):

      with open(output,'w') as f:
          f.write("Hallo from depio")
      return 1
  ```

  There are three values to chose from
  - `BuildMode.NEVER`: Run this task never
  - `BuildMode.IF_MISSING`: Run this tasks if one of the output files is missing
  - `BuildMode.ALWAYS`: Always run this task


  Create an editable egg and install it.

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


  Run
  ```bash
  pytest
  ```


  See [LICENCE](LICENSE).


  See [SECURITY](SECURITY.md).


pkgId: e4d86af0a5e0a7f82cb8ff163d16b743348ec1cd3e00c7849ff3977013844fa3
name: python-deploy-4-developer-help
arch: noarch
version: 1.0
epoch: 0
release: 1
summary: Development documents and examples for deploy-4-developer
url: https://pypi.org/project/deploy-4-developer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-deploy-4-developer-1.0-1.src.rpm
location_href: Packages/python-deploy-4-developer-help-1.0-1.noarch.rpm
checksum_type: sha256
description:
  This project, **deploy-4-developer**, is an open-source tool designed for developers to automate deployment tasks in their workflows. It simplifies tasks such as file uploads, remote command execution, local file deletions, and changes based on predefined configurations in a JSON-like `deploy.json` file. After installation via pip or other package managers, the tool creates an executable file (`deploy0`) in the Python environment's bin directory to prevent conflicts with other commands. This tool is ideal for developers who need a quick, reliable, and customizable deployment process without having to manually manage complex workflows.


pkgId: 5c1bd01879d6b1f72b380a09378653fe1c26a265072c0ed42f8a1a287ce8157a
name: python-deps-injection-help
arch: noarch
version: 1.6.2
epoch: 0
release: 1
summary: Development documents and examples for deps-injection
url: https://pypi.org/project/deps-injection/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-deps-injection-1.6.2-1.src.rpm
location_href: Packages/python-deps-injection-help-1.6.2-1.noarch.rpm
checksum_type: sha256
description:
  Easy dependency injection for all, works with Python 3.8-3.12. Main features and advantages:
  * support **Python 3.8-3.12**;
  * works with **FastAPI, **Litestar**, Flask** and **Django REST Framework**;
  * support dependency injection via `Annotated` in `FastAPI`;
  * the code is fully typed and checked with [mypy](https://github.com/python/mypy);
  * **no third-party dependencies**;
  * support **async injections**;
  * no **wiring**;
  * the life cycle of objects (**scope**) is implemented by **providers**;
  * **overriding** dependencies for testing;
  * **100%** code coverage;
  * good [documentation](https://injection.readthedocs.io/latest/);
  * intuitive and almost identical api with [dependency-injector](https://github.com/ets-labs/python-dependency-injector),
  which will allow you to easily migrate to injection


pkgId: d85beffff8f50d90deffb39924d1d2e51b5f066373d5eeea329790a76d9a0376
name: python-deps-rocker-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for deps-rocker
url: https://pypi.org/project/deps-rocker/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-deps-rocker-0.5.0-1.src.rpm
location_href: Packages/python-deps-rocker-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Ci](https://github.com/blooop/deps_rocker/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/blooop/deps_rocker/actions/workflows/ci.yml?query=branch%3Amain)
  [![Codecov](https://codecov.io/gh/blooop/deps_rocker/branch/main/graph/badge.svg?token=Y212GW1PG6)](https://codecov.io/gh/blooop/deps_rocker)
  [![GitHub issues](https://img.shields.io/github/issues/blooop/deps_rocker.svg)](https://GitHub.com/blooop/deps_rocker/issues/)
  [![GitHub pull-requests merged](https://badgen.net/github/merged-prs/blooop/deps_rocker)](https://github.com/blooop/deps_rocker/pulls?q=is%3Amerged)
  [![GitHub release](https://img.shields.io/github/release/blooop/deps_rocker.svg)](https://GitHub.com/blooop/deps_rocker/releases/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/deps-rocker)](https://pypistats.org/packages/deps-rocker)
  [![License](https://img.shields.io/pypi/l/deps-rocker)](https://opensource.org/license/mit/)
  [![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/downloads/)
  [![Pixi Badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json)](https://pixi.sh)




  ```
  pip install deps-rocker
  ```



  ```

  rocker --deps ubuntu:22.04
  ```



  Docker enables easy isolation of dependencies from the host system, but it is not easy to dynamically combine docker files from separate projects into a single unified environment.




  This is a [rocker](https://github.com/tfoote/rocker) extension for automating dependency installation.  The aim is to allow a projects to define its development dependencies in a deps.yaml file which are added to the rocker container.  If two projects define their dependencies in separate files, the extension will combine the common commands into the same docker layer to help reduce image size and duplication of work.

  For example:

  pkg a requires git, make and ffmpeg and pkg_b requires git-lfs and pip.  Their deps.yaml files would look something like:

  pkg_a.deps.yaml:

  ```
  apt_sources:
    - git

  apt_language-toolchain:
    - make
    - gcc

  apt:
    - ffmpeg
  ```
  pkg_b.deps.yaml

  ```
  apt_sources:
    - git
    - git-lfs

  apt_language-toolchain:
    - python3-pip
  ```

  If you wanted a container that had the dependencies of both installed deps-rocker would combine the dependencies to produce a file like:

  ```
  apt_sources:
    - git
    - git-lfs

  apt_language-toolchain:
    - make
    - gcc
    - python3-pip

  apt:
    - ffmpeg
  ```

  Each heading in the yaml file produces a docker layer based on the command and the label.  The format of the labels is {command_name}_{command-label}.  The layer names are delimited by _ so layer names should use - eg: language-toolchain.

  This makes it easy to define the dependencies for a single project, but enable reuse of common dependencies across multiple projects. However, deps rocker does not restrict what is defined in each layer and so relies on a common convention for multiple packages to play nicely with eachother.  If one package adds "make" to apt_sources and other package adds "make" to apt_langage_toolchain, the deps-rocker will not complain and will not deduplicate that install step.



  The algorithm works by splitting each entry in the yaml file into a command and a layer.  The entries from all the deps.yaml files are grouped by the command and layer into a list of entries for that command.  The order of the commands is defined by the order they appear in the deps.yaml file.  As long as all the files follow the same order of commands then a dependency tree of commands can be created and executed in a deterministic order.  However if two files define conflicting orders deps-rocker will not be able to produce a deterministic set of commands and fail.  e.g:

  pkg_a.deps.yaml:

  ```
  apt_sources:
    - git

  apt_language-toolchain:
    - make
    - gcc
  ```
  pkg_b.deps.yaml

  ```
  apt_language-toolchain:
    - python3-pip

  apt_sources:
    - git
    - git-lfs
  ```

  pkg_a says that apt_langage-toolchain comes before apt_sources, and pkg_b says that apt_sources comes before apt_language-toolchain, which is a conflict.

  The pseudocode for the deps-rocker algorithm is as follows:
  ```
  dependencies_dictionary
  for file in glob(*.deps.yaml):
    for entry in file.entries:
      add
  ```

  If two packages have unqiue layers that depend on a common layer

  pkg_a.deps.yaml:

  ```
  apt_sources:
    - git

  apt_pkg_a_custom:
    - custom1
  ```
  pkg_b.deps.yaml

  ```
  apt_sources:
    - git-lfs

  apt_pkg_b_custom:
    - custom1
  ```

  Here apt_pkg_b_custom and apt_pkg_a_custom both need to be run after apt_sources.  They will be run run in alphabetical order (to ensure determinism)




  Commands are defined in templates/commandname_snippet.Dockerfile.

  They use the [empy](https://pypi.org/project/empy/) templating langage that is used by [rocker](https://github.com/tfoote/rocker).  deps-rocker has some basic commands already implemented but adding a new command is as simple as adding a _snippet.Dockerfile.

  Existing Commands:
    - apt: apt install packages
    - add-apt-repository: add repositories to apt
    - env: define environment variables
    - pip: install pip packages
    - run: RUN a docker command
    - script: run a script.
    - pyproject: look for any local pyproject.toml files and install dependencies listed there.


  script:

  If you have sudo inside your script deps-rocker will automatically remove them.  This is so that you can run the script on the host machine where sudo is required.



  As mentioned above, deps-rocker does not enforce any particular layer order so the user can define them as they see fit, however to enhance interoperation of packages we define a suggested layer order.  Examples of deps.yaml can be found in [manifest_rocker](https://github.com/blooop/manifest_rocker/tree/all/pkgs)

  the template_pkg has common layers and dependencies that go in each layer as a guide to maximise reusability and caching.
  [template_pkg](https://github.com/blooop/manifest_rocker/blob/main/pkgs/template_pkg/template_pkg.deps.yaml)

  ```


  env_base:
    - DEPS_ROCKER=1

  apt_base: #lowest level of dependency that changes very infrequently
    - build-essentials

  apt_io: #graphics sound, input devices etc
    - libasound2

  apt_sources: #apt dependencies for setting up software sources
    - ca-certificates #needed for wget
    - wget
    - curl
    - lsb-release
    - gnupg2
    - git
    - git-lfs

  script_sources: #scripts for adding repositories or repo keys
    - sources.sh

  apt_language-toolchain: #packges related to setting up languages e.g. c++,python,rust etc
    - python3-pip
    - make
    - gcc

  pip_language-toolchain: #install basic development tools which almost never change
    - pip #this updates pip to latest version
    - flit
    - pytest
    - ruff

  apt_tools: #any other development tools
    - colcon

  apt: #the main dependencies of the package
    - fsearch

  pyproject: #Scan for all pyproject.tomls and install
    - all

  script_build: #any build steps
    - build.sh

  script_lint:
    - lint.sh

  script_test:
    - test.sh




  This has only been tested on the ubuntu base image. It assumes you have access to apt-get.


pkgId: 786d8e561a3d5afc9fd26b4f48c998d2cfab4e24d5c2b0b52954ace1977556d6
name: python-deriva-help
arch: noarch
version: 1.7.5
epoch: 0
release: 1
summary: Development documents and examples for deriva
url: https://github.com/informatics-isi-edu/deriva-py
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-deriva-1.7.5-1.src.rpm
location_href: Packages/python-deriva-help-1.7.5-1.noarch.rpm
checksum_type: sha256
description:
  For further information, visit the project [homepage](https://github.com/informatics-isi-edu/deriva-py).


pkgId: b0e2b7124a29aece08d8fc85ecb06f70c33ccae1bfd0a11887e888523d1d69b3
name: python-descope-pulumi-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for descope-pulumi
url: https://www.descope.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-descope-pulumi-0.1.0-1.src.rpm
location_href: Packages/python-descope-pulumi-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  The Descope Resource Provider lets you manage [Descope](https://www.descope.com) resources.



  This package is available for several languages/platforms:



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @descope/pulumi-descope
  ```

  or `yarn`:

  ```bash
  yarn add @descope/pulumi-descope
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install descope_pulumi
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/descope/pulumi-descope/sdk/go/...
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Descope.Pulumi.Descope
  ```



  The following configuration points are available for the `descope` provider:

  - `descope:projectId` (environment: `DESCOPE_PROJECT_ID`) - Descope Project ID
  - `descope:managementKey` (environment: `DESCOPE_MANAGEMENT_KEY`) - Descope Management Key



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/descope/api-docs/).


pkgId: a76c63dbdcf0ce8c0b52ad3c16151ba1fa231f5a347f163f5318935afb0e9fdb
name: python-descriptorlib-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for descriptorlib
url: https://pypi.org/project/descriptorlib/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-descriptorlib-0.1.0-1.src.rpm
location_href: Packages/python-descriptorlib-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
  [![License](https://img.shields.io/badge/license-LGPL-green.svg)](LICENSE)
  [![Coverage Status](https://img.shields.io/coveralls/nostalgiatan/Descriptorlib/master.svg?style=flat-square)](https://coveralls.io/r/https://github.com/nostalgiatan/Descriptorlib)
  [![PyPI](https://img.shields.io/pypi/v/Descriptorlib.svg?style=flat-square)](https://pypi.org/project/Descriptorlib/)
  [![Documentation Status](https://readthedocs.org/projects/descriptorlib/badge/?version=latest&style=flat-square)](https://descriptorlib.readthedocs.io/en/latest/?badge=latest)
  `Descriptorlib` 是一个 Python 库，它提供了一系列强大的描述符，用于增强 Python 类的属性功能。通过使用描述符，你可以轻松实现属性的类型检查、只读、延迟初始化、版本控制、线程安全等特性。

  使用 pip 安装 `Descriptorlib`:
  ```bash
  pip install Descriptorlib
  ```

  `Descriptorlib` 提供了详细的文档，包括中文和英文版本。每个描述符都有其对应的文档，方便用户查找和使用。
  - [Chinese Documentation](/docs/Chinese/Descriptordocs)
  - [English Documentation](/docs/English/Descriptordocs)

  在 `Chinese` 和 `English` 目录下都有一个 `FAQ` 目录，收录了常见问题与解决方案。

  我们为每个描述符提供了单元测试，确保它们的可用性和正确性。测试代码位于 `tests` 目录。

  `examples` 目录提供了描述符的使用示例，帮助用户快速上手。

  - **monomer**: 所有描述符都储存在此目录下。
  - **libException**: 包含所有错误信息的目录。
  - **utils**:包含公用于所有描述符的工具目录。

  我们欢迎和鼓励社区成员为 `Descriptorlib` 做出贡献。请参考 [CONTRIBUTING.md](CONTRIBUTING.md) 了解如何贡献代码。

rpm_license:
  GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999  Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  [This is the first released version of the Lesser GPL.  It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.]  Preamble  The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.  This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it.  You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below.  When we speak of free software, we are referring to freedom of use, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things.  To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights.  These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it.  For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you.  You must make sure that they, too, receive or can get the source code.  If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it.  And you must show them these terms so they know their rights.  We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library.  To protect each distributor, we want to make it very clear that there is no warranty for the free library.  Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others.  Finally, software patents pose a constant threat to the existence of any free program.  We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder.  Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license.  Most GNU software, including some libraries, is covered by the ordinary GNU General Public License.  This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License.  We use this license for certain libraries in order to permit linking those libraries into non-free programs.  When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library.  The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom.  The Lesser General Public License permits more lax criteria for linking other code with the library.  We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License.  It also provides other free software developers Less of an advantage over competing non-free programs.  These disadvantages are the reason we use the ordinary General Public License for many libraries.  However, the Lesser license provides advantages in certain special circumstances.  For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard.  To achieve this, non-free programs must be allowed to use the library.  A more frequent case is that a free library does the same job as widely used non-free libraries.  In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License.  In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software.  For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system.  Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library.  The precise terms and conditions for copying, distribution and modification follow.  Pay close attention to the difference between a "work based on the library" and a "work that uses the library".  The former contains code derived from the library, whereas the latter must be combined with the library in order to run.  GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you".  A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables.  The "Library", below, refers to any such software library or work which has been distributed under these terms.  A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language.  (Hereinafter, translation is included without limitation in the term "modification".)  "Source code" for a work means the preferred form of the work for making modifications to it.  For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library.  Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it).  Whether that is true depends on what the Library does and what the program that uses the Library does.  1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library.  You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.  2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:  a) The modified work must itself be a software library.  b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change.  c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License.  d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful.  (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application.  Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.)  These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library.  In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.  3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library.  To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License.  (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.)  Do not make any other change in these notices.  Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy.  This option is useful when you wish to copy part of the code of the Library into a program that is not a library.  4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange.  If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code.  5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library".  Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License.  However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library".  The executable is therefore covered by this License. Section 6 states terms for distribution of such executables.  When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library.  The threshold for this to be true is not precisely defined by law.  If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work.  (Executables containing this object code plus portions of the Library will still fall under Section 6.)  Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself.  6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications.  You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License.  You must supply a copy of this License.  If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License.  Also, you must do one of these things:  a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library.  (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.)  b) Use a suitable shared library mechanism for linking with the Library.  A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with.  c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution.  d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place.  e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy.  For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it.  However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.  It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system.  Such a contradiction means you cannot use both them and the Library together in an executable that you distribute.  7. 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 not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things:  a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities.  This must be distributed under the terms of the Sections above.  b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.  8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License.  However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.  9. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Library or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it.  10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License.  11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all.  For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library.  If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.  This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.  12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.  13. The Free Software Foundation may publish revised and/or new versions of the 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 specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation.  14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.  NO WARRANTY  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Libraries  If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change.  You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License).  To apply these terms, attach the following notices to the library.  It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the library's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA  Also add information on how to contact you by electronic and paper mail.  You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary.  Here is a sample; alter the names:  Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker.  <signature of Ty Coon>, 1 April 1990 Ty Coon, President of Vice  That's all there is to it!


pkgId: f0bd3ee4b3a897f309308a1eb34d9a28f2be3de290e64b58cae7f740cb492a02
name: python-detective-pi-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for detective-pi
url: https://github.com/sergiudm/detective
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-detective-pi-0.1.5-1.src.rpm
location_href: Packages/python-detective-pi-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  detective是一款更适合中国宝宝的室友内卷监测工具，它可以帮助你监测室友的内卷行为，让你的寝室生活更加和谐。
  > TODO：demo

  | 环境   | 版本                         |
  | ------ | ---------------------------- |
  | OS     | Ubuntu22.04, Raspberry Pi OS, Window11, Debian 12|
  | Python | 3.10                         |

  - Raspberry Pi 4B * 2
  - 摄像头 * 2
  - 蜂鸣器
  - LED灯
  - 面包板


  ```bash
  conda create -n <your_env_name> python=3.10
  pip install detective-pi
  ```

  克隆仓库
  ```bash
  git clone https://github.com/sergiudm/detective.git
  cd detective
  ```
  你可以使用`deploy.sh`脚本自动安装
  ```bash
  sudo chmod +x deploy.sh
  ./deploy.sh
  ```
  或者手动安装
  ```bash
  conda create -n <your_env_name> python=3.10
  conda activate <your_env_name>
  pip install -r requirements.txt
  ```

  开始前，你需要配置`config.json`文件，
  以下是一个示例：
  ```json
  {
      "default_detect_mode": "others",
      "use_camera": true,
      "LED_pin": 18, # LED灯的引脚
      "use_visualization": false, # 是否使用可视化
      "server_email": "youremail@example.com",
      "server_email_password": "your email password",# 请使用授权码
      "target_email": [
          "email1",
          "email2"
      ],
      "smtp_server":"your smtp server",
      "smtp_port": 587,
      "video_path": "assets/videos/sit.mp4", # use_camera为false时，使用该视频
      "image_path": "resources", # 邮件中的图片
      "send_delay": 13,
      "effective_detection_duration": 2,
      "max_num_hands": 2,
      "min_detection_confidence": 0.65,
      "min_tracking_confidence": 0.65
  }
  ```
  >[!CAUTION]
  实际使用时，请删除`config.json`中的所有注释!
  Linux:
  ```bash
  sudo chmod +x run.sh
  ./run.sh
  ```
  Windows:
  ```bash
  cd detective
  python main.py
  ```

  - 检测是否有室友在内卷
      - 如果有，会自动响起警报，并且发微信通知你
  - 检测你是不是卷过头了
      - 如果连续工作超过2小时（可在`config.json`中配置），会自动响起警报，并提醒你休息一下
  - to do list
    - 检测 学习 与 玩游戏
      - 肩部、髋部、膝盖 夹角； 手部 位置
    - 报警：蜂鸣器（可换为便宜的喇叭）（直到结束学习才消失）、led、微信发消息
    - 开关门检测
      - 开关门 检测完成后： 人在寝室，才监控
    - 不良坐姿的检测
    - 魔术

  本仓库仅使用了[mediapipe](https://github.com/google-ai-edge/mediapipe)中的人体姿态检测和手部检测功能，如果你有更多想法，欢迎：
  - 提交PR
    - [插件指南]()
  - 提交Issue
  - 传播给更多的室友

  [mediapipe](https://github.com/google-ai-edge/mediapipe)


pkgId: ffb36ce7bb3e1b24f519d08611a8c0133c1adc65ac7a02d569754aa45c19b311
name: python-detroit-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for detroit
url: https://github.com/bourbonut/detroit
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-detroit-2.0.0-1.src.rpm
location_href: Packages/python-detroit-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <img style="border-radius:15px" src="https://raw.githubusercontent.com/bourbonut/detroit/main/docs/source/_static/logo.png"></img>
      <br />
      <a href="https://pypi.org/project/detroit/">
          <img src="https://img.shields.io/pypi/v/detroit.svg?style=flat&logo=pypi" alt="PyPI Latest Release">
      </a>
      <a href='https://detroit.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/detroit/badge/?version=latest' alt='Documentation Status' />
      </a>
      <a href="https://img.shields.io/badge/license-MIT-red.svg?style=flat">
          <img src="https://img.shields.io/badge/License-BSD%203--Clause-blue.svg" alt="BSD-3-Clause">
      </a>
  </p>

  `detroit` is Python implentation of [d3js](https://d3js.org/).

  - [Documentation](https://detroit.readthedocs.io/en/latest/)
  - [Examples](https://github.com/bourbonut/detroit/tree/main/examples)

  <p align="center">
      <img style="width: 70%;" src="https://raw.githubusercontent.com/bourbonut/detroit/main/docs/source/figures/hertz_russel.png"></img>
      <br />
      <a href="https://github.com/bourbonut/detroit/blob/main/examples/hertz_russel.py">Source code</a>
  </p>



  ```sh
  pip install git+https://github.com/bourbonut/detroit.git
  ```



  | Package Name    | Yes / No | Tests OK | Notes                         |
  |-----------------|----------|----------|-------------------------------|
  | array           | Yes      | Yes      |  Not all functions supported  |
  | axis            | Yes      | Yes      |                               |
  | brush           | No       | -        |                               |
  | chord           | No       | -        |                               |
  | color           | Yes      | Yes      |                               |
  | contour         | No       | -        |                               |
  | delaunay        | No       | -        |                               |
  | dispatch        | No       | -        |                               |
  | drag            | No       | -        |                               |
  | dsv             | No       | -        | use `import pandas / polars`  |
  | ease            | No       | -        |                               |
  | fetch           | No       | -        | use `import requests`         |
  | force           | No       | -        |                               |
  | format          | Yes      | Yes      |                               |
  | geo             | No       | -        |                               |
  | hierarchy       | No       | -        |                               |
  | interpolate     | Yes      | Yes      | interpolate CSS not supported |
  | path            | Yes      | Yes      |                               |
  | polygone        | No       | -        |                               |
  | quadtree        | No       | -        |                               |
  | random          | No       | -        | Use `import random`           |
  | scale           | Yes      | Yes      | Mostly `test_linear`          |
  | scale-chromatic | No       | No       | TODO: tests                   |
  | selection       | Yes      | No       | TODO: tests                   |
  | shape           | Yes      | Yes      | Missing most of shapes        |
  | time            | Yes      | Yes      |                               |
  | time-format     | Yes      | Yes      |                               |
  | timer           | No       | -        |                               |
  | transition      | No       | -        |                               |
  | zoom            | No       | -        |                               |

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Benjamin Bourbon  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: cc6418a15dd45f91a54d4b133fdc3218f9f8f22921ea5b6d759111ac0799049c
name: python-device-smi-help
arch: noarch
version: 0.3.3
epoch: 0
release: 1
summary: Development documents and examples for device-smi
url: https://github.com/ModelCloud/Device-SMI/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-device-smi-0.3.3-1.src.rpm
location_href: Packages/python-device-smi-help-0.3.3-1.noarch.rpm
checksum_type: sha256
description:
  Self-contained Python lib with zero-dependencies that give you a unified `device` properties for `gpu`, `cpu`, and `npu`. No more calling separate tools such as `nvidia-smi` or `/proc/cpuinfo` and parsing it yourself.

  <p align="center">
      <a href="https://github.com/ModelCloud/Device-SMI/releases" style="text-decoration:none;"><img alt="GitHub release" src="https://img.shields.io/github/release/ModelCloud/Device-SMI.svg"></a>
      <a href="https://pypi.org/project/device-smi/" style="text-decoration:none;"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/device-smi"></a>
      <a href="https://pepy.tech/projects/device-smi" style="text-decoration:none;"><img src="https://static.pepy.tech/badge/device-smi" alt="PyPI Downloads"></a>
      <a href="https://github.com/ModelCloud/Device-SMI/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/device-smi" alt="License"></a>
      <a href="https://huggingface.co/modelcloud/"><img src="https://img.shields.io/badge/🤗%20Hugging%20Face-ModelCloud-%23ff8811.svg"></a>
  </p>


  * 12/20/2024 [0.3.3](https://github.com/ModelCloud/Device-SMI/releases/tag/v0.3.3) Patch fix for Windows install compatibility.
  * 12/05/2024 [0.3.2](https://github.com/ModelCloud/Device-SMI/releases/tag/v0.3.2) Added Windows `WSL` support.
  * 12/03/2024 [0.3.1](https://github.com/ModelCloud/Device-SMI/releases/tag/v0.3.1) Added `CPUDevice` compat for Windows.
  * 12/02/2024 [0.3.0](https://github.com/ModelCloud/Device-SMI/releases/tag/v0.3.0) Added `OSDevice`.[`name`, `version`, `kernel`, `arch`] for Linux/MacOS/Windows/FreeBSD/Solaris. Added `cpu.`[`count`, `cores`, `threads`] properties. Bug fix for gpu device index.
  * 11/29/2024 [0.2.1](https://github.com/ModelCloud/Device-SMI/releases/tag/v0.2.1) Added `pcie.`[`gen`, `speed`, `id`] + [`firmware`, `driver`] properties to `GPU` device.



  - Retrieve information for both CPU and GPU devices.
  - Includes details about memory usage, utilization, driver, pcie info when applicable, and other device specifications.
  - Zero pypi dependency.
  - Linux/MacOS support

  Supported Devices:

  - **OS**: Linux, MacOS, Windows, FreeBSD, Solaris
  - **CPU**: [Intel/AMD/Apple] Linux/MacOS system interface
  - **NVIDIA GPU**: NVIDIA System Management Interface `nvidia-smi`
  - **Intel XPU**: Intel/XPU System Management Interface `xpu-smi`
  - **Apple GPU**: MacOS interfaces



  For OS, use `os` to init a new Device object.

  ```py
  from device_smi import Device

  dev = Device("os")
  print(dev)
  ```

  Output: (Ubuntu 22.04)

  > {'type': 'os', 'name': 'ubuntu', 'version': '22.04', 'kernel': '6.12.1-x64v3-xanmod2', 'arch': 'x86_64'}

  For GPU/XPU, use [`gpu`, `cuda`] for Nvidia and `xpu` for Intel/XPU. Index usage for multiple GPUs: `cuda:0`

  ```py
  from device_smi import Device

  dev = Device("cuda:0")
  print(dev)
  ```

  Output: (Nvidia 4090)

  > {'pcie': {'gen': 2, 'speed': 1, 'id': '00000000:16:00.0'}, 'gpu': {'driver': '565.57.01', 'firmware': '95.02.3C.40.E7'}, 'type': 'gpu', 'model': 'geforce rtx 4090', 'memory_total': 25757220864, 'vendor': 'nvidia', 'features': ['8.9']}

  For CPU, use `cpu` to init a new Device object.

  ```py
  from device_smi import Device

  dev = Device("cpu")
  print(dev)
  ```

  Output: (AMD EPYC 7443)

  > {'type': 'cpu', 'model': 'epyc 7443', 'vendor': 'amd', 'memory_total': 1000000000000, 'count': 2, 'cores': 48, 'threads': 96, 'features': ['3dnowprefetch', 'abm', 'adx', 'aes', 'amd_ppin', 'aperfmperf', 'apic', 'arat', 'avx', 'avx2', 'bmi1', 'bmi2', 'bpext', 'brs', 'cat_l3', 'cdp_l3', 'clflush', 'clflushopt', 'clwb', 'clzero', 'cmov', 'cmp_legacy', 'constant_tsc', 'cpb', 'cpuid', 'cqm', 'cqm_llc', 'cqm_mbm_local', 'cqm_mbm_total', 'cqm_occup_llc', 'cr8_legacy', 'cx16', 'cx8', 'de', 'debug_swap', 'decodeassists', 'erms', 'extapic', 'extd_apicid', 'f16c', 'flushbyasid', 'fma', 'fpu', 'fsgsbase', 'fsrm', 'fxsr', 'fxsr_opt', 'ht', 'hw_pstate', 'ibpb', 'ibrs', 'ibs', 'invpcid', 'irperf', 'lahf_lm', 'lbrv', 'lm', 'mba', 'mca', 'mce', 'misalignsse', 'mmx', 'mmxext', 'monitor', 'movbe', 'msr', 'mtrr', 'mwaitx', 'nonstop_tsc', 'nopl', 'npt', 'nrip_save', 'nx', 'ospke', 'osvw', 'overflow_recov', 'pae', 'pat', 'pausefilter', 'pcid', 'pclmulqdq', 'pdpe1gb', 'perfctr_core', 'perfctr_llc', 'perfctr_nb', 'pfthreshold', 'pge', 'pku', 'pni', 'popcnt', 'pse', 'pse36', 'rapl', 'rdpid', 'rdpru', 'rdrand', 'rdseed', 'rdt_a', 'rdtscp', 'rep_good', 'sep', 'sha_ni', 'skinit', 'smap', 'smca', 'smep', 'ssbd', 'sse', 'sse2', 'sse4_1', 'sse4_2', 'sse4a', 'ssse3', 'stibp', 'succor', 'svm', 'svm_lock', 'syscall', 'tce', 'topoext', 'tsc', 'tsc_scale', 'umip', 'user_shstk', 'v_spec_ctrl', 'v_vmsave_vmload', 'vaes', 'vgif', 'vmcb_clean', 'vme', 'vmmcall', 'vpclmulqdq', 'wbnoinvd', 'wdt', 'xgetbv1', 'xsave', 'xsavec', 'xsaveerptr', 'xsaveopt', 'xsaves', 'xtopology']}




  - Support AMD GPU
  - Support Intel/Gaudi
  - Support Google/TPU
  - Add NPU support (ARM/Intel/AMD)


pkgId: 34c6cd31d7f0779eae191e38d0f0d12ca6f7ee0729ece539a80221dc3d0f1172
name: python-devious-help
arch: noarch
version: 0.9.0
epoch: 0
release: 1
summary: Development documents and examples for devious
url: https://github.com/flxtrtwn/devious
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-devious-0.9.0-1.src.rpm
location_href: Packages/python-devious-help-0.9.0-1.noarch.rpm
checksum_type: sha256
description:
  Devious is a command line utility to manage the lifecycle of applications in a mono repository.
  It is developed in the context of a VSCode-based development container template (see [devious](https://github.com/flxtrtwn/devious)).



  -   `create`, `build`, `test`, `debug` applications locally
  -   `deploy`, `run` and `stop` applications (e.g. on remote machines)
  -   Manage remote machines and `install` infrastructure



  Devious features an extensible target model and can provide functionality for any application type that implements the `Target` interface.
  It currently supports `microservice` and `django_app` targets and can manage their lifecycle.


pkgId: 793b3b378669a9117192341d3bd2ed83a741b0018e901121a97bc83ce7ebb26b
name: python-devkit-math-debuginfo
arch: aarch64
version: 1.5.0a1
epoch: 0
release: 1
summary: Debug information for package python-devkit-math
url: https://pypi.org/project/devkit-math/
rpm_license: MIT
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-devkit-math-1.5.0a1-1.src.rpm
location_href: Packages/python-devkit-math-debuginfo-1.5.0a1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-devkit-math.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 2fdb51c898f5c7a73edc2b29ff9985769e7a22f79e92a56801039d30bdcd4edd
name: python-devkit-math-debugsource
arch: aarch64
version: 1.5.0a1
epoch: 0
release: 1
summary: Debug sources for package python-devkit-math
url: https://pypi.org/project/devkit-math/
rpm_license: MIT
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-devkit-math-1.5.0a1-1.src.rpm
location_href: Packages/python-devkit-math-debugsource-1.5.0a1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-devkit-math.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 9bbe88634262f9eca39d6c8eeb21d2adc83511168ac0c7b6955ffa2654091fc8
name: python-devstack-cli-help
arch: noarch
version: 10.0.157
epoch: 0
release: 1
summary: Development documents and examples for devstack-cli
url: https://cloudomation.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-devstack-cli-10.0.157-1.src.rpm
location_href: Packages/python-devstack-cli-help-10.0.157-1.noarch.rpm
checksum_type: sha256
description:
  The `devstack-cli` provides command-line access to Remote Development Environments (RDEs) created by Cloudomation DevStack. Learn more about [Cloudomation DevStack](https://docs.cloudomation.com/devstack/docs/overview-and-concept).



  The following binaries must be installed to be able to use `devstack-cli`:

  * `ssh`
  * `ssh-keyscan`
  * `rsync`
  * `git`

  On Debian/Ubuntu the packages can be installed with

  ```
  apt install openssh-client rsync git
  ```

  Then you can install `devstack-cli` by running

  ```
  python -m pip install devstack-cli
  ```



  ```
  usage: devstack-cli [-h] -H HOSTNAME -s SOURCE_DIRECTORY [-o OUTPUT_DIRECTORY] [-v]
  ```

  You need to specify the hostname/IP of the RDE created by Cloudomation DevStack as well as the path to a directory where the sources will be cached locally. Optionally you can specify an output directory where artifacts created on the RDE will be stored locally.
  The `-v` switch enables debug logging.



  `devstack-cli` is part of Cloudomation DevStack and support is provided to you with an active subscription.



  Cloudomation actively maintains the `devstack-cli` command line tool as part of Cloudomation DevStack



  Copyright (c) 2024 Starflows OG

  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: 8128cb255d78742eee2ea2146443957173aabc18be6104971bff527e6fbd53de
name: python-dew-gwdata-help
arch: noarch
version: 0.88
epoch: 0
release: 1
summary: Development documents and examples for dew-gwdata
url: http://github.com/dew-waterscience/dew_gwdata
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dew-gwdata-0.88-1.src.rpm
location_href: Packages/python-dew-gwdata-help-0.88-1.noarch.rpm
checksum_type: sha256
description:
  Python module for accessing groundwater data internally at DEW



  The source code is on [Bitbucket](https://bitbucket.org/dewsurfacewater/dew_gwdata), while Python packages (source and binary) are published on
  the [Python Package Index](https://pypi.org/project/dew-gwdata/) and
  on a dedicated channel on [Anaconda Cloud](https://anaconda.org/dew-waterscience/repo).



  Run this in Command Prompt to install from PyPI:

  ```
  pip install dew_gwdata
  ```

  To upgrade to the latest version:

  ```
  pip install -U dew_gwdata
  ```



  You can also install using conda/mamba if you prefer:

  ```
  mamba install -c dew-waterscience dew_gwdata
  ```

  To upgrade:

  ```
  mamba upgrade -c dew-waterscience dew_gwdata
  ```

  The version may not be as up-to-date as the PyPI version.



  This is how you can install the latest version of the source code directly from Bitbucket (the version control repository):

  ```
  python -m pip install git+https://kinveraritysagov@bitbucket.org/dewsurfacewater/dew_gwdata.git
  ```

  You will need to replace ``kinveraritysagov`` with your Bitbucket username, and you will also need access to the source repository on the Bitbucket dewsurfacewater workspace.



  Check out complete documentation at:

  [http://bunyip:8191/python-docs/dew_gwdata/latest_source/index.html](http://bunyip:8191/python-docs/dew_gwdata/latest_source/index.html)



  All rights reserved DEW 2023


pkgId: 66449ff24d688a41984a5dde56c67d158849937ce939c306b166a1113a332ff0
name: python-dfcx-scrapi-help
arch: noarch
version: 1.13.1
epoch: 0
release: 1
summary: Development documents and examples for dfcx-scrapi
url: https://github.com/GoogleCloudPlatform/dfcx-scrapi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dfcx-scrapi-1.13.1-1.src.rpm
location_href: Packages/python-dfcx-scrapi-help-1.13.1-1.noarch.rpm
checksum_type: sha256
description:
  If you're using SCRAPI with [Cloud Functions](https://cloud.google.com/functions) or [Cloud Run](https://cloud.google.com/run), SCRAPI can pick up on the default environment creds used by these services without any additional configuration!
  1. Add `dfcx-scrapi` to your `requirements.txt` file
  2. Ensure the Cloud Function / Cloud Run service account has the appropriate Dialogflow IAM Role
  Once you are setup with the above, your function code can be used easily like this:
  ```py
  from dfcx_scrapi.core.intents import Intents
  agent_id = '<YOUR_AGENT_ID>'
  i = Intents() # <-- Creds will be automatically picked up from the environment
  intents_map = i.get_intents_map(agent_id)


pkgId: d0a62c425f0fe9617d11443cefc3d1dfaacd7969218259482e5f560fb1fcb22d
name: python-dfhelper-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for dfhelper
url: https://github.com/kodurd/dfhelper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dfhelper-0.0.5-1.src.rpm
location_href: Packages/python-dfhelper-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Dfhelper is a versatile Python package that streamlines data preprocessing and visualization in Jupyter Notebooks.
  With intuitive functions for cleaning and transforming pandas DataFrames and the ability to render them as interactive
  HTML tables, this toolkit is an essential addition to any data scientist's arsenal. Simplify your data analysis process
  and gain clearer insights with dfhelper.


  ```
  !pip install dfhelper
  ```


  1) Output date frames in HTML. This is extremely useful when working with multiple selections
  2) Output in HTML df.info() multiple dataframes
  3) Output the size of the date frames in html.
  4) The ability to display dataframes vertically and horizontally
  5) Functions for summarizing the date of Ephraim, created for conducting EDA


  ```python
  import pandas as pd
  from dfhelper.viz import df_view, df_info_view, df_shape_view
  from dfhelper.scout import summarize_df, summarize_dfs



  df1 = pd.DataFrame(
              {"A": [1, 0, 0, None],
               "B": [1, 1, 2, 2],
               "C": [None, None, None, None]}
          )

  df2 = pd.DataFrame(
              {"A": [1, 5, 0, 10],
               "B": [1, 1, 2, 2],
               "C": [None, 4, 16, 101]}
          )


  df_view(df1, df2)

  df_info_view(df1, df2)

  df_shape_view(df1, df2)



  summarize_df(df1)

  summarize_dfs(df1, df2)
  ```


pkgId: 2f45eb01519d001313a9e5b88f87047c75bbedef0a8ce74dce8dd949d559c766
name: python-dfpyre-help
arch: noarch
version: 0.7.3
epoch: 0
release: 1
summary: Development documents and examples for dfpyre
url: https://github.com/Amp63/pyre
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dfpyre-0.7.3-1.src.rpm
location_href: Packages/python-dfpyre-help-0.7.3-1.noarch.rpm
checksum_type: sha256
description:
  A package for external creation of code templates for the DiamondFire Minecraft server (mcdiamondfire.com).

  PyPi Link: https://pypi.org/project/dfpyre/



  Run the following command in a terminal:
  ```
  pip install dfpyre
  ```


  - All code block types
  - All code item types
  - Direct sending to DF via recode or codeclient
  - Automatic type conversion (int to num, str to text)
  - Name checking ("did you mean ___?" for close matches)
  - Default tag values




  - [Setting up a program](#setup)
  - [Events and Actions](#events-and-actions)
  - [Building](#building)



  - [Text](#text)
  - [Number](#number)
  - [Variable](#variable)
  - [Location](#location)
  - [Item](#item)
  - [Sound](#sound)
  - [Particle](#particle)
  - [Potion](#potion)
  - [Game Value](#game-value)
  - [Vector](#vector)
  - [Parameter](#parameter)



  - [Conditionals and Brackets](#conditionals-and-brackets)
  - [Loops](#loops)



  - [Creating Functions and Processes](#creating-functions-and-processes)
  - [Calling Functions and Processes](#calling-functions-and-processes)



  - [Editing Tags](#editing-tags)
  - [Importing from Code](#importing-from-code)
  - [Script Generation](#script-generation)
  - [Method List](#method-list)

  ___



  To start creating in pyre, you have to create a DFTemplate object like so:

  ```py
  from dfpyre import *
  t = DFTemplate()
  ```

  Basically everything stems from this template object.

  This is the basic layout of a file:

  ```py
  from dfpyre import *
  t = DFTemplate()


  t.build()
  ```

  The commented lines represent where you will insert calls to methods in the template object.

  Here's a complete program that prints a message to every player when a player joins:

  ```py
  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.player_action('SendMessage', '%default has joined!', target=Target.ALL_PLAYERS)
  t.build_and_send('codeclient')
  ```



  You can find a list of events and actions [here](#method-list)

  As shown in [setup](#setup), every code line must start with an event, function, or process. After that, you're free to put anything you want.

  The following program sends a message to all players and gives a player 10 apples upon joining:

  ```py
  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.player_action('SendMessage', '%default has joined!', target=Target.ALL_PLAYERS)
  t.player_action('GiveItems', item('apple', 10))
  ```



  You have 2 different options for building your code line.
  You can either:

  1. Save the compressed template code to a variable and send it to minecraft later
  2. Build and send directly to your minecraft client (recommended)

  If you choose the first option, the code would look something like this:

  ```py
  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.player_action('SendMessage', '%default has joined!', target=Target.ALL_PLAYERS)
  template_code = t.build()  # do whatever you want with this
  ```

  If you choose the second option, you can do this:

  ```py
  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.player_action('SendMessage', '%default has joined!', target=Target.ALL_PLAYERS)
  t.build_and_send('codeclient')  # builds and sends automatically to minecraft
  ```





  Represents a diamondfire text item:

  ```py
  text('hello %default.')
  ```

  If a regular string is passed to a method as a chest parameter, it will automatically be converted to a text object:

  ```py

  t.player_action('SendMessage', text('%default joined.'))
  t.player_action('SendMessage', '%default joined.')
  ```



  Represents a diamondfire number item:

  ```py
  num(5)
  num(3.14)
  ```

  If a regular integer or float is passed to a method as a chest parameter, it will automatically be converted to a num object:

  ```py

  t.set_variable('=', var('number'), num(10))
  t.set_variable('=', var('number'), 10)
  ```



  Represents a diamondfire variable item:

  ```py
  var('num')
  var('text1')
  ```

  You can set variable values by using the `set_variable` method:

  ```py
  t.set_variable('=', var('num'), 12)  # sets 'num' to 12
  t.set_variable('x', var('doubled'), var('num'), 2)  # sets 'doubled' to 24
  ```

  You can set the scope of the variable by using the `scope` argument:

  ```py
  t.set_variable('=', var(num1, scope='unsaved'), 12)  # `unsaved` is the same as a game variable.
  t.set_variable('=', var(num1, scope='saved'), 12)
  t.set_variable('=', var(num1, scope='local'), 12)
  ```



  You can also use the variable shorthand format like this:
  ```py

  t.set_variable('=', var('lineVar', scope='line'), 5)
  t.set_variable('=', '$ilineVar', 5)
  ```

  Shorthand vars should be formatted like this: `$[scope id][var name]`

  Here's a list of the scope IDs:
  - `g` = Game (unsaved)
  - `s` = Saved
  - `l` = Local
  - `i` = Line



  Represents a diamondfire location item:

  ```py
  loc(x=25.5, y=50, z=25.5, pitch=0, yaw=-90)
  ```

  Example:

  ```py

  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.player_action('Teleport', loc(10, 50, 10))
  ```



  Represents a minecraft item:

  ```py
  item('stick', count=5)
  item('stone', 64)
  ```

  To add extra data to an item, you can use any methods from the [mcitemlib](https://github.com/Amp63/mcitemlib) library



  Represents a diamondfire sound item:

  ```py
  sound('Wood Break', pitch=1.5, vol=2.0)
  ```

  Example:

  ```py

  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.player_action('PlaySound', sound('Grass Place'))
  ```



  Represents a diamondfire particle item:

  ```py
  particle({'particle':'Cloud','cluster':{'amount':1,'horizontal':0.0,'vertical':0.0},'data':{'x':1.0,'y':0.0,'z':0.0,'motionVariation':100}})
  ```

  Example:

  ```py

  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  part = particle({'particle':'Cloud','cluster':{'amount':1,'horizontal':0.0,'vertical':0.0},'data':{'x':1.0,'y':0.0,'z':0.0,'motionVariation':100}})
  t.player_action('Particle', part, loc(5, 50, 5))
  ```

  Currently, the particle object does not support colors.



  Represents a diamondfire potion item:

  ```py

  potion('Speed', dur=1200, amp=0)
  ```

  Example:

  ```py

  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.player_action('GivePotion', potion('Saturation', amp=254))
  ```



  Represents a diamondfire game value item:

  ```py
  gamevalue('Player Count')
  gamevalue('Location' target='Selection')
  ```

  Example:

  ```py

  from dfpyre import *
  t = DFTemplate()
  t.function('printData')
  t.player_action('SendMessage', gamevalue('Player Count'), gamevalue('CPU Usage'))
  ```



  Represents a diamondfire vector item:

  ```py
  vector(x=1.1, y=0.0, z=0.5)
  ```

  Example:

  ```py

  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.player_action('SetVelocity', vector(x=1.0, y=0.0, z=0.0))
  ```



  Represents a diamondfire parameter item:

  ```py
  parameter('text', ParameterType.STRING)
  ```

  Example:

  ```py

  from dfpyre import *
  t = DFTemplate()
  name_parameter = parameter('name', ParameterType.TEXT)
  t.function('SayHi', name_parameter)
  t.player_action('SendMessage', 'Hello, ', var('name', 'line'))
  ```



  A list of conditionals and loops can be found [here](#method-list).

  A specific syntax must be followed when creating conditionals and loops. Each conditional statement must be followed by a `bracket()` method, which will contain code. Here's an example:

  ```py

  from dfpyre import *
  t = DFTemplate()
  t.player_event('RightClick')
  t.if_player('IsHolding', item('stick'))
  t.bracket(
      t.player_action('SendMessage', 'clicked')
  )
  ```

  To create an `else` statement, use the `else_` method:

  ```py

  from dfpyre import *
  t = DFTemplate()
  t.function('grounded')
  t.if_player('IsGrounded')
  t.bracket(
      t.player_action('ActionBar', 'on the ground')
  )
  t.else_()
  t.bracket(
      t.player_action('ActionBar', 'in the air')
  )
  ```



  As for loops, the bracket syntax is the same and will automatically change to "repeat-type" brackets:

  ```py

  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.repeat('Multiple', var('i'), 5)
  t.bracket(
      t.player_action('SendMessage', var('i'))
  )
  ```



  To create a function or process, just start the template with a `function` or `process` method:

  ```py

  from dfpyre import *
  t = DFTemplate()
  t.function('doStuff')
  t.player_action('GiveItems', item('golden_apple', 64))
  ```



  Calling Functions and processes is also simple:

  ```py
  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.call_function('doStuff')
  ```


  You can edit an action's tags by passing the `tags` argument to a template method:

  ```py
  from dfpyre import *
  t = DFTemplate()
  t.player_event('Join')
  t.player_action('SendMessage', 'hello', tags={'Alignment Mode': 'Centered'})
  ```

  If you choose not to modify a specific tag, its default value will be used.
  Order does not matter when adding multiple tag entries.



  You can import existing templates from their built code using the `from_code` method:

  ```py
  from dfpyre import *
  template_code = 'H4sIAGVyIGYC/3WOMQ7CMAxFz4LnDsw5AhITI6qQSaw2IrGrxkJCVe5eh3boAJP9n/Kfs8AziX8VcPcFYgC3Zej26YDexGoZvUZhAxeJ3PI8WMtKSrnV+1q7P4op4Yfmx244qG7E4Uql4EA/jNv2Jc3qJU/2KqBiY4yZjI6UkpzAjkNJouDO1X7S1xUDaGUl2QAAAA=='

  t = DFTemplate.from_code(template_code)

  ```




  You can also generate an equivalent python script for a template from a template object:

  ```py
  from dfpyre import *
  template_code = 'H4sIAGVyIGYC/3WOMQ7CMAxFz4LnDsw5AhITI6qQSaw2IrGrxkJCVe5eh3boAJP9n/Kfs8AziX8VcPcFYgC3Zej26YDexGoZvUZhAxeJ3PI8WMtKSrnV+1q7P4op4Yfmx244qG7E4Uql4EA/jNv2Jc3qJU/2KqBiY4yZjI6UkpzAjkNJouDO1X7S1xUDaGUl2QAAAA=='

  t = DFTemplate.from_code(template_code)
  t.generate_script('my_template.py')    # generated python script will be written to my_template.py
  ```



  - Events / Function / Process
    - player_event
    - entity_event
    - function
    - process
    - call_function
    - start_process

  - Actions
    - player_action
    - game_action
    - entity_action

  - Conditionals / Loops
    - if_player
    - if_variable
    - if_game
    - if_entity
    - else_
    - repeat
    - bracket

  - Other
    - control
    - select_object
    - set_variable


pkgId: f3748c9a080b097cec0e42ce69ba0c0432089e7af7751a21ab0a1d1a7fb43d9a
name: python-dgii-rnc-help
arch: noarch
version: 0.6
epoch: 0
release: 1
summary: Development documents and examples for dgii-rnc
url: https://github.com/lcgarc1a/dgii_rnc
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dgii-rnc-0.6-1.src.rpm
location_href: Packages/python-dgii-rnc-help-0.6-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/dgii-rnc)](https://pypi.org/project/dgii-rnc/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dgii-rnc)](https://www.python.org/downloads/)
   ![PyPI - Status](https://img.shields.io/pypi/status/dgii-rnc) [![changelog](https://img.shields.io/badge/changelog-5A5A5A)](./CHANGELOG.md)

  Simple tool to load the dataset of taxpayers of the Dominican Republic. It can be used to correct data on names or IDs registered in some data source, as well as being integrated into a much larger application.

  Source: [https://www.dgii.gov.do/app/WebApps/Consultas/RNC/DGII_RNC.zip]



  ```python
  pip install dgii-rnc
  ```



  - Polars
  - Selenium





  ```python
  from dgii_rnc.dgii_rnc import dgii_handler
  import polars as pl

  df = dgii_handler.rnc_df()

  df.shape
  (735018, 7)

  df.filter(pl.col("NOMBRE").str.contains("BANCO CENTRAL"))
  shape: (4, 7)
  +-----------+----------------+----------------+---------------+------------+--------------+--------+
  | ID        | NOMBRE         | NOMBRE_COMERCI | CATEGORIA     | FECHA      | REGIMEN_PAGO | ESTADO |
  | ---       | ---            | AL             | ---           | ---        | ---          | ---    |
  | str       | str            | ---            | str           | str        | str          | str    |
  |           |                | str            |               |            |              |        |
  +==================================================================================================+
  | 401007551 | BANCO CENTRAL  | null           | SERV GRALES   | 23/10/1947 | ACTIVO       | NORMAL |
  |           | DE LA          |                | DE LA ADM     |            |              |        |
  |           | REPUBLICA      |                | PÚBLICA       |            |              |        |
  |           | DOMINICANA     |                |               |            |              |        |
  | 430027715 | ARS PLAN SALUD | ARS BANCO      | ADMINISTRACIO | 23/06/2003 | ACTIVO       | NORMAL |
  |           | BANCO CENTRAL  | CENTRAL        | N DE RIESGOS  |            |              |        |
  |           |                |                | DE S          |            |              |        |
  | 401508583 | FONDO DE       | null           | ADMINISTRACIÓ | 24/02/1999 | ACTIVO       | NORMAL |
  |           | JUBILACIONES Y |                | N DE FONDOS   |            |              |        |
  |           | PENSIONES DEL  |                | DE PE         |            |              |        |
  |           | PERSONAL DEL   |                |               |            |              |        |
  |           | BANCO CENTRAL  |                |               |            |              |        |
  | 430118591 | CLUB EMPLEADOS | CLUB EMPLEADOS | SERV. DE      | 08/09/2011 | ACTIVO       | NORMAL |
  |           | DEL BANCO      | DEL BANCO      | ORGANIZACIÓN, |            |              |        |
  |           | CENTRAL        | CENTRAL        | DIRECCI       |            |              |        |
  +-----------+----------------+----------------+---------------+------------+--------------+--------+
  ```





  ```python

  search_query = dgii_handler.search({'NOMBRE':'BANCO CENTRAL DE LA REPUBLICA'})
  print(search_query)
  shape: (1, 7)
  +-----------+----------------+----------------+---------------+------------+--------------+--------+
  | ID        | NOMBRE         | NOMBRE_COMERCI | CATEGORIA     | FECHA      | REGIMEN_PAGO | ESTADO |
  | ---       | ---            | AL             | ---           | ---        | ---          | ---    |
  | str       | str            | ---            | str           | str        | str          | str    |
  |           |                | str            |               |            |              |        |
  +==================================================================================================+
  | 401007551 | BANCO CENTRAL  | null           | SERV GRALES   | 23/10/1947 | ACTIVO       | NORMAL |
  |           | DE LA          |                | DE LA ADM     |            |              |        |
  |           | REPUBLICA      |                | PÚBLICA       |            |              |        |
  |           | DOMINICANA     |                |               |            |              |        |
  +-----------+----------------+----------------+---------------+------------+--------------+--------+
  ```



  ```python

  web_search_query = dgii_handler.web_search('401007551')
  web_search_query.to_dicts()
  [{'Cédula/RNC': '401-00755-1',
   'Nombre/Razón Social': 'BANCO CENTRAL DE LA REPUBLICA DOMINICANA',
   'Nombre Comercial': ' ',
   'Categoría': '',
   'Régimen de pagos': 'NORMAL',
   'Estado': 'ACTIVO',
   'Actividad Economica': 'SERV GRALES DE LA ADM PÚBLICA (INCL. EL DESEMPEÑO DE FUNCIONES EJECUTIVAS Y LEGISLATIVAS DE ADM POR PARTE DE LAS ENTIDADES DE LA A',
   'Administracion Local': 'ADM LOCAL GGC'}]
  ```



  ```python
  df = df.to_pandas()
  ```


pkgId: 2967198688e90aa0b62b814b9b4dca971b465576e136c4363bf4928f94615d45
name: python-dgpsi-help
arch: noarch
version: 2.5.0
epoch: 0
release: 1
summary: Development documents and examples for dgpsi
url: https://github.com/mingdeyu/DGP
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dgpsi-2.5.0-1.src.rpm
location_href: Packages/python-dgpsi-help-2.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub release (latest by date including pre-releases)](https://img.shields.io/github/v/release/mingdeyu/DGP?display_name=release&include_prereleases&style=flat-square)](https://github.com/mingdeyu/DGP/releases)
  [![Conda](https://img.shields.io/conda/dn/conda-forge/dgpsi?label=Conda%20Downloads&style=flat-square)](https://anaconda.org/conda-forge/dgpsi)
  ![Conda](https://img.shields.io/conda/pn/conda-forge/dgpsi?color=orange&style=flat-square)
  [![Read the Docs (version)](https://img.shields.io/readthedocs/dgpsi/latest?style=flat-square)](https://dgpsi.readthedocs.io)
  [![GitHub R package version](https://img.shields.io/github/r-package/v/mingdeyu/dgpsi-R)](https://github.com/mingdeyu/dgpsi-R)


  The `R` interface to the package is available at [`dgpsi-R`](https://github.com/mingdeyu/dgpsi-R).


  `dgpsi` currently implements:

  * Gaussian process emulations with separable or non-separable squared exponential and Mat&eacute;rn-2.5 kernels.
  * Deep Gaussian process emulation with flexible architecture construction:
      - multiple layers;
      - multiple GP nodes;
      - separable or non-separable squared exponential and Mat&eacute;rn2.5 kernels;
      - global input connections;
      - non-Gaussian likelihoods (Poisson, Negative-Binomial, heteroskedastic Gaussian, and categorical);
  * Linked emulation of feed-forward systems of computer models:
      - linking GP emulators of deterministic individual computer models;
      - linking GP and DGP emulators of deterministic individual computer models;
  * Multi-core predictions from GP, DGP, and Linked (D)GP emulators;
  * Fast Leave-One-Out (LOO) cross validations for GP and DGP emulators.
  * Calculations of ALM, MICE, and VIGF sequential design criterions.
  * ![Feature Badge](https://img.shields.io/badge/Feature-New-orange) [Large-scale GP, DGP, and Linked (D)GP emulations.](https://github.com/mingdeyu/DGP/blob/master/demo/vecchia_SI.ipynb)
  * ![Feature Badge](https://img.shields.io/badge/Feature-New-orange) [Scalable DGP classification using Stochastic Imputation.](https://github.com/mingdeyu/DGP/blob/master/demo/DGP_classification.ipynb)


  `dgpsi` currently requires Python version 3.7, 3.8, 3.9, or 3.10. The package can be installed via `pip`:

  ```bash
  pip install dgpsi
  ```

  or `conda`:

  ```bash
  conda install -c conda-forge dgpsi
  ```

  However, to gain the best performance of the package or you are using an Apple Silicon computer, we recommend the following steps for the installation:
  * Download and install `Miniforge3` that is compatible to your system from [here](https://github.com/conda-forge/miniforge).
  * Run the following command in your terminal app to create a virtual environment called `dgp_si`:

  ```bash
  conda create -n dgp_si python=3.9.13
  ```

  * Activate and enter the virtual environment:

  ```bash
  conda activate dgp_si
  ```

  * Install `dgpsi`:
      - for Apple Silicon users, you could gain speed-up by switching to Apple's Accelerate framework:

      ```bash
      conda install dgpsi "libblas=*=*accelerate"
      ```

      - for Intel users, you could gain speed-up by switching to MKL:

      ```bash
      conda install dgpsi "libblas=*=*mkl"
      ```

      - otherwise, simply run:
      ```bash
      conda install dgpsi
      ```


  Please see [demo](https://github.com/mingdeyu/DGP/tree/master/demo) for some illustrative examples of the method. The API reference
  of the package can be accessed from [https://dgpsi.readthedocs.io](https://dgpsi.readthedocs.io).


  * Since SI is a stochastic inference, in case of unsatisfactory results, you may want to try to restart the training multiple times even with initial values of hyperparameters unchanged;
  * The recommended DGP structure is a two-layered one with the number of GP nodes in the first layer equal to the number of input dimensions (i.e., number of input columns) and the number of GP nodes in the second layer equal to the number of output dimensions (i.e., number of output columns) or the number of parameters in the specified likelihood.


  Please feel free to email me with any questions and feedbacks:

  Deyu Ming <[deyu.ming.16@ucl.ac.uk](mailto:deyu.ming.16@ucl.ac.uk)>.


  This package is part of an ongoing research initiative. For detailed information about the research aspects and guidelines for use, please refer to our [Research Notice](./RESEARCH-NOTICE.md).


  > [Ming, D. and Williamson, D. (2023) Linked deep Gaussian process emulation for model networks. arXiv:2306.01212.](https://arxiv.org/abs/2306.01212)

  > [Ming, D., Williamson, D., and Guillas, S. (2023) Deep Gaussian process emulation using stochastic imputation. <i>Technometrics</i>. 65(2), 150-161.](https://doi.org/10.1080/00401706.2022.2124311)

  > [Ming, D. and Guillas, S. (2021) Linked Gaussian process emulation for systems of computer models using Mat&eacute;rn kernels and adaptive design, <i>SIAM/ASA Journal on Uncertainty Quantification</i>. 9(4), 1615-1642.](https://epubs.siam.org/doi/abs/10.1137/20M1323771)


pkgId: f4c0f9e028ef8c7e7ad04fc12093f82d294a6e4da92db1e0e61160151e1e8acb
name: python-dheapy-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for dheapy
url: https://github.com/vandasari/dheapy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dheapy-0.1.1-1.src.rpm
location_href: Packages/python-dheapy-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  `dheapy` is a pure Python implementation of $d$-ary heap data structure for priority queue applications, which can work for both max-heap and min-heap variants. The factor $d$ in $d$-ary heap is called the branching factor and it can be equal to or greater than $2$, where $d=2$ means the heap is built with a binary tree, $d=3$ with a ternary tree, $d=4$ with a quaternary tree, and so on.

  The branching factor of a tree is the maximum number of children a node can have.

  A $2$-ary heap or binary heap has a branching factor of $2$:
  ![Binary Heap](https://raw.githubusercontent.com/vandasari/dheapy/main/images/ex1_binary_tree.png)

  A $3$-ary heap or ternary heap has a branching factor of $3$:
  ![Ternary Heap](https://raw.githubusercontent.com/vandasari/dheapy/main/images/ex2_ternary_tree.png)

  A $4$-ary heap or quaternary heap has a branching factor of $4$:
  ![Quarternary Heap](https://raw.githubusercontent.com/vandasari/dheapy/main/images/ex3_quarternary_tree.png)

  `dheapy` is array-based and adaptable, where arbitrary items can be removed, updated, and displayed on the go.

  The library also comes with a sorting function that is based on the heap-sort algorithm to sort lists of tuples.



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

  ```
  pip install dheapy
  ```



  None.



  1.  `DHeap(branching_factor=2, variant='max')`
      Class to create an empty and perform priority queue operations (shown in the table below).
      Parameters:

      - `branching_factor`: `int`; default = `2`
      - `variant`: `str`, either `'max'` or `'min'`; default = `'max'`

  2.  `heapsorted(object, branching_factor=2, variant='max')`
      Function for sorting arrays that is based on the heap sort algorithm.
      Parameters:
      - `object`: array or iterable
      - `branching_factor`: `int`; default = `2`
      - `variant`: `str`, either `'max'` or `'min'`; default = `'max'`

  To create an empty priority queue with branching factor 3 and min-heap variant:

  ```
  from dheapy import DHeap

  P = DHeap(3, 'min')
  ```

  then the following operations can be performed:

  | **Operation**                  | **Description**                                                                                                                                                                                                                                                                  | **Object Returned** |
  | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- |
  | `P.insert(k,v)`                | adds a new item with priority number `k` and element/description `v` into priority queue. The priority number `k` must be positive and can be of integer or floating-point type; the priority element/description `v` can be of any type.                                        |                     |
  | `P.peek()`                     | returns the highest priority item, but without extracting/removing it from the queue.                                                                                                                                                                                            | `(k, v)`            |
  | `P.delete()`                   | removes/deletes the highest priority item from the queue.                                                                                                                                                                                                                        | `(k, v)`            |
  | `P.removeitem(k, v)`           | removes an item with priority number `k` and element `v` from the queue.                                                                                                                                                                                                         | `(k, v)`            |
  | `P.update(old_item, new_item)` | updates a pair of old item (in tuple, which consists of a priority number and its element) and replaces it with a pair of new item (in tuple, which consists of a priority number and its element). This operation can also be used to update a priority number or element only. |                     |
  | `len(P)`                       | returns the number of items in priority queue `P`.                                                                                                                                                                                                                               | `int`               |
  | `is_empty(P)`                  | returns `True` if priority queue `P` does not contain any items.                                                                                                                                                                                                                 | `True` or `False`   |
  | `P.contains(k, v)`             | returns `True` if priority queue `P` contains an item with priority number `k` with element `v`.                                                                                                                                                                                 | `True` or `False`   |
  | `P.show(i)`                    | returns the item at index `i`.                                                                                                                                                                                                                                                   | `(k, v)`            |

  Time complexity of each operation:

  | **Operation**                  | **Time Complexity** |
  | ------------------------------ | ------------------- |
  | `P.insert(k,v)`                | O(log n)            |
  | `P.peek()`                     | O(1)                |
  | `P.delete()`                   | O(log on)           |
  | `P.removeitem(k, v)`           | O(log on)           |
  | `P.update(old_item, new_item)` | O(log on)           |
  | `len(P)`                       | O(1)                |
  | `is_empty(P)`                  | O(1)                |
  | `P.contains(k, v)`             | O(1)                |
  | `P.show(i)`                    | O(1)                |



  - Data to be inserted in to a priority queue must be a tuple of size $2$, where the first entry must contain priority numbers (either integer or floating-point type) and the second entry can be any object. Aside from individual insertion, a group of individual items of data can also be inserted into a priority queue. Let's do an example. Prepare data to be inserted into a priority queue in a list of tuples:

  ```
  toInsert = [(10, 'CGK'), (9, 'BSL'), (9.2, 'IST'), (8, 'AMS'),
              (7, 'BCN'), (5, 'DOH'), (3, 'BOS'), (8.7, 'AUH')]
  ```

  - Import `DHeap` class:

  ```
  from dheapy import DHeap
  ```

  - Instantiate an empty priority queue object:

  ```
  branching_factor = 3
  variant = 'min'

  P = DHeap(branching_factor, variant)
  ```

  - Check if the priority queue is empty:

  ```
  print(f'Is Priority Queue empty: {P.is_empty()}')
  print(f'Priority Queue length = {len(P)}')
  ```

  which will result in

  ```
  Is Priority Queue empty: True
  Priority Queue length = 0
  ```

  - Insert the data into our empty priority queue `P`:

  ```
  for i in toInsert:
      P.insert(i[0], i[1])
  ```

  - Check again whether the priority queue is already filled with data and its length:

  ```
  print(f'Is Priority Queue empty: {P.is_empty()}')
  print(f'Priority Queue length = {len(P)}')
  ```

  which will print

  ```
  Is Priority Queue empty: False
  Priority Queue length = 8
  ```

  - Use `peek()` module to display the highest priority item:

  ```
  print(f'Highest priority: {P.peek()}')
  ```

  we'll get

  ```
  Highest priority: (3, 'BOS')
  ```

  Our ternary min-heap will look like as follows:

  ![Figure 1](https://raw.githubusercontent.com/vandasari/dheapy/main/images/Figure_1.png)

  Our data will be stored in a list in an arrangement such that it starts from the root node `(3, 'BOS')`. The root's children will be stored subsequently, starting from the most left child `(5, 'DOH')` traversing horizontally through all children until the most right child `(9, 'BSL')`. Thus data in the list will be stored as `[(3, 'BOS'), (5, 'DOH'), (8.7, 'AUH'), (9, 'BSL')]`. Then children of the most left child `(5, 'DOH')` will be stored next, followed with children of `(8.7, 'AUH')`, and so on. This can be verified by using the `show(i)` module where `i` is an index number of the item position. For example, to obtain item at index $0$ or the root node, by either directly displaying like:

  ```
  print(P.show(0))
  ```

  with result

  ```
  (3, 'BOS')
  ```

  Or, to get the pair of priority number and its element individually:

  ```
  priority, element = P.show(0)
  ```

  then display:

  ```
  print(priority, element)
  ```

  Since in this example we use a ternary heap, to display all three children of the root node directly:

  ```
  print(P.show(1))
  print(P.show(2))
  print(P.show(3))
  ```

  which will give us

  ```
  (5, 'DOH')
  (8.7, 'AUH')
  (9, 'BSL')
  ```

  - Use module `delete()` to delete the current highest priority:

  ```
  P.delete()
  ```

  or to display the deleted item:

  ```
  print(f'Deleted: {P.delete()}')
  ```

  which will return

  ```
  Deleted: (3, 'BOS')
  ```

  - View the new highest priority:

  ```
  print(f'Highest priority: {P.peek()}')
  ```

  to get:

  ```
  Highest priority: (5, 'DOH')
  ```

  and our structure now will look like:
  ![Figure 2](https://raw.githubusercontent.com/vandasari/dheapy/main/images/Figure_2.png)

  - Use `removeitem(k, v)` to remove an item from our priority queue, where `k` is a key or priority number and `v` is its element. For example, to remove `(8.7, 'AUH')`:

  ```
  rm = P.removeitem(8.7, 'AUH')
  print(f"Removed: {rm}")
  ```

  we get

  ```
  Removed: (8.7, 'AUH')
  ```

  Our structure now will look like:
  ![Figure 3](https://raw.githubusercontent.com/vandasari/dheapy/main/images/Figure_3.png)

  - To replace an item with a new one, use the `update()` module. For example, to replace the item `(8, AMS)` with `(3.3, 'SFO')`:

  ```
  old_item = (8, 'AMS')
  new_item = (3.3, 'SFO')
  P.update(old_item, new_item)
  ```

  and check the latest highest priority:

  ```
  print(f'Highest priority: {P.peek()}')
  ```

  will return

  ```
  Highest priority: (3.3, 'SFO')
  ```

  Our structure now will look like:
  ![Figure 4](https://raw.githubusercontent.com/vandasari/dheapy/main/images/Figure_4.png)

  - Finally, to check if an item is in our priority queue, we can use the module `contains(k, v)` with `k` is the key or priority number of the item and `v` is its element:

  ```
  P.contains(4.5, 'TKO')
  ```

  will return

  ```
  False
  ```

  or

  ```
  P.contains(9, 'BSL')
  ```

  will return

  ```
  True
  ```



  Import the function:

  ```
  from dheapy import heapsorted
  ```

  The `heapsorted()` function is used to sort a list of tuples, just like the example data for `DHeap` class above.

  - To sort a list of tuples data:

  ```
  data = [(10, 'CGK'), (9, 'BSL'), (9.2, 'IST'), (8, 'AMS'),
          (7, 'BCN'), (5, 'DOH'), (3, 'BOS'), (8.7, 'AUH')]

  branching_factor = 3
  variant = 'min'
  result = heapsorted(data, branching_factor, variant)
  ```

  To print the `result`:

  ```
  print(result)
  ```

  we get

  ```
  [(3, 'BOS'), (5, 'DOH'), (7, 'BCN'), (8, 'AMS'), (8.7, 'AUH'), (9, 'BSL'), (9.2, 'IST'), (10, 'CGK')]
  ```

  - To sort data in a priority queue, we must transform the data into an array. Let's sort the priority queue `P` we have created in the above example. First we create an empty array, and then append the items in `P` into the array using the module `show()`:

  ```
  array = []

  for i in range(len(P)):
      array.append(P.show(i))
  ```

  Then we use the `array` for our function input argument:

  ```
  result = heapsorted(array, branching_factor, variant)
  ```

  printing the result, we'll get

  ```
  [(3.3, 'SFO'), (5, 'DOH'), (7, 'BCN'), (9, 'BSL'), (9.2, 'IST'), (10, 'CGK')]
  ```


pkgId: 57f88dd7f8d60fa1489c4d1cd7d5573d251d4592f28f729a8a12a6e90fcf207a
name: python-dheapy-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for dheapy
url: https://github.com/vandasari/dheapy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dheapy-0.1.4-1.src.rpm
location_href: Packages/python-dheapy-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  `dheapy` is a pure Python implementation of $d$-ary heap data structure for priority queue applications, which can work for both max-heap and min-heap variants. The factor $d$ in $d$-ary heap is called the branching factor and it can be equal to or greater than $2$, where $d=2$ means the heap is built with a binary tree, $d=3$ with a ternary tree, $d=4$ with a quaternary tree, and so on.

  The branching factor of a tree is the maximum number of children a node can have.

  A $2$-ary heap or binary heap has a branching factor of $2$:
  ![Binary Heap](https://raw.githubusercontent.com/vandasari/dheapy/main/images/ex1_binary_tree.png)

  A $3$-ary heap or ternary heap has a branching factor of $3$:
  ![Ternary Heap](https://raw.githubusercontent.com/vandasari/dheapy/main/images/ex2_ternary_tree.png)

  A $4$-ary heap or quaternary heap has a branching factor of $4$:
  ![Quarternary Heap](https://raw.githubusercontent.com/vandasari/dheapy/main/images/ex3_quarternary_tree.png)

  `dheapy` is array-based and adaptable, where arbitrary items can be removed, updated, and displayed on the go.

  The library also comes with a sorting function that is based on the heap-sort algorithm to sort lists of tuples.



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

  ```
  pip install dheapy
  ```



  None.



  1.  `DHeap(branching_factor=2, variant='max')`
      Class to create an empty and perform priority queue operations (shown in the table below).
      Parameters:

      - `branching_factor`: `int`; default = `2`
      - `variant`: `str`, either `'max'` or `'min'`; default = `'max'`

      To import `DHeap` class:

      ```
      from dheapy import DHeap
      ```

  2.  `heapsorted(object, branching_factor=2, variant='max')`
      Function for sorting arrays that is based on the heap sort algorithm.
      Parameters:

      - `object`: array or iterable
      - `branching_factor`: `int`; default = `2`
      - `variant`: `str`, either `'max'` or `'min'`; default = `'max'`

      To import `heapsorted()` function

      ```
      from dheapy import heapsorted
      ```

  To create an empty priority queue with branching factor 3 and min-heap variant:

  ```
  P = DHeap(3, 'min')
  ```

  The following are operations that can be performed with `DHeap` class:

  | **Operation**                  | **Description**                                                                                                                                                                                                                                                                  | **Object Returned** |
  | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- |
  | `P.insert(k,v)`                | adds a new item with priority number `k` and element/description `v` into priority queue. The priority number `k` must be positive and can be of integer or floating-point type; the priority element/description `v` can be of any type.                                        |                     |
  | `P.peek()`                     | returns the highest priority item, but without extracting/removing it from the queue.                                                                                                                                                                                            | `(k, v)`            |
  | `P.delete()`                   | removes/deletes the highest priority item from the queue.                                                                                                                                                                                                                        | `(k, v)`            |
  | `P.removeitem(k, v)`           | removes an item with priority number `k` and element `v` from the queue.                                                                                                                                                                                                         | `(k, v)`            |
  | `P.update(old_item, new_item)` | updates a pair of old item (in tuple, which consists of a priority number and its element) and replaces it with a pair of new item (in tuple, which consists of a priority number and its element). This operation can also be used to update a priority number or element only. |                     |
  | `len(P)`                       | returns the number of items in priority queue `P`.                                                                                                                                                                                                                               | `int`               |
  | `is_empty(P)`                  | returns `True` if priority queue `P` does not contain any items.                                                                                                                                                                                                                 | `True` or `False`   |
  | `P.contains(k, v)`             | returns `True` if priority queue `P` contains an item with priority number `k` with element `v`.                                                                                                                                                                                 | `True` or `False`   |
  | `P.show(i)`                    | returns the item at index `i`.                                                                                                                                                                                                                                                   | `(k, v)`            |



  | **Operation**                  | **Time Complexity** |
  | ------------------------------ | ------------------- |
  | `P.insert(k,v)`                | O(log n)            |
  | `P.peek()`                     | O(1)                |
  | `P.delete()`                   | O(log n)            |
  | `P.removeitem(k, v)`           | O(log n)            |
  | `P.update(old_item, new_item)` | O(log n)            |
  | `len(P)`                       | O(1)                |
  | `is_empty(P)`                  | O(1)                |
  | `P.contains(k, v)`             | O(1)                |
  | `P.show(i)`                    | O(1)                |
  | function `heapsorted()`        | O(n log n)          |



  - Data to be inserted in to a priority queue must be a tuple of size $2$, where the first entry must contain priority numbers (either integer or floating-point type) and the second entry can be any object. Aside from individual insertion, a group of individual items of data can also be inserted into a priority queue. Let's do an example. Prepare data to be inserted into a priority queue in a list of tuples:

  ```
  toInsert = [(10, 'CGK'), (9, 'BSL'), (9.2, 'IST'), (8, 'AMS'),
              (7, 'BCN'), (5, 'DOH'), (3, 'BOS'), (8.7, 'AUH')]
  ```

  - Import `DHeap` class:

  ```
  from dheapy import DHeap
  ```

  - Instantiate an empty priority queue object:

  ```
  branching_factor = 3
  variant = 'min'

  P = DHeap(branching_factor, variant)
  ```

  - To verify if parameters are correct, we print the object we just created

  ```
  print(P)
  ```

  which will result in

  ```
  Priority Queue with 3 branching factor and min-heap
  ```

  - Check if the priority queue is empty:

  ```
  print(f'Is Priority Queue empty: {P.is_empty()}')
  print(f'Priority Queue length = {len(P)}')
  ```

  which will result in

  ```
  Is Priority Queue empty: True
  Priority Queue length = 0
  ```

  - Insert the data into our empty priority queue `P`:

  ```
  for i in toInsert:
      P.insert(i[0], i[1])
  ```

  - Check again whether the priority queue is already filled with data and its length:

  ```
  print(f'Is Priority Queue empty: {P.is_empty()}')
  print(f'Priority Queue length = {len(P)}')
  ```

  which will print

  ```
  Is Priority Queue empty: False
  Priority Queue length = 8
  ```

  - Use `peek()` module to display the highest priority item:

  ```
  print(f'Highest priority: {P.peek()}')
  ```

  we'll get

  ```
  Highest priority: (3, 'BOS')
  ```

  Our ternary min-heap will look like as follows:

  ![Figure 1](https://raw.githubusercontent.com/vandasari/dheapy/main/images/Figure_1.png)

  Our data will be stored in a list in an arrangement such that it starts from the root node `(3, 'BOS')`. The root's children will be stored subsequently, starting from the most left child `(5, 'DOH')` traversing horizontally through all children until the most right child `(9, 'BSL')`. Thus data in the list will be stored as `[(3, 'BOS'), (5, 'DOH'), (8.7, 'AUH'), (9, 'BSL')]`. Then children of the most left child `(5, 'DOH')` will be stored next, followed with children of `(8.7, 'AUH')`, and so on. This can be verified by using the `show(i)` module where `i` is an index number of the item position. For example, to obtain item at index $0$ or the root node, by either directly displaying like:

  ```
  print(P.show(0))
  ```

  with result

  ```
  (3, 'BOS')
  ```

  Or, to get the pair of priority number and its element individually:

  ```
  priority, element = P.show(0)
  ```

  then display:

  ```
  print(priority, element)
  ```

  Since in this example we use a ternary heap, to display all three children of the root node directly:

  ```
  print(P.show(1))
  print(P.show(2))
  print(P.show(3))
  ```

  which will give us

  ```
  (5, 'DOH')
  (8.7, 'AUH')
  (9, 'BSL')
  ```

  - Use module `delete()` to delete the current highest priority:

  ```
  P.delete()
  ```

  or to display the deleted item:

  ```
  print(f'Deleted: {P.delete()}')
  ```

  which will return

  ```
  Deleted: (3, 'BOS')
  ```

  - View the new highest priority:

  ```
  print(f'Highest priority: {P.peek()}')
  ```

  to get:

  ```
  Highest priority: (5, 'DOH')
  ```

  and our structure now will look like:
  ![Figure 2](https://raw.githubusercontent.com/vandasari/dheapy/main/images/Figure_2.png)

  - Use `removeitem(k, v)` to remove an item from our priority queue, where `k` is a key or priority number and `v` is its element. For example, to remove `(8.7, 'AUH')`:

  ```
  rm = P.removeitem(8.7, 'AUH')
  print(f"Removed: {rm}")
  ```

  we get

  ```
  Removed: (8.7, 'AUH')
  ```

  Our structure now will look like:
  ![Figure 3](https://raw.githubusercontent.com/vandasari/dheapy/main/images/Figure_3.png)

  - To replace an item with a new one, use the `update()` module. For example, to replace the item `(8, AMS)` with `(3.3, 'SFO')`:

  ```
  old_item = (8, 'AMS')
  new_item = (3.3, 'SFO')
  P.update(old_item, new_item)
  ```

  and check the latest highest priority:

  ```
  print(f'Highest priority: {P.peek()}')
  ```

  will return

  ```
  Highest priority: (3.3, 'SFO')
  ```

  Our structure now will look like:
  ![Figure 4](https://raw.githubusercontent.com/vandasari/dheapy/main/images/Figure_4.png)

  - Finally, to check if an item is in our priority queue, we can use the module `contains(k, v)` with `k` is the key or priority number of the item and `v` is its element:

  ```
  P.contains(4.5, 'TKO')
  ```

  will return

  ```
  False
  ```

  or

  ```
  P.contains(9, 'BSL')
  ```

  will return

  ```
  True
  ```



  Import the function:

  ```
  from dheapy import heapsorted
  ```

  The `heapsorted()` function is used to sort a list of tuples, just like the example data for `DHeap` class above.

  - To sort a list of tuples data:

  ```
  data = [(10, 'CGK'), (9, 'BSL'), (9.2, 'IST'), (8, 'AMS'),
          (7, 'BCN'), (5, 'DOH'), (3, 'BOS'), (8.7, 'AUH')]

  branching_factor = 3
  variant = 'min'
  result = heapsorted(data, branching_factor, variant)
  ```

  To print the `result`:

  ```
  print(result)
  ```

  we get

  ```
  [(3, 'BOS'), (5, 'DOH'), (7, 'BCN'), (8, 'AMS'), (8.7, 'AUH'), (9, 'BSL'), (9.2, 'IST'), (10, 'CGK')]
  ```

  - To sort data in a priority queue, we must transform the data into an array. Let's sort the priority queue `P` we have created in the above example. First we create an empty array, and then append the items in `P` into the array using the module `show()`:

  ```
  array = []

  for i in range(len(P)):
      array.append(P.show(i))
  ```

  Then we use the `array` for our function input argument:

  ```
  result = heapsorted(array, branching_factor, variant)
  ```

  printing the result, we'll get

  ```
  [(3.3, 'SFO'), (5, 'DOH'), (7, 'BCN'), (9, 'BSL'), (9.2, 'IST'), (10, 'CGK')]
  ```


pkgId: a3965f33df694de33519a52ed6ab4706defbc066845bdb57cffd49d0375a003d
name: python-dhesend-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for dhesend
url: https://github.com/dhesend/dhesend-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dhesend-0.0.1-1.src.rpm
location_href: Packages/python-dhesend-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python library for interacting with the Dhesend API, designed to make email sending simple and efficient.
  For full documentation, visit the [official website](https://dhesend.com/docs/introduction).



  Install the SDK using your preferred package manager:

  ```bash
  pip install dhesend
  ```



  Discover example integrations with various frameworks:

  - [Python Example](https://github.com/dhesend/dhesend-python-example)
  - [Django Example)](https://github.com/dhesend/dhesend-django-example)
  - [Flask](https://github.com/dhesend/dhesend-nextjs-pages-router-example)



  1. **Obtain an API Key:**
        Get your API key from the [Dhesend Dashboard](https://dhesend.com).

  2. **Initialize the SDK:**
        Use your API key to create an instance of the Dhesend client.

  ```py
  from dhesend import Dhesend

  dhesend = Dhesend('your_api_key_here'); # Replace with your actual API key
  ```





  ```py
  from dhesend import Dhesend, SendEmailPayload

  dhesend = Dhesend("your-apikey")

  params: SendEmailPayload = {
      "from": "Dhesend <example@domain.com>",
      "to": ['example@dhesend.com'],
      "subject": 'Welcome to Dhesend',
      "textBody": 'Have a nice day!',
  }

  response = dhesend.Email.send(params)
  print(response)
  ```



  ```py
  from dhesend import Dhesend, SendEmailPayload

  dhesend = Dhesend("your-apikey")

  params: SendEmailPayload = {
      "from": "Dhesend <example@domain.com>",
      "to": ['example@dhesend.com'],
      "subject": 'Welcome to Dhesend',
      "htmlBody": '<strong>Have a nice day!</strong>',
  }

  response = dhesend.Email.send(params)
  print(response)
  ```


  MIT License.


pkgId: e75fcc34548c9817db047a1e635e3dd0a6bdec41b7d0fb4fea0d6e9c3279c9b6
name: python-dhlibs-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for dhlibs
url: https://github.com/DinhHuy2010/dhlibs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dhlibs-0.1.5-1.src.rpm
location_href: Packages/python-dhlibs-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/) [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/) ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/dhlibs/dhlibs/ci.yaml?logo=github&label=CI)  ![Libraries.io dependency status for GitHub repo](https://img.shields.io/librariesio/github/dhlibs/dhlibs) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/dhlibs) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dhlibs)   ![PyPI - Version](https://img.shields.io/pypi/v/dhlibs)


  dhlibs® - random libraries that you shouldn't care™
  <!--stackedit_data:
  eyJoaXN0b3J5IjpbLTUxODYzMjIwNl19
  -->


pkgId: 06b303ba5106168e88cf1fc313be94911b079fe7ab92092da576972ed6f1d6b7
name: python-diPLSlib
arch: noarch
version: 2.4.2
epoch: 0
release: 1
summary: Python package for domain adaptation in multivariate regression
url: https://github.com/B-Analytics/di-PLS
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-diPLSlib-2.4.2-1.src.rpm
location_href: Packages/python-diPLSlib-2.4.2-1.noarch.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/badge/python-3.13-blue.svg)
  ![](https://static.pepy.tech/badge/diplslib)

  ![](https://user-images.githubusercontent.com/77445667/104728864-d5fede80-5737-11eb-8aad-59f9901a0cf4.png)

  diPLSlib has been created to build privacy-preserving regression models and to perform calibration model maintenance by domain adaptation. It has a scikit-learn compatible API and features following methods:

  - (Multiple) Domain-invariant partial least squares regression (di-PLS/mdi-PLS)
  - Graph-based calibration transfer (GCT-PLS)
  - $(\epsilon, \delta)$-differentially private partial least squares regression (edPLS)

  **Citation**: If you use this library in your research, please cite the following reference:

  ```
  Nikzad-Langerodi R.(2024). diPLSlib : A Python library for domain adaptation in multivariate calibration (version 2.4.1). URL: https://di-pls.readthedocs.io/
  ```
  or in Bibtex format :
  ```bibtex
  @misc{nikzad2024diPLSlib,
  author = {Nikzad-Langerodi, Ramin},
  month = {12},
  title = {diPLSlib: A Python library for domain adaptation in multivariate calibration},
  url = {https://di-pls.readthedocs.io/},
  year = {2024}
  }
  ```


  ```bash
  pip install diPLSlib
  ```



  Train regression model
  ```python
  from diPLSlib.models import DIPLS
  from diPLSlib.utils import misc

  l = 100000                    # or l = (10000, 100) Regularization
  m = DIPLS(A=2, l=l)
  m.fit(X, y, X_source, X_target)


  ```
  Apply the model
  ```python
  yhat_dipls = m.predict(X_test)
  err = misc.rmse(y_test, yhat_dipls)
  ```


  ```python
  from diPLSlib.models import DIPLS

  l = 100000                    # or l = (5, 100, 1000)  Regularization
  m = DIPLS(A=3, l=l, target_domain=2)
  m.fit(X, y, X_source, X_target)



  ```


  ```python
  from diPLSlib.models import GCTPLS


  l = 10                         # or l = (10, 10) Regularization
  m = GCTPLS(A=2, l=l)
  m.fit(X, y, X_source, X_target)


  ```


  ```python
  from diPLSlib.models import EDPLS


  epsilon = 1                      # Privacy loss
  delta = 0.05                     # Failure probability of the privacy guarantee
  m = EDPLS(A=2, epsilon=epsilon, delta=delta)
  m.fit(X, y)
  ```


  For more examples, please refer to the [Notebooks](notebooks):

  - [Domain adaptation with di-PLS](https://github.com/B-Analytics/diPLSlib/blob/main/notebooks/demo_diPLS.ipynb)
  - [Including multiple domains (mdi-PLS)](https://github.com/B-Analytics/diPLSlib/blob/main/notebooks/demo_mdiPLS.ipynb)
  - [Implicit calibration transfer with GCT-PLS](https://github.com/B-Analytics/diPLSlib/blob/main/notebooks/demo_gctPLS.ipynb)
  - [Model selection with `scikit-learn`](https://github.com/B-Analytics/diPLSlib/blob/main/notebooks/demo_ModelSelection_SciKitLearn.ipynb)
  - [Privacy-preserving regression with EDPLS](https://github.com/B-Analytics/diPLSlib/blob/main/notebooks/demo_edPLS.ipynb)


  The documentation can be found [here](https://di-pls.readthedocs.io/en/latest/diPLSlib.html).


  The first version of di-PLS was developed by Ramin Nikzad-Langerodi, Werner Zellinger, Edwin Lughofer, Bernhard Moser and Susanne Saminger-Platz
  and published in:

  - *Ramin Nikzad-Langerodi, Werner Zellinger, Edwin Lughofer, and Susanne Saminger-Platz
  Analytical Chemistry 2018 90 (11), 6693-6701 https://doi.org/10.1021/acs.analchem.8b00498*

  Further refinements to the initial algorithm were published in:

  - *R. Nikzad-Langerodi, W. Zellinger, S. Saminger-Platz and B. Moser, "Domain-Invariant Regression Under Beer-Lambert's Law," 2019 18th IEEE International Conference On Machine Learning And Applications (ICMLA), Boca Raton, FL, USA, 2019, pp. 581-586, https://doi.org/10.1109/ICMLA.2019.00108.*

  - *Ramin Nikzad-Langerodi, Werner Zellinger, Susanne Saminger-Platz, Bernhard A. Moser,
  Domain adaptation for regression under Beer–Lambert’s law,
  Knowledge-Based Systems, Volume 210, 2020, https://doi.org/10.1016/j.knosys.2020.106447.*

  - *Bianca Mikulasek, Valeria Fonseca Diaz, David Gabauer, Christoph Herwig, Ramin Nikzad-Langerodi,
  "Partial least squares regression with multiple domains" Journal of Chemometrics 2023 37 (5), e3477, https://doi.org/10.13140/RG.2.2.23750.75845*

  - *Ramin Nikzad-Langerodi & Florian Sobieczky (2021). Graph‐based calibration transfer. Journal of Chemometrics, 35(4), e3319. https://doi.org/10.1002/cem.3319*

  - *Ramin Nikzad-Langerodi,  Mohit Kumar, Du Nguyen Duy, and Mahtab Alghasi (2024), "(epsilon, delta)-Differentially Private Partial Least Squares Regression", unpublished.*


  Bottleneck Analytics GmbH
  info@bottleneck-analytics.com


pkgId: 62675af4f8a6cd80c2449fec60bd6e1779b6ce41f6ae8b403d53a74f91fe98a2
name: python-diagify-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for diagify
url: https://github.com/alexminnaar/diagify
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-diagify-0.1.4-1.src.rpm
location_href: Packages/python-diagify-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  Diagify is a tool that leverages OpenAI's LLM models and the Mingrammer diagrams library to
  transform natural language descriptions into well-formatted technical diagram.


pkgId: 0b73641319e3a748bc8d336ff3645dffec01c80c0c1e0d79b29aad10634f47f8
name: python-dicetables-help
arch: noarch
version: 4.0.3
epoch: 0
release: 1
summary: Development documents and examples for dicetables
url: https://allthedice.com
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dicetables-4.0.3-1.src.rpm
location_href: Packages/python-dicetables-help-4.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Have you ever wondered what the chances were for killing that 25 hp creature
  with your lvl-5 fireball? Of course you have(it's 3.24%. Good luck with that).
  What about if you could use your loaded dice that roll 6 twice as often.
  We've got you covered (still only a 10% chance). Want to make sure
  you'll win a bet on a number spread for DND dice randomly grabbed from a bag?
  No problem("i'll bet you can't roll 150-200 on 7D4, 4D8, 5D12 and 4D20" ...
  because it's a 0.3% chance). Ever wondered what would happen if you flipped a
  coin a thousand times? (Your chance of flipping heads more than 600 times
  is 0.000000009%.)
  Impress your friends. Wow the gender of your choice -
  with .... DICETABLES!!!

rpm_license:
  MIT License  Copyright (c) 2019 Eric Shaw  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: 9fa52e24027fd8ef9ea04c95857a1608acefedc8978017246f30324da59dada8
name: python-dichback-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for dichback
url: https://github.com/SpeechlessMatt/Dichback
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dichback-0.0.1-1.src.rpm
location_href: Packages/python-dichback-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  一种节省步数的，效率高的回溯算法。



  回溯步骤比较复杂，直接看代码可能会好一点

  - 定义逻辑和-逻辑函数单元：

      - **logic_unit**(self, **effective_list**: *list*) -> *bool*： 接收一个列表（有效数据集合）作为参数，遍历每一个元素，存在一个元素不符合定义的逻辑时就返回False,否则返回True

  - 进入**dichotomy_backtracking_algorithm**(**effective_list**)方法:

      1. **调用逻辑和-逻辑函数单元**（传参：*effective_list*）：返回*true*或者*false*

      2. **第一次调用**：如果返回值为*True*，则直接退出（因为所有元素均符合定义逻辑），返回值为*False*，则将有效列表二分为两个子列表（*子列表1*,*子列表2*），将子列表1作为参数返回**步骤1**

      3. **非第一次调用**：如果返回值为*True*,那么该列表内的所有元素均符合定义逻辑，将该列表元素全部加入*yes_list*，这个时候回溯到它的父列表中的其他子列表中（由于二分法，一个父列表一般就两个子列表，也就是说每一个列表最多只有一个同父同级列表），如果其他子列表返回*False*,那么继续分割子列表，直到子列表长度小于等于*lm*（这一个值事实上会影响算法优化程度，因为这个值限制了子列表的**最小长度**，防止深度优先搜索过度深入造成浪费，也就是说当lm=有效列表长度//3-1的时候，理论上列表最多被分割4次），会把子列表元素逐个穷举，返回*True*，则加入yes_list，然后回溯，将它的同父同级列表作为参数返回**步骤1**

  暂时还没有配图，所以可能不太好理解



  ```bash
  pip install dichback
  ```

  示例程序
  ```python
  from dichback import AlgorithmSet

  class Al(AlgorithmSet):
      LIST = [i for i in range(1, 100) if i%10 == 0]
      def __init__(self):
          super().__init__()

      def logic_unit(self, effective_list: list) -> bool:
          
          
          
          
          for i in effective_list:
              if not i in self.LIST:
                  return False
          return True

  if __name__ == '__main__':
      a = Al()
      rep = a.dichotomy_backtracking_algorithm([i for i in range(1, 100)])
      print(a.chance)
      print(rep)
  ```

  dichback中**AlgorithmSet**类继承的时候强制要求定义逻辑元:
  `logic_unit(self, effective_list: list) -> bool`

  同时提供*self.counts*属性，查看逻辑元调用次数


pkgId: 22229bb8ee50dfbced4dea12b712997f909db53228279b34757a7ab6f3c82a97
name: python-dicom-validator-help
arch: noarch
version: 0.6.4
epoch: 0
release: 1
summary: Development documents and examples for dicom-validator
url: https://pypi.org/project/dicom-validator/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dicom-validator-0.6.4-1.src.rpm
location_href: Packages/python-dicom-validator-help-0.6.4-1.noarch.rpm
checksum_type: sha256
description:
  Module "Enhanced XA/XRF Image":
  Tag (0018,9410) (Planes in Acquisition) is missing
  Module "Mask":
  Tag (0028,6100) (Mask Subtraction Sequence) is missing
  Module "X-Ray Frame Acquisition":
  Tag (0018,9328) (Exposure Time in ms) is unexpected in  Multi-frame Functional Groups > (5200,9230) > (0018,9417)
  Tag (0018,9332) (Exposure in mAs) is unexpected in  Multi-frame Functional Groups > (5200,9230) > (0018,9417)
  Module "X-Ray Geometry":
  Tag (0018,9476) (X-Ray Geometry Sequence) is missing in  Multi-frame Functional Groups > (5200,9230)
  Module "XA/XRF Multi-frame Presentation":
  Tag (0028,1090) (Recommended Viewing Mode) is missing in  XA/XRF Multi-frame Presentation > (0008,9458)
  Tag (0028,9411) (Display Filter Percentage) is missing in  XA/XRF Multi-frame Presentation > (0008,9458)
  General:
  Tag (0008,0022) (Acquisition Date) is unexpected
  Tag (0008,0032) (Acquisition Time) is unexpected
  Tag (0028,9411) (Display Filter Percentage) is unexpected
  Tag (0018,1164) (Imager Pixel Spacing) is unexpected
  Process finished with exit code 6
  ```


  As mentioned, if the evaluation of conditions fails, the related module or
  tag is considered optional, which may hide some non-conformity.
  Condition evaluation may fail if:
  - the needed information is not directly contained in the DICOM file (e.g. verbose
    descriptions like "if the Patient is an animal", "if the image has been calibrated" etc.)
  - the information is related to other DICOM files (e.g. referenced images)
  - the parsing failed because the condition is too complicated, unexpected,
    or due to a bug (please write an issue if you encounter such a problem)

  Only the given standard is used to evaluate the files. If
  the DICOM file has been written using an older standard, it may conform to
  that standard, but not to the newest one. Tags that are retired in the
  version of the standard used for parsing are not considered at all.
  You can always check against an older standard by using the `--revision` option.

  Most enumerated values are checked against, but some are ignored due to parsing issues.
  Support for more cases may be added in the future.
  Defined terms are _not_ checked, because they are allowed to be user-defined, which means
  that any value may be valid.

  - SOP classes not in the table in PS3.3 such as Presentation States are not
    handled

  This is a very simple DICOM dump tool, which uses
  the DICOM dictionary as read from part 6 of the standard. It prints the
  DICOM header of the given DICOM file, or of all DICOM files recursively in a
  given directory. The output looks like this:
  ```
  (py3_test) c:\dev\GitHub\dicom-validator>dump_dcm_info "c:\dev\DICOM
  Data\SR\image12.dcm"
  c:\dev\DICOM Data\SR\image12.dcm
  (0005,0010) [Unknown]                                LO    1  [AEGIS_DICOM_2.00]
  (0005,1000) [Unknown]                                UN    1  [\x00\x05 \x08\x00\x00\x00\n  RIGHT   \x00\x05\xc1X\x00\x00\x00\x06 0.09 \x00\x05...]
  (0008,0008) Image Type                               CS    0  []
  (0008,0016) SOP Class UID                            UI    1  [Ultrasound Image Storage (Retired)]
  (0008,0018) SOP Instance UID                         UI    1  [1.2.840.113680.3.103.775.2873347909.282313.2]
  (0008,0020) Study Date                               DA    1  [19950119]
  (0008,0030) Study Time                               TM    1  [092854.0]
  (0008,0050) Accession Number                         SH    1  [ACN000001]
  (0008,0060) Modality                                 CS    1  [US]
  (0008,0070) Manufacturer                             LO    1  [Acuson]
  (0008,0090) Referring Physician's Name               ON    1  []
  (0008,1010) Station Name                             SH    1  [QV-00775]
  (0008,1030) Study Description                        LO    1  [ABDOMEN]
  (0008,1050) Performing Physician's Name              ON    1  [DOE,JOHN]
  (0008,1060) Name of Physician(s) Reading Study       ON    1  []
  (0008,1070) Operators' Name                          ON    1  [DO]
  (0008,1080) Admitting Diagnoses Description          LO    1  [RSNA'95 Data Not Delete]
  (0009,0010) [Unknown]                                LO    1  [AEGIS_DICOM_2.00]
  ```
  If you want to show only specific tags, you can use the option `--show-tags`:
  ```
  (py3_test) c:\dev\GitHub\dicom-validator>dump_dcm_info "c:\dev\DICOM Data\SR\image12.dcm" --show-tags 0010,0010 PatientID
  c:\dev\DICOM Data\SR\image12.dcm
  (0010,0010) Patient's Name                           ON    1  [DOE^JANE]
  (0010,0020) Patient ID                               LO    1  [ACN000001]
  ```

  A self-contained Windows executable is contained in the release artifacts.
  Here is a sample workflow to build such an executable yourself:
  ```powershell

  git clone git@github.com:pydicom/dicom-validator.git

  cd dicom-validator
  virtualenv venv
  venv\Scripts\activate

  pip install -r requirements-dev.txt

  pyinstaller dicom-validator.spec -y
  ```

  Contributions are very welcome. If you submit a pull request for a bugfix
  or a new feature, please make sure to also write respective tests.


pkgId: 59b733f03716c52278f5f4fce7ee9e170027a35593f79638302c2265cb3d0201
name: python-dicom2nifti-help
arch: noarch
version: 2.5.1
epoch: 0
release: 1
summary: Development documents and examples for dicom2nifti
url: https://github.com/icometrix/dicom2nifti
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dicom2nifti-2.5.1-1.src.rpm
location_href: Packages/python-dicom2nifti-help-2.5.1-1.noarch.rpm
checksum_type: sha256
description:
  With this package you can convert dicom images to nifti files.
  There is support for most anatomical CT and MR data.
  For MR specifically there is support for most 4D data (like DTI and fMRI)


pkgId: 22d2a641736c35ad2601b71b0152736b5ecad1c489d52aa467b4ce9adc6970f7
name: python-dicompare-help
arch: noarch
version: 0.1.10
epoch: 0
release: 1
summary: Development documents and examples for dicompare
url: https://github.com/astewartau/dicompare
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dicompare-0.1.10-1.src.rpm
location_href: Packages/python-dicompare-help-0.1.10-1.noarch.rpm
checksum_type: sha256
description:
  [![](img/button.png)](https://astewartau.github.io/dicompare/)

  dicompare is a DICOM validation tool designed to ensure compliance with study-specific imaging protocols and domain-specific guidelines while preserving data privacy. It provides multiple interfaces, including support for validation directly in the browser, leveraging WebAssembly (WASM), Pyodide, and the underlying pip package [`dicompare`](#dicompare). dicompare is suitable for multi-site studies and clinical environments without requiring software installation or external data uploads.

  dicompare supports DICOM session validation against:

  - **Session schemas**: JSON schema files that can be generated based on a reference session;
  - **[TESTING] domain guidelines**: Flexible guidelines for specific domains (currently [QSM](https://doi.org/10.1002/mrm.30006));
  - **[FUTURE] landmark studies**: Schema files based on landmark studies such as the [HCP](https://doi.org/10.1038/s41586-018-0579-z), [ABCD](https://doi.org/10.1016/j.dcn.2018.03.001), and [UK BioBank](https://doi.org/10.1038/s41586-018-0579-z) projects.



  While you can run [dicompare](https://astewartau.github.io/dicompare/) in your browser now without any installation, you may also use the underlying `dicompare` pip package if you wish to use the command-line interface (CLI) or application programming interface (API).

  ```bash
  pip install dicompare
  ```



  The package provides the following CLI entry points:

  - `dcm-gen-session`: Generate JSON schemas for DICOM validation.
  - `dcm-check-session`: Validate DICOM sessions against predefined schemas.

  1. Generate a JSON Reference Schema

  ```bash
  dcm-gen-session \
      --in_session_dir /path/to/dicom/session \
      --out_json_ref schema.json \
      --acquisition_fields ProtocolName SeriesDescription \
      --reference_fields EchoTime RepetitionTime
  ```

  This will create a JSON schema describing the session based on the specified fields.

  2. Validate a DICOM Session

  ```bash
  dicompare-session \
      --in_session /path/to/dicom/session \
      --json_ref schema.json \
      --out_json compliance_report.json
  ```

  The tool will output a compliance summary, indicating deviations from the reference schema.



  The `dicompare` package provides a Python API for programmatic schema generation and validation.

  **Generate a schema:**

  ```python
  from dicompare.io import read_dicom_session

  reference_fields = ["EchoTime", "RepetitionTime"]
  acquisition_fields = ["ProtocolName", "SeriesDescription"]

  session_data = read_dicom_session(
      session_dir="/path/to/dicom/session",
      acquisition_fields=acquisition_fields,
      reference_fields=reference_fields
  )


  import json
  with open("schema.json", "w") as f:
      json.dump(session_data, f, indent=4)
  ```

  **Validate a session:**

  ```python
  from dicompare.io import read_json_session, read_dicom_session
  from dicompare.compliance import check_session_compliance


  acquisition_fields, reference_fields, ref_session = read_json_session(json_ref="schema.json")


  in_session = read_dicom_session(
      session_dir="/path/to/dicom/session",
      acquisition_fields=acquisition_fields,
      reference_fields=reference_fields
  )


  compliance_summary = check_session_compliance(
      in_session=in_session,
      ref_session=ref_session,
      series_map=None  # Optional: map series if needed
  )


  for entry in compliance_summary:
      print(entry)
  ```


pkgId: efd36df92d3d07035a5cb9d58b6145af07e27e828f8e4c1d2be0aa75867ea664
name: python-dieStruct-help
arch: noarch
version: 1.0
epoch: 0
release: 1
summary: Development documents and examples for dieStruct
url: https://www.youtube.com/results?search_query=daningenio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dieStruct-1.0-1.src.rpm
location_href: Packages/python-dieStruct-help-1.0-1.noarch.rpm
checksum_type: sha256
description:
  **dieStruct** es una librerÃ­a educativa desarrollada para enseÃ±ar la lÃ³gica de programaciÃ³n aplicada al anÃ¡lisis y diseÃ±o estructural. Su objetivo principal es facilitar el aprendizaje de conceptos fundamentales en ingenierÃ­a estructural mediante herramientas computacionales, promoviendo la comprensiÃ³n de algoritmos y procesos detrÃ¡s del diseÃ±o estructural automatizado.

  Esta librerÃ­a estÃ¡ diseÃ±ada tanto para estudiantes como para profesionales que deseen profundizar en los principios computacionales del anÃ¡lisis estructural, utilizando Python como medio de aprendizaje e implementaciÃ³n.


pkgId: d04fdb69bc829ff9ddedaab1966b816b370c5a896022e38b0f79fe92b99fcbd5
name: python-diff-cover-help
arch: noarch
version: 9.2.1
epoch: 0
release: 1
summary: Development documents and examples for diff-cover
url: https://github.com/Bachmann1234/diff-cover
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-diff-cover-9.2.1-1.src.rpm
location_href: Packages/python-diff-cover-help-9.2.1-1.noarch.rpm
checksum_type: sha256
description:
  Automatically find diff lines that need test coverage.
  Also finds diff lines that have violations (according to tools such
  as pycodestyle, pyflakes, flake8, or pylint).
  This is used as a code quality metric during code reviews.


pkgId: f952f3cb1d8d3a0af5c137a858f59daa103c8e67ec64b24469f1f323ffea75a4
name: python-diff3d-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for diff3d
url: https://github.com/bdlucas1/diff3d
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-diff3d-0.1.0-1.src.rpm
location_href: Packages/python-diff3d-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This Python program provides a simple, fast, and robust way to visually
  compare 3d files such as STL, OBJ, 3MF, and STEP. The unchanged parts
  of the objects are shown in gray, while the changed parts are shown in
  contrasting colors that stand out, illustrated by the following
  example.

  <img src="https://raw.githubusercontent.com/bdlucas1/diff3d/refs/heads/master/examples/scheme1.png" width="50%">

  In this example most of the lens clamp is unchanged and is displayed
  in gray, while the differing parts are displayed in red for one file
  and green for the other file: in the red file the diameter is smaller,
  while in the green file the base is longer, and the threaded hole has
  moved.




  You will need to have Python installed. Python comes with a program
  called `pip` for installing Python programs at the system level. To
  install `diff3d` run this command:

      pip install diff3d

  In some more recent versions of Python you may get an error that the
  Python installation is managed by the OS, meaning that you can't use
  `pip` to install packages like `diff3d` directly into the system
  because the OS depends on a stable version of Python. In that case you
  can [install pipx](https://pipx.pypa.io/stable/installation/) and use
  `pipx` in place of `pip` in the command above.

  Then to test the installation download two test files
  [lens-clamp-A.stl](https://raw.githubusercontent.com/bdlucas1/diff3d/refs/heads/master/examples/lens-clamp-A.stl)
  and
  [lens-clamp-B.stl](https://raw.githubusercontent.com/bdlucas1/diff3d/refs/heads/master/examples/lens-clamp-B.stl)
  and run the command

      diff3d lens-clamp-A.stl lens-clamp-B.stl

  The `diff3d` command may take up to about a minute to run the first
  time while it loads and compiles the supporting packages, but after
  that the startup time will be very quick.

  You can drag the displayed object to rotate it, use the mouse wheel to
  zoom, and shift-drag to pan.

  The second file is optional, in which case the first file will simply
  be displayed without diffs. This allows the tool to be used as a
  simple 3d file viewer in addition to its primary function.




  I use MacOS, but I believe this tool works on Windows and Linux
  as well. I have tested it with Python 3.12 and 3.13, but I think
  it will also work on some somewhat older versions of Python.

  Out of the box `diff3d` supports STL, OBJ, and 3MF files. Support for a
  number of additional file types is available by installing `meshio`,
  and support for STEP files can be enabled by installing `build123d`.

  Unlike other tools that do 3d diffs by using 3d boolean operations
  like intersection and difference, this tool is robust and is not
  limited to manifold (closed surface) meshes, but can diff anything that
  can be rendered, including open surfaces, curves, and points.




  Three color schemes designed to be colorblind-friendly are
  provided. (This is based on information from
  https://davidmathlogic.com/colorblind, and I have not verified
  this. If you have information to add please contact me by opening an
  issue on github.)

  <img src="https://raw.githubusercontent.com/bdlucas1/diff3d/refs/heads/master/examples/scheme1.png" width="30%"><img src="https://raw.githubusercontent.com/bdlucas1/diff3d/refs/heads/master/examples/scheme2.png" width="30%"><img src="https://raw.githubusercontent.com/bdlucas1/diff3d/refs/heads/master/examples/scheme3.png" width="30%">

  You can choose a scheme using the `-s` or `--scheme` option.  The
  above schemes are named "1", "2", and "3" respectively.




  The `diff3d` module provides a simple API if you want to integrate it
  into your own program. See the code for details.

  * `diff3d.from_files` opens a window displaying the diff between two files

  * `diff3d.diff` opens a window displaying the diff between two pyvista objects.

  * If you are using a different mesh or CAD package, if you can obtain
    point and triangle arrays, you can convert them to pyvista objects
    using `pyvista.PolyData.from_regular_faces`


pkgId: e03b9a3d24169dca56e943a848a866fffe29224e898c7276c5ca554686457fd5
name: python-diffa-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for diffa
url: https://github.com/tomcarter23/diffa
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-diffa-0.0.2-1.src.rpm
location_href: Packages/python-diffa-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  A very simple python package for creating a HTML line diff between two files

  Use like:
  ```
  python diffa/diffa.py file1.txt file2.txt output.html --side-by-side
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Tom Carter  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: 662df4a4fcf5e0b8fa9e56bb61dd9d6dc14be9592109eb541a0ae9c4572f13d2
name: python-diffmah-help
arch: noarch
version: 0.6.3
epoch: 0
release: 1
summary: Development documents and examples for diffmah
url: https://pypi.org/project/diffmah/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-diffmah-0.6.3-1.src.rpm
location_href: Packages/python-diffmah-help-0.6.3-1.noarch.rpm
checksum_type: sha256
description:
  The latest release of diffmah is available for installation with pip or conda-forge:
  ```
  $ conda install -c conda-forge diffmah
  ```

  To install diffmah into your environment from the source code:

  ```
  $ cd /path/to/root/diffmah
  $ pip install .
  ```


  For a typical development environment in conda:

  ```
  $ conda create -c conda-forge -n diffit python=3.9 numpy jax pytest ipython jupyter matplotlib scipy h5py diffmah
  ```


  Data for this project can be found [at this URL](https://portal.nersc.gov/project/hacc/aphearin/diffmah_data/).


  Online documentation for Diffmah is available at [diffmah.readthedocs.io](https://diffmah.readthedocs.io/en/latest/).


  The `diffmah_fitter_demo.ipynb` notebook demonstrates how to fit the MAH of a simulated halo with a diffmah approximation. See `history_fitting_script.py` for an example of how to fit the MAHs of a large number of simulated halos in parallel with mpi4py.


  [The diffmah paper](https://astro.theoj.org/article/26991-a-differentiable-model-of-the-assembly-of-individual-and-populations-of-dark-matter-halos) has been published by the [Open Journal of Astrophysics](https://astro.theoj.org/). Citation information for the paper can be found at [this ADS link](https://ui.adsabs.harvard.edu/abs/2021OJAp....4E...7H/abstract), copied below for convenience:

  ```
  @ARTICLE{2021OJAp....4E...7H,
         author = {{Hearin}, Andrew P. and {Chaves-Montero}, Jon{\'a}s and {Becker}, Mathew R. and {Alarcon}, Alex},
          title = "{A Differentiable Model of the Assembly of Individual and Populations of Dark Matter Halos}",
        journal = {The Open Journal of Astrophysics},
       keywords = {Astrophysics - Cosmology and Nongalactic Astrophysics, Astrophysics - Astrophysics of Galaxies},
           year = 2021,
          month = jul,
         volume = {4},
         number = {1},
            eid = {7},
          pages = {7},
            doi = {10.21105/astro.2105.05859},
  archivePrefix = {arXiv},
         eprint = {2105.05859},
   primaryClass = {astro-ph.CO},
         adsurl = {https://ui.adsabs.harvard.edu/abs/2021OJAp....4E...7H},
        adsnote = {Provided by the SAO/NASA Astrophysics Data System}
  }
  ```

rpm_license:
  BSD 3-Clause License  Copyright (c) 2021, Andrew Hearin 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: 93ade7c96979042009e5f33125999040d90a30e351870417a92efcc5192c47b3
name: python-digiflow-help
arch: noarch
version: 5.7.9
epoch: 0
release: 1
summary: Development documents and examples for digiflow
url: https://github.com/ulb-sachsen-anhalt/digital-flow
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-digiflow-5.7.9-1.src.rpm
location_href: Packages/python-digiflow-help-5.7.9-1.noarch.rpm
checksum_type: sha256
description:
  ![Python CI](https://github.com/ulb-sachsen-anhalt/digital-flow/actions/workflows/main.yml/badge.svg)
  [![PyPi version](https://badgen.net/pypi/v/digiflow/)](https://pypi.org/project/digiflow/) ![PyPI - Downloads](https://img.shields.io/pypi/dm/digiflow) ![PyPI - License](https://img.shields.io/pypi/l/digiflow) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/digiflow)

  Father's little helper for internal library digitalization workflows running on Linux-Systems. Use at own risk.



  Execute `tox` in a closed environment:

  ```bash
  setup_tox.sh your-python-tox-image
  docker build --tag <your-test-image> --build-arg BASE_IMAGE=<your-python-tox-image> -f Dockerfile.tox .
  docker run --rm <your-test-image> tox
  ```



  This project's source code is licensed under terms of the [MIT license](https://opensource.org/licenses/MIT).

  NOTE: This project depends on components that may use different license terms.


pkgId: eab8f28f5d18500e0d7f9ce8de20a285385ea14f6c2db7a663c712965758613a
name: python-digital-payments-sdk-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for digital-payments-sdk
url: https://pypi.org/project/digital-payments-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-digital-payments-sdk-1.1.0-1.src.rpm
location_href: Packages/python-digital-payments-sdk-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  The APIs detailed within this document will enable Shell's Fleet Solutions Customers to digitalize Shell Card/s and use them to pay to refuel their vehicles at Shell Stations.



  The package is compatible with Python versions `3 >=3.7, <= 3.11`.
  Install the package from PyPi using the following pip command:

  ```bash
  pip install digital-payments-sdk==1.1.0
  ```

  You can also view the package at:
  https://pypi.python.org/pypi/digital-payments-sdk/1.1.0



  You can test the generated SDK and the server with test cases. `unittest` is used as the testing framework and `pytest` is used as the test runner. You can run the tests as follows:

  Navigate to the root directory of the SDK and run the following commands

  ```
  pip install -r test-requirements.txt
  pytest
  ```



  **_Note:_** Documentation for the client can be found [here.](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/client.md)

  The following parameters are configurable for the API Client:

  | Parameter | Type | Description |
  |  --- | --- | --- |
  | `environment` | `Environment` | The API environment. <br> **Default: `Environment.TEST`** |
  | `http_client_instance` | `HttpClient` | The Http Client passed from the sdk user for making requests |
  | `override_http_client_configuration` | `bool` | The value which determines to override properties of the passed Http Client from the sdk user |
  | `http_call_back` | `HttpCallBack` | The callback value that is invoked before and after an HTTP call is made to an endpoint |
  | `timeout` | `float` | The value to use for connection timeout. <br> **Default: 60** |
  | `max_retries` | `int` | The number of times to retry an endpoint call if it fails. <br> **Default: 0** |
  | `backoff_factor` | `float` | A backoff factor to apply between attempts after the second try. <br> **Default: 2** |
  | `retry_statuses` | `Array of int` | The http statuses on which retry is to be done. <br> **Default: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]** |
  | `retry_methods` | `Array of string` | The http methods on which retry is to be done. <br> **Default: ['GET', 'PUT']** |
  | `mpp_token_credentials` | [`MppTokenCredentials`](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/auth/custom-header-signature.md) | The credential object for Custom Header Signature |
  | `o_auth_token_post_credentials` | [`OAuthTokenPostCredentials`](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/auth/custom-header-signature-1.md) | The credential object for Custom Header Signature |

  The API client can be initialized as follows:

  ```python
  client = ShellsmartpayapiClient(
      mpp_token_credentials=MppTokenCredentials(
          authorization='Authorization'
      ),
      o_auth_token_post_credentials=OAuthTokenPostCredentials(
          x_apigee_authorization='X-Apigee-Authorization'
      ),
      environment=Environment.TEST
  )
  ```



  The SDK can be configured to use a different environment for making API calls. Available environments are:



  | Name | Description |
  |  --- | --- |
  | Test | **Default** |
  | Production | - |



  This API uses the following authentication schemes.

  * [`MppToken (Custom Header Signature)`](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/auth/custom-header-signature.md)
  * [`oAuthTokenPost (Custom Header Signature)`](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/auth/custom-header-signature-1.md)



  * [Shell API Platform Security Authentication](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/controllers/shell-api-platform-security-authentication.md)
  * [Digital Payment Enablement](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/controllers/digital-payment-enablement.md)
  * [Station Locator](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/controllers/station-locator.md)
  * [Partner Notification](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/controllers/partner-notification.md)
  * [Fueling](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/controllers/fueling.md)



  * [Utility Classes](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/utility-classes.md)
  * [HttpResponse](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/http-response.md)
  * [HttpRequest](https://www.github.com/sdks-io/digital-payments-python-sdk/tree/1.1.0/doc/http-request.md)


pkgId: f1d7dd3f5c9ec853b1f4b892ecdd82116f78bdfecb17f2deeebb4fef83fc02e1
name: python-digitalmarketplace-developer-tools-help
arch: noarch
version: 1.3.1
epoch: 0
release: 1
summary: Development documents and examples for digitalmarketplace-developer-tools
url: https://github.com/Crown-Commercial-Service/digitalmarketplace-developer-tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-digitalmarketplace-developer-tools-1.3.1-1.src.rpm
location_href: Packages/python-digitalmarketplace-developer-tools-help-1.3.1-1.noarch.rpm
checksum_type: sha256
description:
  Common developer tooling for Digital Marketplace repos.



  Install [the digitalmarketplace-developer-tools package from PyPI][package] and
  run Invoke in a Digital Marketplace repo to see what tasks are available:

  ```
  $ pip install digitalmarketplace-developer-tools
  $ invoke --list
  ```





  Developers on the Digital Marketplace need to be able to easily set-up a
  developer environment for a repo, so they can quickly start making changes to
  the code.

  Traditionally this need has been met with `make`, however on the Digital
  Marketplace we are starting to use [Invoke][pyinvoke] instead.

  Invoke lets us write tasks once and use them for multiple repos. Being written
  in Python, we can create a library of tasks and publish them on PyPI for reuse.
  The [package for this repo][package] includes these tasks.

  To start using the tasks in a repo, add a `tasks.py` file and import the
  collection of tasks appropriate for the repo. For instance, for a frontend app:

  ```

  from dmdevtools.invoke_tasks import frontend_app_tasks as ns
  ```

  The `as ns` part is needed so that the `invoke` command line tool sees the
  imported tasks, read the [Invoke documentation on collections and
  namespaces][1] for more details on how this works.

  For backwards-compatibility, `make` can still be used for a repo. Just copy the
  [`Makefile` from this repo](Makefile) (or just the `%` goal), and any
  unrecognised goals will be sent to `invoke`.

  [1]: http://docs.pyinvoke.org/en/stable/concepts/namespaces.html#starting-out



  This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
  Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.



  Unless stated otherwise this codebase is released under [the MIT
  License][licence]. This covers both the codebase and any sample code in the
  documentation.

  The documentation is [&copy; Crown copyright][copyright] and available under
  the terms of the [Open Government 3.0][ogl] licence.

  [licence]: LICENCE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/

  [package]: https://pypi.org/project/digitalmarketplace-developer-tools
  [pyinvoke]: pyinvoke.org

  [pre-commit hook]: https://pre-commit.com/
  [pre-commit quick start]: https://pre-commit.com/#quick-start


pkgId: 8991c3104795b124cbba7575ecc9e0df92faa3eebc4aec986e103091e6c8b464
name: python-digitz-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for digitz
url: https://pypi.org/project/digitz/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-digitz-0.5.0-1.src.rpm
location_href: Packages/python-digitz-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install digitz
  ```

  ```
  >>> from digitz import PhoneNumber
  >>> num = PhoneNumber.parse("+1 (201) 555-0123")
  >>> num.region_code
  'US'
  >>> num.is_possible
  True
  >>> num.national_destination_code
  '201'
  >>> num.to_e164()
  '+12015550123'
  >>> num.to_national()
  '(201) 555-0123'
  >>> num.to_international()
  '+1 201-555-0123'
  ```

  `digitz` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: 30e35f3fb30ec72777d5cc60559c67e26c857709b9b58d721a53f3b142140361
name: python-dihlibs-help
arch: noarch
version: 0.0.56
epoch: 0
release: 1
summary: Development documents and examples for dihlibs
url: https://github.com/nKataraia/dihlibs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dihlibs-0.0.56-1.src.rpm
location_href: Packages/python-dihlibs-help-0.0.56-1.noarch.rpm
checksum_type: sha256
description:
  `dihlibs` is a Python package designed to simplify and enhance data integration and handling tasks. Whether you're dealing with data ingestion, preprocessing, transformation, or integration from various sources, `dihlibs` offers a set of tools and utilities to make these tasks more straightforward and efficient.



  - **Data Ingestion**: Easily import data from multiple sources like databases, files, or APIs.
  - **Data Transformation**: Transform data with a set of powerful, easy-to-use functions.
  - **Integration Utilities**: Seamlessly integrate data from different formats and standards.
  - **Preprocessing Tools**: Prepare your data for analysis with preprocessing capabilities.



  Install `dihlibs` using pip:

  ```bash
  pip install dihlibs


pkgId: 36c3af07f5d54a88dff479a6acc6afd72eaa284699b748674960a33cd933a483
name: python-dimo-python-sdk-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for dimo-python-sdk
url: https://github.com/DIMO-Network/dimo-python-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dimo-python-sdk-1.1.0-1.src.rpm
location_href: Packages/python-dimo-python-sdk-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  You can install the SDK using `pip`

  ```bash
  pip install dimo-python-sdk
  ```



  Coming Soon



  Please visit the DIMO [Developer Documentation](https://docs.dimo.org/developer-platform) to learn more about building on DIMO and detailed information on the API.




  In order to build on DIMO, you’ll need to get a [DIMO Developer License](https://docs.dimo.zone/developer-platform/getting-started/developer-license) via the [DIMO Dev Console](https://console.dimo.org/). The DIMO Developer license is our approach and design to a more secured, decentralized access control. As a developer, you will need to perform the following steps:

  1. Sign Up for an Account - You can use your Google or Github account to register.
  2. Complete Registration - Enter the details of the application that you’re building.
  3. Create An App - Click “Create App”, fill out the form & select your preferred environment (at this time, please select “Production” until we’re ready to launch our Sandbox environment), then hit “Create Application”.
  4. Finish Configuring Your Application - Once your project is initialized, you’ll use your connected wallet to generate an API Key and any optional Redirect URIs.

  More information about this process can be found on our docs [here](https://docs.dimo.org/developer-platform/getting-started/developer-guide/developer-console)



  Importing the SDK:

  ```python
  from dimo import DIMO
  ```

  Initiate the SDK depending on the envionrment of your interest, we currently support both `Production` and `Dev` environments:

  ```python
  dimo = DIMO("Production")
  ```

  or

  ```python
  dimo = DIMO("Dev")
  ```



  To get authenticated as a developer, you must have already obtained a [Developer License via the Console](https://docs.dimo.org/developer-platform/getting-started/developer-guide/developer-console#getting-a-license). To learn more about authentication, including the User JWT, Developer JWT, and Vehicle JWT needed for accessing certain endpoints, please read: [Authentication Docs](https://docs.dimo.org/developer-platform/getting-started/developer-guide/authentication).





  The SDK offers 3 basic functions that maps to the steps listed in [Authentication](https://docs.dimo.org/developer-platform/getting-started/developer-guide/authentication): `generate_challenge`, `sign_challenge`, and `submit_challenge`. You can use them accordingly depending on how you build your application.

  ```python
      challenge = dimo.auth.generate_challenge(
          client_id = '<client_id>',
          domain = '<domain>',
          address = '<address>'
      )

      signature = dimo.auth.sign_challenge(
          message = challenge['challenge'],
          private_key = '<private_key>'
      )

      tokens = dimo.auth.submit_challenge(
          client_id = '<client_id>',
          domain = '<domain>',
          state = challenge['state'],
          signature = signature
      )
  ```



  As mentioned earlier, this is the streamlined function call to directly get the `developer_jwt`. The `address` field in challenge generation is omitted since it is essentially the `client_id` of your application per Developer License:

  ```python
  auth_header = dimo.auth.get_token(
      client_id = '<client_id>',
      domain = '<domain>',
      private_key = '<private_key>'
  )


  dev_jwt = auth_header["access_token"]
  ```



  The SDK uses the [requests](https://requests.readthedocs.io/en/latest/) library for making HTTP requests. You can perform a query like so:

  ```python
  def decode_vin():
      device_makes = dimo.device_definitions.decode_vin(
          developer_jwt = dev_jwt,
          country_code = "USA",
          vin = "<VIN>"
      )
      
  ```



  For query parameters, simply feed in an input that matches with the expected query parameters:

  ```python
  dimo.device_definitions.search_device_definitions(
      query = "Lexus gx 2023"
  )
  ```




  As the 2nd leg of the API authentication, applications may exchange for short-lived Vehicle JWTs for specific vehicles that granted privileges to the app. This uses the [DIMO Token Exchange API](https://docs.dimo.org/developer-platform/api-references/token-exchange-api).

  For the end users of your application, they will need to share their vehicle permissions via the DIMO Mobile App or through your implementation of the [Login with DIMO flow](https://docs.dimo.org/developer-platform/getting-started/developer-guide/login-with-dimo). You can use the pre-built React component SDK, or redirect users to the URLs included in the documentation [here](https://docs.dimo.org/developer-platform/getting-started/developer-guide/login-with-dimo#dont-use-react).

  Typically, any endpoints that uses a NFT `tokenId` in path parameters will require JWTs. You can use this flow to obtain a privilege token.

  ```python

  get_vehicle_jwt = dimo.token_exchange.exchange(
      developer_jwt = dev_jwt,
      
      privileges=[1, 3, 4, 5],
      
      token_id="<token_id>"
      
      )
  vehicle_jwt = get_vehicle_jwt['token']
  ```

  Once you have the privilege token, you can pipe it through to corresponding endpoints like so:

  ```python
  def my_trips():
      trip_data = dimo.trips.trips(
          vehicle_jwt=vehicle_jwt,
          token_id=<token_id>
          )
      return trip_data
  ```



  The SDK accepts any type of valid custom GraphQL queries, but we've also included a few sample queries to help you understand the DIMO GraphQL APIs.



  The GraphQL entry points are designed almost identical to the REST API entry points. For any GraphQL API that requires auth headers (Telemetry API for example), you can use the same pattern as you would in the REST protected endpoints.

  ```python

  telemetry_data = dimo.telemetry.query(
      vehicle_jwt=vehicle_jwt,
      query= """
          query {
              some_valid_GraphQL_query
              }
          """
      )
  ```



  To send a custom GraphQL query, you can simply call the `query` function on any GraphQL API Endpoints and pass in any valid GraphQL query. To check whether your GraphQL query is valid, please visit our [Identity API GraphQL Playground](https://identity-api.dimo.zone/) or [Telemetry API GraphQL Playground](https://telemetry-api.dimo.zone/).

  ```python
  my_query = """
      {
      vehicles (first:10) {
          totalCount
          }
      }
      """

  total_network_vehicles = dimo.identity.query(query=my_query)
  ```



  You can read more about contributing [here](https://github.com/DIMO-Network/dimo-python-sdk/blob/dev-barrettk/CONTRIBUTING.md)


pkgId: c9daf199081184bc6d8f8d67340376ee0d48b78344b4332b0f02a63ca0fa28a5
name: python-dinamis-sdk-help
arch: noarch
version: 0.3.4
epoch: 0
release: 1
summary: Development documents and examples for dinamis-sdk
url: https://pypi.org/project/dinamis-sdk/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dinamis-sdk-0.3.4-1.src.rpm
location_href: Packages/python-dinamis-sdk-help-0.3.4-1.noarch.rpm
checksum_type: sha256
description:
  <br>
  <a href="https://forgemia.inra.fr/cdos-pub/dinamis-sdk/-/releases">
  <img src="https://forgemia.inra.fr/cdos-pub/dinamis-sdk/-/badges/release.svg">
  </a>
  <a href="https://forgemia.inra.fr/cdos-pub/dinamis-sdk/-/commits/main">
  <img src="https://forgemia.inra.fr/cdos-pub/dinamis-sdk/badges/main/pipeline.svg">
  </a>
  <a href="LICENSE">
  <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg">
  </a>

  Largely inspired from the *Microsoft Planetary Computer SDK*, **Dinamis-SDK** is
  built on the STAC ecosystem to provide easy access to remote sensing imagery
  and thematic products of the [THEIA-MTP geospatial data center](https://home-cdos.apps.okd.crocc.meso.umontpellier.fr/).

  ```python
  import dinamis_sdk
  import pystac_client

  api = pystac_client.Client.open(
     'https://stacapi-cdos.apps.okd.crocc.meso.umontpellier.fr',
     modifier=dinamis_sdk.sign_inplace,
  )
  ```

  For more information read the
  [documentation](https://cdos-pub.pages.mia.inra.fr/dinamis-sdk).

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2022-2023 INRAE  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: cd59ecf19076ba0245366ef8fdef75b9083b3cb41b926a835c5cbd2be7c9c157
name: python-ding-api-client-help
arch: noarch
version: 3.9.47
epoch: 0
release: 1
summary: Development documents and examples for ding-api-client
url: https://github.com/ding-live/ding-python.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ding-api-client-3.9.47-1.src.rpm
location_href: Packages/python-ding-api-client-help-3.9.47-1.noarch.rpm
checksum_type: sha256
description:
  The Ding Python library provides convenient access to the Ding API from applications written in the Python language.

  <!-- Start Summary [summary] -->


  Ding: The OTP API allows you to send authentication codes to your users using their phone numbers.
  <!-- End Summary [summary] -->

  <!-- Start Table of Contents [toc] -->

  <!-- $toc-max-depth=2 -->
  * [Ding Python SDK](https://github.com/ding-live/ding-python/blob/master/#ding-python-sdk)
    * [SDK Installation](https://github.com/ding-live/ding-python/blob/master/#sdk-installation)
    * [SDK Example Usage](https://github.com/ding-live/ding-python/blob/master/#sdk-example-usage)
    * [SDK Example Usage](https://github.com/ding-live/ding-python/blob/master/#sdk-example-usage-1)
    * [Available Resources and Operations](https://github.com/ding-live/ding-python/blob/master/#available-resources-and-operations)
    * [Error Handling](https://github.com/ding-live/ding-python/blob/master/#error-handling)
    * [Server Selection](https://github.com/ding-live/ding-python/blob/master/#server-selection)
    * [Custom HTTP Client](https://github.com/ding-live/ding-python/blob/master/#custom-http-client)
    * [Authentication](https://github.com/ding-live/ding-python/blob/master/#authentication)
  * [Development](https://github.com/ding-live/ding-python/blob/master/#development)
    * [Contributions](https://github.com/ding-live/ding-python/blob/master/#contributions)

  <!-- End Table of Contents [toc] -->

  <!-- Start SDK Installation [installation] -->


  The SDK can be installed using the *pip* package manager, with dependencies and metadata stored in the `setup.py` file.

  ```bash
  pip install ding_api_client
  ```
  <!-- End SDK Installation [installation] -->



  <!-- Start SDK Example Usage [usage] -->




  Send an OTP code to a user's phone number.


  ```python
  import ding
  from ding.models import components

  s = ding.Ding(
      api_key='YOUR_API_KEY',
  )


  res = s.otp.create_authentication(request=components.CreateAuthenticationRequest(
      customer_uuid='c9f826e0-deca-41ec-871f-ecd6e8efeb46',
      phone_number='+1234567890',
      locale='fr-FR',
  ))

  if res.create_authentication_response is not None:
      
      pass

  ```



  Check that a code entered by a user is valid.


  ```python
  import ding
  from ding.models import components

  s = ding.Ding(
      api_key='YOUR_API_KEY',
  )


  res = s.otp.check(request=components.CreateCheckRequest(
      customer_uuid='e0e7b0e9-739d-424b-922f-1c2cb48ab077',
      authentication_uuid='8f1196d5-806e-4b71-9b24-5f96ec052808',
      check_code='123456',
  ))

  if res.create_check_response is not None:
      
      pass

  ```



  Perform a retry if a user has not received the code.


  ```python
  import ding

  s = ding.Ding(
      api_key='YOUR_API_KEY',
  )


  res = s.otp.retry()

  if res.retry_authentication_response is not None:
      
      pass

  ```



  Send feedback about the authentication process.


  ```python
  import ding
  from ding.models import components

  s = ding.Ding(
      api_key='YOUR_API_KEY',
  )


  res = s.otp.feedback(request=components.FeedbackRequest(
      customer_uuid='c0c405fa-6bcb-4094-9430-7d6e2428ff23',
      phone_number='+1234567890',
      status=components.FeedbackRequestStatus.ONBOARDED,
  ))

  if res.feedback_response is not None:
      
      pass

  ```



  Get the status of an authentication.


  ```python
  import ding

  s = ding.Ding(
      api_key='YOUR_API_KEY',
  )


  res = s.otp.get_authentication_status(auth_uuid='d8446450-f2fa-4dd9-806b-df5b8c661f23')

  if res.authentication_status_response is not None:
      
      pass

  ```



  Perform a phone number lookup.


  ```python
  import ding

  s = ding.Ding(
      api_key='YOUR_API_KEY',
  )


  res = s.lookup.lookup(phone_number='<value>', customer_uuid='6e93aa15-9177-4d09-8395-b69ce50db1c8')

  if res.lookup_response is not None:
      
      pass

  ```
  <!-- End SDK Example Usage [usage] -->

  <!-- Start Available Resources and Operations [operations] -->


  <details open>
  <summary>Available methods</summary>




  * [lookup](https://github.com/ding-live/ding-python/blob/master/docs/sdks/lookup/README.md#lookup) - Look up for phone number



  * [create_authentication](https://github.com/ding-live/ding-python/blob/master/docs/sdks/otp/README.md#create_authentication) - Send a code
  * [check](https://github.com/ding-live/ding-python/blob/master/docs/sdks/otp/README.md#check) - Check a code
  * [feedback](https://github.com/ding-live/ding-python/blob/master/docs/sdks/otp/README.md#feedback) - Send feedback
  * [get_authentication_status](https://github.com/ding-live/ding-python/blob/master/docs/sdks/otp/README.md#get_authentication_status) - Get authentication status
  * [retry](https://github.com/ding-live/ding-python/blob/master/docs/sdks/otp/README.md#retry) - Perform a retry

  </details>
  <!-- End Available Resources and Operations [operations] -->

  <!-- Start Error Handling [errors] -->


  Handling errors in this SDK should largely match your expectations. All operations return a response object or raise an exception.

  By default, an API error will raise a errors.SDKError exception, which has the following properties:

  | Property        | Type             | Description           |
  |-----------------|------------------|-----------------------|
  | `.status_code`  | *int*            | The HTTP status code  |
  | `.message`      | *str*            | The error message     |
  | `.raw_response` | *httpx.Response* | The raw HTTP response |
  | `.body`         | *str*            | The response content  |

  When custom error responses are specified for an operation, the SDK may also raise their associated exception. You can refer to respective *Errors* tables in SDK docs for more details on possible exception types for each operation. For example, the `create_authentication` method may raise the following exceptions:

  | Error Type           | Status Code | Content Type     |
  | -------------------- | ----------- | ---------------- |
  | errors.ErrorResponse | 400         | application/json |
  | errors.SDKError      | 4XX, 5XX    | \*/\*            |



  ```python
  import ding
  from ding.models import components, errors

  s = ding.Ding(
      api_key='YOUR_API_KEY',
  )

  res = None
  try:
      res = s.otp.create_authentication(request=components.CreateAuthenticationRequest(
      customer_uuid='c9f826e0-deca-41ec-871f-ecd6e8efeb46',
      phone_number='+1234567890',
      locale='fr-FR',
  ))

  except errors.ErrorResponse as e:
      
      raise(e)
  except errors.SDKError as e:
      
      raise(e)

  if res.create_authentication_response is not None:
      
      pass

  ```
  <!-- End Error Handling [errors] -->

  <!-- Start Server Selection [server] -->




  The default server can also be overridden globally by passing a URL to the `server_url: str` optional parameter when initializing the SDK client instance. For example:
  ```python
  import ding
  from ding.models import components

  s = ding.Ding(
      server_url='https://api.ding.live/v1',
      api_key='YOUR_API_KEY',
  )


  res = s.otp.create_authentication(request=components.CreateAuthenticationRequest(
      customer_uuid='c9f826e0-deca-41ec-871f-ecd6e8efeb46',
      phone_number='+1234567890',
      locale='fr-FR',
  ))

  if res.create_authentication_response is not None:
      
      pass

  ```
  <!-- End Server Selection [server] -->

  <!-- Start Custom HTTP Client [http-client] -->


  The Python SDK makes API calls using the [requests](https://pypi.org/project/requests/) HTTP library.  In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with a custom `requests.Session` object.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  import ding
  import requests

  http_client = requests.Session()
  http_client.headers.update({'x-custom-header': 'someValue'})
  s = ding.Ding(client=http_client)
  ```
  <!-- End Custom HTTP Client [http-client] -->

  <!-- Start Authentication [security] -->




  This SDK supports the following security scheme globally:

  | Name      | Type   | Scheme  |
  | --------- | ------ | ------- |
  | `api_key` | apiKey | API key |

  To authenticate with the API the `api_key` parameter must be set when initializing the SDK client instance. For example:
  ```python
  import ding
  from ding.models import components

  s = ding.Ding(
      api_key='YOUR_API_KEY',
  )


  res = s.otp.create_authentication(request=components.CreateAuthenticationRequest(
      customer_uuid='c9f826e0-deca-41ec-871f-ecd6e8efeb46',
      phone_number='+1234567890',
      locale='fr-FR',
  ))

  if res.create_authentication_response is not None:
      
      pass

  ```
  <!-- End Authentication [security] -->

  <!-- Placeholder for Future Speakeasy SDK Sections -->





  While we value open-source contributions to this SDK, this library is generated programmatically.
  Feel free to open a PR or a Github issue as a proof of concept and we'll do our best to include it in a future release!


pkgId: 8305d699f05b73ac4575b589670859e549bb7ce658720d15c310839e56b524bc
name: python-dinosaur-dycore-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for dinosaur-dycore
url: https://pypi.org/project/dinosaur-dycore/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dinosaur-dycore-1.1.2-1.src.rpm
location_href: Packages/python-dinosaur-dycore-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  ![](./dinosaur-logo.png)



  Authors: Jamie A. Smith, Dmitrii Kochkov, Peter Norgaard, Janni Yuval, Stephan Hoyer

  Dinosaur is a spectral dynamical core for global atmospheric modeling written in
  JAX:

  - *Dynamics*: Dinosaur solves the shallow water equations, and the primitive equations (moist and dry) on sigma coordinates.
  - *Auto-diff*: Dinosaur supports both forward- and backward-mode automatic differentiation in JAX.
  - *Acceleration*: Dinosaur is designed to run efficiently on modern accelerator
  hardware (GPU/TPU), including parallelization across multiple devices.

  For more details, see our paper on [Neural General Circulation Models](https://arxiv.org/abs/2311.07222).



  Dinosaur is an experimental research project that we are still working on
  documenting.

  We currently have examples replicating two standard test-cases for dynamical cores:

  - [Baroclinic instability](https://nbviewer.org/github/neuralgcm/dinosaur/blob/main/notebooks/baroclinic_instability.ipynb)
  - [Held-Suarez forcing](https://nbviewer.org/github/neuralgcm/dinosaur/blob/main/notebooks/held_suarez.ipynb)

  We recommend running them using [Google Colab](https://colab.research.google.com/) with a GPU runtime.
  You can also install Dinosaur locally: `pip install git+https://github.com/neuralgcm/dinosaur`



  If you like Dinosaur, you might also like
  [SpeedyWeather.jl](https://github.com/SpeedyWeather/SpeedyWeather.jl), which
  solves similar equations in Julia.



  See [`CONTRIBUTING.md`](CONTRIBUTING.md) for details. We are open to user
  contributions, but please reach out (either on GitHub or by email) to coordinate
  before starting significant work.



  Apache 2.0; see [`LICENSE`](LICENSE) for details.

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


pkgId: 3fe72aa48874c9762b03b3452991bdf198187491fa27fefff9d1942ff1056507
name: python-diplomat-track-help
arch: noarch
version: 0.1.14
epoch: 0
release: 1
summary: Development documents and examples for diplomat-track
url: https://pypi.org/project/diplomat-track/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-diplomat-track-0.1.14-1.src.rpm
location_href: Packages/python-diplomat-track-help-0.1.14-1.noarch.rpm
checksum_type: sha256
description:
  Deep learning-based Identity Preserving Labeled-Object Multi-Animal Tracking.

  **NOTE:** DIPLOMAT is currently early beta software, there may be minor bugs and usability issues.

  If you are a user (not a developer contributing code), you may want to visit:
  - the software website: [https://wheelerlab.org/DIPLOMAT](https://wheelerlab.org/DIPLOMAT/)
  - in-depth documentation: [https://diplomat.readthedocs.io](https://diplomat.readthedocs.io/en/latest)



  DIPLOMAT provides a multi-animal pose estimation and editing interface. It relies on a trained CNN model (currently supporting SLEAP and DeepLabCut packages) and uses algorithms to first _**Track**_ the animal body part in a way that reduces body part losses and identity swaps, and then provides an intuitive and memory/time efficient _**Interact**_ interface to edit and re-track as needed. DIPLOMAT differs from other multi-animal tracking packages by working directly off of confidence maps instead of running peak detection, allowing for more nuanced tracking results.

  ![UI Demo Showing user correcting tracking in a video](interact_retrack_gif.gif)

  **Correcting and rerunning the Viterbi algorithm on the Interact Interface**

  | Example of tracking 2 Degus in a Box | Example of tracking 3 Rats |
  |:------------------------------------:|:--------------------------:|
  | ![Example of tracking 2 Degus](https://raw.githubusercontent.com/TravisWheelerLab/DIPLOMAT/main/docs/source/_static/imgs/example1.png) | ![Example of tracking 3 Rats](https://raw.githubusercontent.com/TravisWheelerLab/DIPLOMAT/main/docs/source/_static/imgs/example2.png) |


  For detailed installation instructions, please refer to the [documentation](https://diplomat.readthedocs.io/en/latest/installation.html)!





  To run DIPLOMAT on a video once it is installed, simply use DIPLOMAT's `unsupervised` and `supervised` commands to track a video:
  ```bash

  diplomat track -c path/to/config -v path/to/video

  diplomat track_and_interact -c path/to/config -v path/to/video
  ```

  Multiple videos can be tracked by passing them as a list:
  ```bash
  diplomat track -c path/to/config -v [path/to/video1, path/to/video2, "path/to/video3"]
  ```

  Once tracking is done, DIPLOMAT can create labeled videos via it's `annotate` subcommand:
  ```bash
  diplomat annotate -c path/to/config -v path/to/video
  ```

  If you need to reopen the UI to make further major modifications, you can do so using the interact subcommand:
  ```bash
  diplomat interact -s path/to/ui_state.dipui
  ```
  This displays the full UI again for making further edits. Results are saved back to the same files.

  If you need to make minor modifications after tracking a video, you can do so using the tweak subcommand:
  ```bash
  diplomat tweak -c path/to/config -v path/to/video
  ```
  This will display a stripped down version of the interactive editing UI, allowing for minor tweaks to be made to the
  tracks, and then saved back to the same file.

  For a list of additional ways DIPLOMAT can be used, see the [documentation](https://diplomat.readthedocs.io/en/latest/basic_usage.html).



  All DIPLOMAT commands are documented via help strings. To get more information about a diplomat subcommand or command, simply run it with the `-h` or `--help` flag.

  ```bash

  diplomat --help

  diplomat track --help

  diplomat predictors --help
  ```



  DIPLOMAT has documentation on ReadTheDocs at [https://diplomat.readthedocs.io/en/latest](https://diplomat.readthedocs.io/en/latest).



  DIPLOMAT is written entirely in python. To set up an environment for developing DIPLOMAT, you can simply pull down this repository and install its
  requirements using pip. For a further description of how to set up DIPLOMAT for development, see the
  [Development Usage](https://diplomat.readthedocs.io/en/latest/advanced_usage.html#development-usage) section in the documentation.



  We welcome external contributions, although it is a good idea to contact the
  maintainers before embarking on any significant development work to make sure
  the proposed changes are a good fit.

  Contributors agree to license their code under the license in use by this
  project (see `LICENSE`).

  To contribute:

    1. Fork the repo
    2. Make changes on a branch
    3. Create a pull request



  See `LICENSE` for details.



  If you have any questions, feel free to reach out to George Glidden, at [georgeglidden@arizona.edu](mailto:georgeglidden@arizona.edu)

  See `AUTHORS` the full list of authors.


pkgId: 0071cd76640184983cb8156d17858c3ccaf2ec6a94da74d76ed6e6c1f63069fc
name: python-diracx-help
arch: noarch
version: 0.0.1a21
epoch: 0
release: 1
summary: Development documents and examples for diracx
url: https://pypi.org/project/diracx/
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-diracx-0.0.1a21-1.src.rpm
location_href: Packages/python-diracx-help-0.0.1a21-1.noarch.rpm
checksum_type: sha256
description:
  ![DiracX tests](https://github.com/DIRACGrid/diracx/actions/workflows/main.yml/badge.svg?branch=main)
  ![Legacy tests](https://github.com/DIRACGrid/diracx/actions/workflows/integration.yml/badge.svg?branch=main)
  ![security: bandit](https://github.com/DIRACGrid/diracx/actions/workflows/main.yml/badge.svg?branch=main)



  This repository contains the code for DiracX.
  It is still incomplete. Check the current progress on our [status board](https://github.com/orgs/DIRACGrid/projects/2/views/2).

  Feel free to look around however try not to draw any conclusions as the code is still rapidly evolving.



  Follow the instructions in the [diracx-charts README](https://github.com/DIRACGrid/diracx-charts?tab=readme-ov-file#running-the-demo-locally) to try it out.



  The documentation is scattered around [various files](./docs/).



  - [The NeXt Dirac Incarnation - CHEP 24](https://indico.cern.ch/event/1338689/contributions/6010971/)
  - [Eventually coming with some Documentation - Dirac User Workshop 24](https://indico.cern.ch/event/1341205/contributions/5972930/)
  - [Demo and Technical details - Dirac & Rucio Workshop 23](https://indico.cern.ch/event/1252369/contributions/5515392/)
  - [Dirac: future Part1](https://indico.cern.ch/event/1292287/) and [Part2 -  Bild-Dev meeting June 23](https://indico.cern.ch/event/1297397/)


pkgId: dfb8ed3c39618545046e67c6c84a62b547e82f4c97b52fa1de8b968cdbea8216
name: python-diresa-help
arch: noarch
version: 1.0.16
epoch: 0
release: 1
summary: Development documents and examples for diresa
url: https://gitlab.com/etrovub/ai4wcm/public/diresa
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-diresa-1.0.16-1.src.rpm
location_href: Packages/python-diresa-help-1.0.16-1.noarch.rpm
checksum_type: sha256
description:
  ![test](https://gitlab.com/etrovub/ai4wcm/public/diresa/badges/master/pipeline.svg?ignore_skipped=true&key_text=test&key_width=35)
  ![release](https://gitlab.com/etrovub/ai4wcm/public/diresa/-/badges/release.svg?key_text=pypi&key_width=35)
  ![python](https://img.shields.io/badge/python-3.8%20|%203.9%20|%203.10%20|%203.11%20|%203.12-blue)
  ![tensorflow](https://img.shields.io/badge/tensorflow-2.12%20|%202.13%20|%202.14%20|%202.15%20|%202.16%20|%202.17%20|%202.18-orange)
  ![mit](https://img.shields.io/badge/license-MIT-yellow)



  *DIRESA* is a Python package for dimension reduction based on
  [TensorFlow](https://www.tensorflow.org). The distance-regularized
  Siamese twin autoencoder architecture is designed to preserve distance
  (ordering) in latent space while capturing the non-linearities in
  the datasets.




  Install *DIRESA* with the following command:

  ``` bash
    pip install diresa
  ```



  The *DIRESA* documentation can be found on [Read the Docs](https://diresa-learn.readthedocs.io)


pkgId: ce3d4143124ae56de1ecfcfd978b4e835b91f59e37341cb52d6a7954c454d3ad
name: python-dirmapper-core-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for dirmapper-core
url: https://pypi.org/project/dirmapper-core/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dirmapper-core-0.2.0-1.src.rpm
location_href: Packages/python-dirmapper-core-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  A directory mapping library that aids in visualization and directory structuring.


  A directory mapping library that aids in visualization and directory structuring.



  - Generate directory structures in various styles (tree, list, flat, etc.)
  - Apply custom formatting to directory structures (plain text, JSON, HTML, Markdown, etc.)
  - Ignore specific files and directories using patterns
  - Summarize directory contents using AI (local or API-based)



  To install the library, use pip:

  ```sh
  pip install dirmapper-core
  ```



  You can generate a directory structure using the `DirectoryStructureGenerator` class. Here is an example:
  ```python


  from dirmapper_core.generator.directory_structure_generator import DirectoryStructureGenerator
  from dirmapper_core.ignore.path_ignorer import PathIgnorer
  from dirmapper_core.styles.tree_style import TreeStyle
  from dirmapper_core.formatter.formatter import PlainTextFormatter


  ignore_patterns = [
      SimpleIgnorePattern('.git/'),
      SimpleIgnorePattern('.github/'),
      SimpleIgnorePattern('__pycache__/')
  ]


  path_ignorer = PathIgnorer(ignore_patterns)


  generator = DirectoryStructureGenerator(
      root_dir='./path/to/your/directory',
      output='output.txt',
      ignorer=path_ignorer,
      sorting_strategy=AscendingSortStrategy(case_sensitive=False),
      style=TreeStyle(),
      formatter=PlainTextFormatter()
  )


  structure = generator.generate() # Returns str
  ```
  Generating a directory structure results in a formatted string depending on your style and formatter. Here is an example of the `TreeStyle`:
  ```
  /path/to/root/directory
  ├── requirements.txt
  ├── tests/
  │   ├── test1.py
  │   └── __init__.py
  ├── docs/
  ├── README.md
  ├── setup.py
  ├── .gitignore
  ├── src/
  │   └── snake_game/
  │       ├── __init__.py
  │       ├── utils/
  │       │   └── helper.py
  │       └── main.py
  ```
  See the [styles](dirmapper_core/styles) folder for all valid style examples.

  You may also generate a raw DirectoryStructure object if you set the parameter `styled` to False in the `generate()` method. This allows access to the `DirectoryStructure` class helper functions and access to `DirectoryItems`
  ```python

  structure = generator.generate(styled=False) # Returns DirectoryStructure object


  for item in structure.to_list():
      if item.metadata.get('content') is not None:
          print(f"Content of {item.path}: {item.content}")
  ```


  You can create a directory structure from a template using the `StructureWriter` class. Here is an example:
  ```python
  from dirmapper_core.writer.structure_writer import StructureWriter


  base_path = 'Path/To/Your/Project'


  structure_template = {
      "meta": {
          "version": "2.0",
          "source": "dirmapper",
          "author": "root",
          "root_path": base_path,
          "creation_date": "2024-11-01T20:06:14.510200",
          "last_modified": "2024-11-01T20:06:14.510211"
      },
      "template": {
          "requirements.txt": {},
          "tests/": {
              "test1.py": {},
              "__init__.py": {}
          },
          "docs/": {},
          "README.md": {},
          "setup.py": {},
          ".gitignore": {},
          "src/": {
              "snake_game/": {
                  "__init__.py": {},
                  "utils/": {
                      "helper.py": {}
                  },
                  "main.py": {}
              }
          }
      }
  }


  writer = StructureWriter(base_path)


  writer.create_structure(structure_template)


  writer.write_structure()
  ```


  You can write the generated directory structure to a template file using the `write_template` function. Here is an example:
  ```python
  from dirmapper_core.writer.template_writer import write_template


  template_path = 'path/to/your/template.json'


  structure_template = {
      "meta": {
          "version": "1.1",
          "source": "dirmapper",
          "author": "root",
          "root_path": template_path,
          "creation_date": "2024-11-01T20:06:14.510200",
          "last_modified": "2024-11-01T20:06:14.510211"
      },
      "template": {
          "requirements.txt": {},
          "tests/": {
              "test1.py": {},
              "__init__.py": {}
          },
          "docs/": {},
          "README.md": {},
          "setup.py": {},
          ".gitignore": {},
          "src/": {
              "snake_game/": {
                  "__init__.py": {},
                  "utils/": {
                      "helper.py": {}
                  },
                  "main.py": {}
              }
          }
      }
  }

  write_template(template_path, structure_template)
  ```
  You may also use a valid styled directory string (i.e. `tree`) as your `structure_template` in the example above to write a YAML or JSON template file.


  You can create a JSON template from a formatted directory structure string. Here is a valid example using the `tree` style:
  ```python
  import json
  from dirmapper_core.writer.template_parser import TemplateParser

  tp = TemplateParser()
  template = """
  /path/to/root/directory
  ├── .git/
  ├── .github/
  │   └── workflows/
  │       ├── check_version.yaml
  │       ├── publish.yaml
  │       └── update-homebrew-formula.yml
  ├── .gitignore
  ├── .pytest_cache/
  ├── CHANGELOG.md
  ├── docs/
  ├── LICENSE
  ├── Makefile
  ├── pyproject.toml
  ├── README.md
  ├── requirements.txt
  ├── src/
  │   └── dirmapper/
  │       ├── __init__.py
  │       ├── ai/
  │       │   └── summarizer.py
  │       ├── api_client.py
  │       ├── config.py
  │       ├── config_manager.py
  │       ├── data/
  │       │   └── .mapping-ignore
  │       ├── main.py
  │       ├── reader/
  │       │   ├── __init__.py
  │       │   └── reader.py
  │       ├── token_manager.py
  │       └── writer/
  │           ├── __init__.py
  │           └── writer.py
  └── tests/
      ├── __init__.py
      └── test_main.py
  """
  parsed_template = tp.parse_from_directory_structure(template)
  print(json.dumps(parsed_template, indent=4))
  ```
  Other allowable styles include `list`, `flat`, and `indentation`.


  You can summarize the directory structure using the `DirectorySummarizer` class. Here is an example:
  ```python

  from dirmapper_core.generator.directory_structure_generator import DirectoryStructureGenerator
  from dirmapper_core.ai.summarizer import DirectorySummarizer
  from dirmapper_core.models.directory_structure import DirectoryStructure
  from dirmapper_core.models.directory_item import DirectoryItem


  config = {
      "use_local": False,
      "api_token": "your_openai_api_token",
      "summarize_file_content": True,  # Enable file content summarization
      "max_file_summary_words": 50     # Limit file summaries to 50 words
  }

  summarizer = DirectorySummarizer(config)


  root_dir = "path/to/root/project"
  dsg = DirectoryStructureGenerator("path/to/root/project")
  structure = dsg.generate(styled = False)


  result = summarizer.summarize(structure)
  print(json.dumps(result, indent=2))
  ```


  You can summarize individual files using the `FileSummarizer` class. Here is an example.
  ```python
  from dirmapper_core.ai.summarizer import FileSummarizer

  preferences = {
      "use_local": False,
      "api_token": "your_openai_api_token_here"
  }

  file_summarizer = FileSummarizer(preferences)
  file_path = "/path/to/your/file.py"
  summary = file_summarizer.summarize_file(file_path, max_words=150)
  print("File Summary:")
  print(summary)
  ```



  You can specify files and directories to ignore using the .mapping-ignore file or by providing patterns directly to the PathIgnorer class.

  Example `.mapping-ignore` file:
  ```

  .git/

  regex:^.*__pycache__$

  regex:^.*\.pyc$

  regex:^.*\.egg-info$

  regex:^.*dist$
  ```


  You can create custom styles and formatters by extending the BaseStyle and Formatter classes, respectively.



  All styles and many functions work with the DirectoryStructure class under the hood. This class is essentially an abstracted list of DirectoryItem objects. Below is a sample usage of initializing, adding items, and converting to a specialized dictionary object.
  ```python

  structure = DirectoryStructure()


  structure.add_item(DirectoryItem('/path/to/game', 0, 'game', {
      'type': 'folder',
      'content': None,
      'summary': None,
      'short_summary': None,
      'tags': []
  }))

  structure.add_item(DirectoryItem('/path/to/game/game_loop.py', 1, 'game_loop.py', {
      'type': 'file',
      'content': 'def main_loop():\n    while True:\n        update()\n        render()',
      'summary': None,
      'short_summary': None,
      'tags': []
  }))

  structure.add_item(DirectoryItem('/path/to/game/snake.py', 1, 'snake.py', {
      'type': 'file',
      'content': 'class Snake:\n    def __init__(self):\n        self.length = 1',
      'summary': None,
      'short_summary': None,
      'tags': []
  }))

      
      nested_dict = structure.to_nested_dict()

      
      print(json.dumps(nested_dict, indent=2))
  ```
  The above code will generate the following output to the console:
  ```json
  {
    "path": {
      "to": {
        "game": {
          "__keys__": {
            "type": "folder",
            "content": null,
            "summary": null,
            "short_summary": null,
            "tags": []
          },
          "game_loop.py": {
            "__keys__": {
              "type": "file",
              "content": "def main_loop():\n    while True:\n        update()\n        render()",
              "summary": null,
              "short_summary": null,
              "tags": []
            }
          },
          "snake.py": {
            "__keys__": {
              "type": "file",
              "content": "class Snake:\n    def __init__(self):\n        self.length = 1",
              "summary": null,
              "short_summary": null,
              "tags": []
            }
          }
        }
      }
    }
  }
  ```


  The most basic element of a directory structure is an item represented by the `DirectoryItem` class. This class is an abstracted object representing a `file` or `folder`. Each object holds valuable metadata about the underlying item, including summaries of the contents which can be generated with AI.
  ```python
      DirectoryItem(
          path='/path/to/project/README.md',
          level=1,
          name='README.md',
          metadata={
              'type': 'file',
              'size': '256B',
              'content': '# Project Documentation',
              'creation_date': '2024-01-01'
          }
      )
  ```


  Contributions are welcome! Please open an issue or submit a pull request on GitHub.


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

rpm_license:
  MIT License  Copyright (c) 2024 nashdean  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: 1efaf9b67e7dca8008688e0b759543a062ba4df8530337704a59d8404b74bf82
name: python-dirtyflags-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for dirtyflags
url: https://pypi.org/project/dirtyflags/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dirtyflags-1.2.0-1.src.rpm
location_href: Packages/python-dirtyflags-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  dirtyflags is a simple Python decorator that tracks when and which instance attributes have changed.


pkgId: a5eed1324b8c072ff4bd67b0eccf12c81654f3f3577a55dd50a5e5a8096b8e34
name: python-disba-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for disba
url: https://github.com/keurfonluu/disba
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-disba-0.7.0-1.src.rpm
location_href: Packages/python-disba-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  |License| |Stars| |Pyversions| |Version| |Downloads| |Code style: black| |Codacy Badge| |Codecov| |Build| |Travis| |Awesome| |DOI|
  **disba** is a computationally efficient Python library for the modeling of surface wave dispersion that implements a subset of codes from `Computer Programs in Seismology (CPS) <http://www.eas.slu.edu/eqc/eqccps.html>`__ in Python compiled `just-in-time <https://en.wikipedia.org/wiki/Just-in-time_compilation>`__ with `numba <https://numba.pydata.org/>`__. Such implementation alleviates the usual prerequisite for a Fortran compiler needed by other libraries also based on CPS (e.g., `pysurf96 <https://github.com/miili/pysurf96>`__, `srfpython <https://github.com/obsmax/srfpython>`__ and `PyLayeredModel <https://github.com/harrymd/PyLayeredModel>`__) which often leads to further installation troubleshooting, especially on Windows platform.
  **disba** aims to be lightweight and portable without compromising on the performance. For both Rayleigh-wave and Love-wave, it is significantly faster than CPS's *surf96* program compiled with `f2py <https://np.org/devdocs/f2py/index.html>`__, noticeably for large number of layers.
     *  - |Perf Rayleigh|
        - |Perf Love|


pkgId: f9ccb957950fca2cc0879123d519aec8d383865bc8b340f058ae982f840ab513
name: python-dischub-help
arch: noarch
version: 1.6
epoch: 0
release: 1
summary: Development documents and examples for dischub
url: https://github.com/stanleychihz/my_sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dischub-1.6-1.src.rpm
location_href: Packages/python-dischub-help-1.6-1.noarch.rpm
checksum_type: sha256
description:
  The Dischub SDK is a Python package designed to initiate online payment to Dischub API. It abstracts the API URL and simplifies the process of integrating the Dischub payment gateway or other services into Django applications.



  - Send dynamic JSON data to Dischub API
  - Abstracted API URL to enhance security
  - Easy integration with Django-based applications
  - Handles POST requests and JSON payloads efficiently
  - Error handling for API communication issues



  You can install the **Dischub SDK** via pip:

  ```bash
  pip install dischub


pkgId: 90ad13f12c52a06921155d25f243c47c08bf7cdb6c4d33f574f3c79666b0b6d1
name: python-discontinuum-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for discontinuum
url: https://pypi.org/project/discontinuum/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-discontinuum-0.5.1-1.src.rpm
location_href: Packages/python-discontinuum-help-0.5.1-1.noarch.rpm
checksum_type: sha256
description:
  the more flexible Weighted Regression on Time Discharge and Season (WRTDS),
  which allows the relation between target and covariate to vary through time.
  `loadest-gp` takes the WRTDS idea and reimplements it as a GP.
  Try it out in the [loadest-gp demo](https://github.com/thodson-usgs/discontinuum/blob/main/notebooks/loadest-gp-demo.ipynb).

  `rating-gp` is a Gaussian-process model for estimate river flow from stage time series.
  Try it out in the [rating-gp demo](https://github.com/thodson-usgs/discontinuum/blob/main/notebooks/rating-gp-demo.ipynb).

  Currently, the only supported engines are the marginal likelihood implementation in `pymc` and `gpytorch`.
  Latent GP implementations could be added in the future.
  In general, the `gpytorch` implementation is faster and provides a lot a powerful features,
  like GPU support, whereas `pymc` is a more complete probabilistic-programming framework,
  which can be "friendlier" for certain use cases.

  ```mermaid
  mindmap
    root((discontinuum))
      data providers
        USGS
        etc
      engines
        PyMC
        PyTorch
      utilities
        pre-processing
        post-processing
        plotting
      models
        loadest-gp
        rating-gp
  ```

rpm_license:
  License =======  Unless otherwise noted, this project is in the public domain in the United States because it contains materials that originally came from the United States Geological Survey, an agency of the United States Department of Interior. For more information, see the official USGS copyright policy at https://www.usgs.gov/information-policies-and-instructions/copyrights-and-credits  Additionally, we waive copyright and related rights in the work worldwide through the CC0 1.0 Universal public domain dedication.   CC0 1.0 Universal Summary -------------------------  This is a human-readable summary of the [Legal Code (read the full text)][1].   ### No Copyright  The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.  You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.   ### Other Information  In no way are the patent or trademark rights of any person affected by CC0, nor are the rights that other persons may have in the work or in how the work is used, such as publicity or privacy rights.  Unless expressly stated otherwise, the person who associated a work with this deed makes no warranties about the work, and disclaims liability for all uses of the work, to the fullest extent permitted by applicable law. When using or citing the work, you should not imply endorsement by the author or the affirmer.    [1]: https://creativecommons.org/publicdomain/zero/1.0/legalcode


pkgId: 8cd2cd43cf9cf79968fe0aa7b074334db7c57dcc11f0fdb3b0631bf0f26f9be0
name: python-discord-embeds-pagination-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for discord-embeds-pagination
url: https://github.com/omaxpy/discord-embeds-pagination
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-discord-embeds-pagination-0.0.7-1.src.rpm
location_href: Packages/python-discord-embeds-pagination-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  Python package to create pagination with embeds in discord.py bots.


  Import:
  ```python
  from pagination import Pagination
  ```

  Example use:
  ```python
  @bot.command()
  async def test_pagination(ctx):
      embeds = [
          discord.Embed(title="A", description="Desc", color=0x00ff00),
          discord.Embed(title="B", description="Desc", color=0x00ff00)
      ]
      pagination = Pagination(ctx, embeds)
      await pagination.init_messsage()
  ```

  ![screenshot](images/test_pagination.PNG)


pkgId: f09d0936ee5a126d2347be71fc4034c29cfefaa966e57ef8d09a20ae54a3e987
name: python-discord.py-tools-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for discord.py-tools
url: https://pypi.org/project/discord.py-tools/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-discord.py-tools-1.0.0-1.src.rpm
location_href: Packages/python-discord.py-tools-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Simple tools for discord.py
  Most of these tools are checks that may be useful on the development of bots, either prefixed
  commands or application commands.

  **Python 3.9 or higher is required.**
  Main package:
  ```shell
  pip install discord.py-tools
  ```
  Y(A)ML I18N Support:
  ```shell
  pip install discord.py-tools[yaml-i18n]
  ```
  Po, Mo, Pot I18N Support:
  ```shell
  pip install discord.py-tools[po-i18n]
  ```

  The documentation is available [here](https://discord-tools.readthedocs.io/en/).

  Contributions are welcome in this project! Only requirements is knowing what you write
  and that everything works!

rpm_license:
  The MIT License (MIT)  Copyright (c) 2024-present Developer Anonymous  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: ee444191f81116e606825bb9daa3586c45273ff82996cfeaaa8e07a61a799d5b
name: python-discotool-help
arch: noarch
version: 0.5.4
epoch: 0
release: 1
summary: Development documents and examples for discotool
url: https://github.com/Neradoc/discotool
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-discotool-0.5.4-1.src.rpm
location_href: Packages/python-discotool-help-0.5.4-1.noarch.rpm
checksum_type: sha256
description:
  Module and tool to discover all boards connected to USB.

  ![(Pimoroni Tiny2040, Arduino Nano 2040, Adafruit Huzzah ESP32)](https://raw.githubusercontent.com/Neradoc/discotool/main/docs/list_tiny_nano_esp32.png)


  The `discotool` command line program and the `discotool` python module for python 3 can be installed with pip.
  ```
  python3 -m pip install discotool
  ```


  It currently runs on MacOS, Linux and Windows. It should not require any installation outside of pip dependencies (no libusb, etc.). If it doesn't work for you, an issue with relevant OS information is welcome.



  When running `discotool` while using a single board, it will be automatically selected for commands. These are the commands I use the most:

  - **`discotool repl`**: to connect to the REPL.
  - **`discotool install ...`**: to install modules via circup.
  - **`discotool update`**: to update modules via circup.

  I often have more than one board connected, and connect to the REPL using `discotool -n pico` for example, or using the drive (mount) name to give each board a personnal name `discotool -m picotwo`.

  I also use a command to back up all connected boards.
  ```
  alias cpbackups='discotool backup --date ~/Backups/CPBackups'
  ```



  Define environment variables to override the default command line tools used by discotool. They are called by appending the relevant parameters at the end of the command, or replacing a placeholder.

  - **`DISCOTOOL_SERIALTOOL`**: command to connect to the REPL (tio, picocom, etc.), adds the port at the end or replaces `{port}` if present.
  	- on windows `{portnum}` is the `6` in `COM6`, required by TeraTerm.
  	- default values, using the first one found:
  		- **TeraTermPro**, **PuTTY** on Windows.
  		- **tio**, **screen** on linux/mac.
  - **`DISCOTOOL_CIRCUP`**: (`circup`) command to call circup (`pip install` it for the default).
  - **`DISCOTOOL_NOCOLOR`**: disables colors in the output if it evaluates to True.



  - **`--wait`**: runs the scan every second until it detects a board.
  - **`--nocolor`**: do not output colors in the terminal (overrides all else).
  - **`--color`**: output colors in the terminal (overrides all else).
  - **`--info`**: add more informations on Circuitpython boards by scanning the drive's content (might trigger the autoreload).



  - if no filter is given, run the `list` command.
  - if filters are given, run the `repl` command.


  Filters select boards from the list of devices found to run a command on them. They are combined with OR logic: anything that matches any filter is selected. All filters are NOT case sensitive. Filters are simple text matches, they don't support wildcards.

  - **`--auto`**: select the first board found.
  - **`--name`**: search in the USB name/description field. Eg: "clue", "QT", "S2".
  - **`--serial`**: search the serial number of the board.
  - **`--mount`**: search the volume names of the board. Eg: "CIRCUITPY".



  - **`list`**: lists the selected boards, with name, manufacturer, serial number. Lists the serial ports and file volumes. If the `--info` option was given, identifies circuitpython code files present, as well as CPY version. On windows the name of the drive is listed in addition to the drive letter.
  - **`repl`**: connect to the REPL of the selected boards using the tool specified, screen by default, choosing the first serial port found if there is more than one.
  - **`eject`**: eject all selected board drives, or all found if no filter given. (MacOS only for now)
  - **`backup <destination dir> [<sub dir>]`**: copy the content of the selected boards drives into the destination dir or the optional sub dir (that will be created for you). Each board is put in a directory with its name and serial number.
  	- **`--create`**: create the destination dir if it does not exist.
  	- **`--date`**: use a time stamp as subdirectory name, or add to the supplied name.
  - **`circup <options>`**: calls circup with its `--path` option to each selected board and passes all other options and commands to it.
  - **`get <key>`**: print just the value for the key, for the selected devices. Can be used with backticks and such in a shell script. Includes special keys:
  	- **`pid`**, **`vid`**, **`sn`**: shortcuts for product_id, vendor_id and serial_num.
  	- **`volume`**: path to the (first) mounted drive of the device.
  	- **`port`**: (first) serial port of the device.
  	- **`repl`**: (first) REPL serial port of the device.
  	- **`cdc`**: (first) non-REPL serial port of the device.
  	- **`main`** or **`code.py`**: full path to the main file for circuitpython.
  - **`json`**: print the output of usbinfo as json for all selected boards.
  	- **`--pretty`** **`-p`**: pretty print it for human reading.



  Exposes the `get_identified_devices(drive_info=False)` function. Find boards on the host's USB bus and tries to match them with serial ports and mounted drives, virtual or not. If `drive_info` is True, when a drive is found, it reads circuitpython information if available: CPY version number and main files in order of priority (code.py, etc.). This might trigger the board's autoreload.
  ```python
  import discotool
  devicesList = discotool.get_identified_devices(drive_info=True)
  ```
  Devices list (MacOS)
  ```python
  [{
  	'manufacturer': 'Adafruit Industries LLC',
  	'name': 'CLUE nRF52840 Express',
  	'ports': [{
  		"dev": "'/dev/cu.usbmodem144443111'",
  		"iface": "CircuitPython CDC data"
  	}],
  	'product_id': 32882,
  	'serial_num': 'F88EE0399C0E1FC6',
  	'vendor_id': 9114,
  	'version': '6.0.1',
  	'volumes': [{
  		'mains': ['code.py'],
  		'mount_point': '/Volumes/CIRCUITPY',
  		'name': 'CIRCUITPY'
  	}],
  	'usb_location': '0x14630000'
  }]
  ```



  - **`get_devices_list(drive_info=False)`**: return a tuple of the devices list and the list of remaining unidentified serial ports `(devicesList, remainingPorts)`.
  - **`get_identified_devices(drive_info=False)`**: only return the devices list.
  - **`get_unidentified_ports()`**: only return the unidentified serial ports.
  - **`devices_by_name(name)`**: only return the devices where the name contains the given string (not case sensitive).
  - **`devices_by_drive(drive_name)`**: only return the devices where the drive name (by default CIRCUITPY) is the given string.
  - **`devices_by_serial(serial_number)`**: only return the devices where the serial number is the given string (not case sensitive).


  The device list is actually a list of DeviceInfoDict, a subclass of dictionary that adds a few properties as shortcuts for paths in the dictionary, with a default value of `None`.

  Dictionary entries:
  - **`name`**: USB name of the board (str).
  - **`manufacturer`**: USB manufacturer of the board (str).
  - **`product_id`**: USB Product ID (int).
  - **`vendor_id`**: USB Vendor ID (int).
  - **`serial_num`**: USB Serial number of the board (str).
  - **`version`**: Circuitpython version, if found.
  - **`ports`**: list of serial ports found on the board, dictionaries.
  	- **`dev`**: port device, used to connect to the port. COM port on windows, dev path on linux (str).
  	- **`iface`**: interface name for the serial port (str).
  - **`volumes`**: list of mounted drives from the board, dictionaries.
  	- **`name`**: drive name, usually `CIRCUITPY` for Circuitpython or `*BOOT` for a UF2 bootloader drive (str).
  	- **`mount_point`**: mount path of the drive, letter on windows (str).
  	- **`mains`**: list of "main" files for Circuitpython (code.py etc.), by order of priority.
  - **`usb_location`**: an identifier for the USB port the board is connected to, should be consistent across reboots and modes (bootloader/application).

  Shortcuts:
  - **`repl`**: REPL port, if any.
  - **`data`**: data port, if any.
  - **`drive`** and **`volume`**: board drive path.
  - **`volume_name`**: board drive name.
  - **`vid`**: shortcut for `vendor_id`.
  - **`pid`**: shortcut for `product_id`.




  Using tio:
  `discotool -n clue`
  ![discotool repl](https://raw.githubusercontent.com/Neradoc/discotool/main/docs/repl_to_clue.png)

  `discotool -n clue circup update`
  ![discotool circup](https://raw.githubusercontent.com/Neradoc/discotool/main/docs/circup_update_clue.png)

  [Samples of what output you can expect from some boards.](https://github.com/Neradoc/discotool/blob/main/docs/examples.md)


pkgId: 1a655118de44e53686d47b9f0fb61166ef2f8869f405c34700728da2af3f67e8
name: python-dismo-help
arch: noarch
version: 1.0.56
epoch: 0
release: 1
summary: Development documents and examples for dismo
url: https://pypi.org/project/dismo/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dismo-1.0.56-1.src.rpm
location_href: Packages/python-dismo-help-1.0.56-1.noarch.rpm
checksum_type: sha256
description:
  [![pipeline status](https://gitlab.com/qtb-hhu/dismo/badges/main/pipeline.svg)](https://gitlab.com/qtb-hhu/dismo/-/commits/main)
  [![coverage report](https://gitlab.com/qtb-hhu/dismo/badges/main/coverage.svg)](https://gitlab.com/qtb-hhu/dismo/-/commits/main)
  [![Documentation](https://img.shields.io/badge/Documentation-Gitlab-success)](https://qtb-hhu.gitlab.io/dismo/)
  [![PyPi](https://img.shields.io/pypi/v/dismo)](https://pypi.org/project/dismo/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
  [![Downloads](https://pepy.tech/badge/dismo)](https://pepy.tech/project/dismo)

  dismo is a Python package for building and analysing discrete spatial models based on ordinary differential equations.
  Its primary purpose is to allow arbitrarily complex internal and transport processes to easily be mapped over multiple different regular grids.
  For this it features one, two and three-dimensional layouts, with standard and non-standard (e.g. hexagonal or triangular) grids.




  If you quickly want to test out dismo, or do not require assimulo support, install dismo via

  ```bash
  pip install dismo
  ```

  To enable assimulo support, the easiest way is to install it via mamba using the [mambaforge](https://github.com/conda-forge/miniforge#mambaforge) distribution

  ```bash
  mamba create -n py311 python=3.11 assimulo
  mamba activate py311
  pip install dismo
  ```



  [GPL 3](https://gitlab.com/qtb-hhu/dismo/blob/main/LICENSE)



  The official documentation is hosted [here on gitlab](https://qtb-hhu.gitlab.io/dismo/).



  If you experience issues using the software please contact us through our [issues](https://gitlab.com/qtb-hhu/dismo/issues) page.



  All contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome.
  See our [contribution guide](https://gitlab.com/qtb-hhu/dismo/blob/main/CONTRIBUTING.md) for more information.



  dismo is currently in the publication process. You will find citing information here as soon as possible.

  <!-- If you use this software in your scientific work, please cite [this article](https://rdcu.be/ckOSa):

  van Aalst, M., Ebenhöh, O. & Matuszyńska, A. Constructing and analysing dynamic models with dismo v1.2.3: a software update. BMC Bioinformatics 22, 203 (2021)

  - [doi](https://doi.org/10.1186/s12859-021-04122-7)
  - [bibtex file](https://gitlab.com/qtb-hhu/dismo/blob/main/citation.bibtex) -->


pkgId: 6dcb26933d6537756b3a4b9712a89dec32f0b1a282bc05331e317c1a56117e1f
name: python-distllm-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for distllm
url: https://pypi.org/project/distllm/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-distllm-1.0.1-1.src.rpm
location_href: Packages/python-distllm-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Distributed Inference for Large Language Models.
  - Create embeddings for large datasets at scale.
  - Generate text using language models at scale.
  - Semantic similarity search using Faiss.



  To install the package on Polaris@ALCF as of 12/12/2024, run the following command:
  ```bash
  git clone git@github.com:ramanathanlab/distllm.git
  cd distllm
  module use /soft/modulefiles; module load conda
  conda create -n distllm python=3.12 -y
  conda activate distllm-12-12
  pip install faiss-gpu-cu12
  pip install vllm
  pip install -e .
  python -m nltk.downloader punkt
  ```


  For ESMC, you can install the following package:
  ```bash
  pip install esm
  ```

  For ESM2, you can install the following package:
  ```bash
  pip install flash-attn --no-build-isolation
  pip install faesm[flash_attn]
  ```
  Or, if you want to forego flash attention and just use SDPA
  ```bash
  pip install faesm
  ```


  To create embeddings at scale, run the following command:
  ```bash
  nohup python -m distllm.distributed_embedding --config examples/your-config.yaml &> nohup.out &
  ```

  For LLM generation at scale, run the following command:
  ```bash
  nohup python -m distllm.distributed_generation --config examples/your-config.yaml &> nohup.out &
  ```

  To run smaller datasets on a single GPU, you can use the following command:
  ```bash
  distllm embed --encoder_name auto --pretrained_model_name_or_path pritamdeka/S-PubMedBert-MS-MARCO --data_path /lus/eagle/projects/FoundEpidem/braceal/projects/metric-rag/data/parsed_pdfs/LUCID.small.test/parsed_pdfs --data_extension jsonl --output_path cli_test_lucid --dataset_name jsonl_chunk --batch_size 512 --chunk_batch_size 512 --buffer_size 4 --pooler_name mean --embedder_name semantic_chunk --writer_name huggingface --quantization --eval_mode
  ```

  Or using a larger model on a single GPU, such as Salesforce/SFR-Embedding-Mistral:
  ```bash
  distllm embed --encoder_name auto --pretrained_model_name_or_path Salesforce/SFR-Embedding-Mistral --data_path /lus/eagle/projects/FoundEpidem/braceal/projects/metric-rag/data/parsed_pdfs/LUCID.small.test/parsed_pdfs --data_extension jsonl --output_path cli_test_lucid_sfr_mistral --dataset_name jsonl_chunk --batch_size 16 --chunk_batch_size 2 --buffer_size 4 --pooler_name last_token --embedder_name semantic_chunk --writer_name huggingface --quantization --eval_mode
  ```

  To merge the HF dataset files, you can use the following command:
  ```bash
  distllm merge --writer_name huggingface --dataset_dir /lus/eagle/projects/FoundEpidem/braceal/projects/metric-rag/data/semantic_chunks/lit_covid_part2.PubMedBERT/embeddings --output_dir lit_covid_part2.PubMedBERT.merge
  ```

  To generate text using a language model, you can use the following command:
  ```bash
  distllm generate --input_dir cli_test_lucid/ --output_dir cli_test_generate --top_p 0.95
  ```



  For development, it is recommended to use a virtual environment. The following commands will create a virtual environment, install the package in editable mode, and install the pre-commit hooks.
  ```bash
  python3.10 -m venv venv
  source venv/bin/activate
  pip install -U pip setuptools wheel
  pip install -e '.[dev,docs]'
  pre-commit install
  ```
  To test the code, run the following command:
  ```bash
  pre-commit run --all-files
  tox -e py310
  ```
  To release a new version of distllm to PyPI:

  1. Merge the develop branch into the main branch with an updated version number in pyproject.toml.
  2. Make a new release on GitHub with the tag and name equal to the version number.
  3. Clone a fresh distllm repository and run the installation commands above.
  4. Run the following commands from the main branch:
  ```bash
  rm -r dist
  python3 -m build
  twine upload dist/*
  ```


pkgId: 2186c32d77976914ae982c3fb50b2ae3536d3486b9a6c86c6da43afd353ca832
name: python-distman-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for distman
url: http://github.com/rsgalloway/distman
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-distman-0.3.2-1.src.rpm
location_href: Packages/python-distman-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  Distributes files and directories to versioned destinations defined in
  `dist.json` files.

  The easiest way to install:
  ```bash
  $ pip install -U distman
  ```
  Alternatively, use distman to dist to a deployment area using options defined
  in the `dist.json` and `distman.env` environment stack files:
  ```bash
  $ distman [-d]
  ```
  Files and directories can be distributed from any folder or git repo containing
  a `dist.json` file.

  `distman` looks for a dist file called `dist.json` at the root of a directory or
  git repo. The dist file defines the file distrubution instructions.
  The basic format of the `dist.json` file is:
  ```json
  {
      "author": "<email>",
      "targets": {
          "<target>": {
              "source": "<source-path>",
              "destination": "<target-path>"
          },
      }
  }
  ```
  where `<source-path>` is the relative path to the source file or directory,
  and `<target-path>` is the target destination path, and `<target>` is a named
  target label to use when running `distman` commands. You can define as many
  targets as you need.
  See the `dist.json` file in this repo for an example.
  Target paths can include environment variables, such as those defined in the
  `distman.env` envstack file, where variables are defined with curly brackets
  only, e.g.:
  ```bash
  "{DEPLOY_ROOT}/lib/python/distman"
  ```
  When files are distributed (or disted), they are copied to a `versions` folder
  and a symlink is created to the version. When a new version is disted, the
  version number is incremented and the link is updated.

  To dist files defined in a `dist.json` file (remove -d when ready):
  ```bash
  $ distman -d
  ```
  This will dist files to the `${DEPLOY_ROOT}` folder defined in the provided
  `distman.env` [envstack](https://github.com/rsgalloway/envstack) file and might
  look something like this when disted:
  ```
  ${DEPLOY_ROOT}
  ├── bin
  │   ├── distman -> versions/distman.0.c73fe42
  │   └── versions
  │       └── distman.0.c73fe42
  └── lib
      └── python
          ├── distman -> versions/distman.0.c73fe42
          └── versions
              └── distman.0.c73fe42
                  ├── cli.py
                  ├── config.py
                  ├── dist.py
                  ├── __init__.py
                  ├── logger.py
                  ├── source.py
                  └── util.py
  ```
  To override the deployment folder, update the `distman.env` environment stack
  file then re-dist:
  ```bash
  $ distman [-d]
  ```
  By default, `distman` dists to a prod folder under `${DEPLOY_ROOT}`. This can be
  changed at any time using `${ENV}` or updating or modifying the `distman.env`
  envstack file:
  ```bash
  $ ENV=dev distman [-d]
  ```
  This will change `prod` to `dev` in the target deplyment path. This is useful
  for deploying files or code to different development environments.

  When disting files, `distman` will create hidden dist info files that meta data
  about the source files. For example, if the source file is called `foobar.py`
  then the dist info file that will be created will be called `.foobar.py.dist`.
  The dist info files will be created at the deployment root.

  Most configuration is done in the `distman.env`
  [envstack](https://github.com/rsgalloway/envstack) file.
  Default config settings are in the config.py module. The following environment
  variables are supported:
  | Variable     | Description |
  |--------------|-------------|
  | $DEPLOY_ROOT | file deployment root directory |
  | $ENV         | target environment (e.g. prod or dev) |
  | $ROOT        | dist root directory |


pkgId: 0bf64130a60617e099239c6780f8aad84562ed9f25564cb0efb805925dd09876
name: python-distributed-help
arch: noarch
version: 2024.12.1
epoch: 0
release: 1
summary: Development documents and examples for distributed
url: https://distributed.dask.org
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-distributed-2024.12.1-1.src.rpm
location_href: Packages/python-distributed-help-2024.12.1-1.noarch.rpm
checksum_type: sha256
description:
  |Test Status| |Longitudinal Report (full)| |Longitudinal Report (short)| |Coverage| |Doc Status| |Discourse| |Version Status| |NumFOCUS|
  A library for distributed computation.  See documentation_ for more details.


pkgId: 90a32b07577e9fb77c11c08a3b88f6e82d1248b99917745a7b13ecf7c4d31605
name: python-dj-jwt-auth-help
arch: noarch
version: 1.8.0
epoch: 0
release: 1
summary: Development documents and examples for dj-jwt-auth
url: https://www.example.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dj-jwt-auth-1.8.0-1.src.rpm
location_href: Packages/python-dj-jwt-auth-help-1.8.0-1.noarch.rpm
checksum_type: sha256
description:
  This is a package to verify and validate JSON Web Tokens (JWT) in Django.


  1. Install the package using pip:
  ```bash
      pip install dj-jwt-auth
  ```

  2. Add "django_jwt" to your INSTALLED_APPS setting like this::
  ```
      INSTALLED_APPS = [
          ...
          "django_jwt",
      ]
  ```

  3. Add "django_jwt.middleware.JWTAuthMiddleware" to your MIDDLEWARE setting like this::
  ```
      MIDDLEWARE = [
          ...
          "django_jwt.middleware.JWTAuthMiddleware",
      ]
  ```


  Required variables:
  - OIDC_CONFIG_ROUTES - dict of "algorithm": "config_url". Required for using JWTAuthMiddleware. Example:
  ```
     OIDC_CONFIG_ROUTES = {
         "RS256": "https://keyCloak/realms/h/.well-known/openid-configuration",
         "HS256": "https://keyCloak/realms/h/.well-known/openid-configuration",
     }
  ```
  Optional variables:
  - OIDC_AUDIENCE - by default ["account", "broker"]

  User retated variables:
  - OIDC_USER_UPDATE - if True, user model will be updated from userinfo endpoint if MODIFIED date has changed, by default True
  - OIDC_USER_MODIFIED_FIELD - user model field to store last modified date, by default `modified_timestamp`
  - OIDC_TOKEN_MODIFIED_FIELD - access token field to store last modified date, by default `updated_at`
  - OIDC_USER_UID - User model" unique identifier, by default `kc_id`
  - OIDC_TOKEN_USER_UID - access token field to store user UID, by default `sub`
  - OIDC_USER_MAPPING - mapping between JWT claims and user model fields. Can be dict or function. By default:
  ```
      OIDC_USER_MAPPING = {
          "given_name": "first_name",
          "family_name": "last_name",
          "name": "username",
      }
  ```
  OR
  ```
      def OIDC_USER_MAPPING(userinfo):
          return {
              "first_name": userinfo.get("given_name"),
              "last_name": userinfo.get("family_name"),
              "username": userinfo.get("name"),
          }
  - OIDC_USER_DEFAULTS - default values for user model fields, by default:
  ```
      OIDC_USER_DEFAULTS = {
          "is_active": True,
      }
  ```

  - OIDC_USER_ON_CREATE and OIDC_USER_ON_UPDATE - functions to be called on user creation and update, by default:
  ```
      OIDC_USER_ON_CREATE = None
      OIDC_USER_ON_UPDATE = None
  ```
  These functions should accept two arguments: user and request.


  To integrate admin panel with OIDC, add OIDC_ADMIN_ISSUER and OIDC_ADMIN_CLIENT_ID to settings.
  - OIDC_ADMIN_ISSUER - for admin-panel access through OIDC. By default will be used 'ES256' from OIDC_CONFIG_ROUTES. Example:
  ```
      OIDC_ADMIN_ISSUER = "https://keyCloak/realms/h/.well-known/openid-configuration"
  ```
  - OIDC_ADMIN_CLIENT_ID - by default "complete-anatomy"
  To mapping roles to admin panel permissions, use OIDC_ADMIN_ROLES. Example:

  ```python

  from django_jwt.roles import ROLE

  OIDC_ADMIN_ROLES = [
      ROLE(
          name="admin",  # name from token
          is_superuser=True,
      ),
      ROLE(
          name="staff",
          groups=["LMS (Full)", "Organizations (Full)", "Customer Support (Full)"],
          permissions=["Can add user"],
      ),
  ]
  ```
  And add login view to urls.py:
  ```python
  urlpatterns = [
      path("admin/", include("django_jwt.urls")),
      ...
  ]
  ```
  Login URL will be available at `/admin/oidc/`.


  Run command `python runtests.py` to run tests.
  To run specific test use `python runtests.py <test_name>`, like `python runtests.py "tests.test.OIDCHandlerTest.test_new_email_exists"`.


pkgId: 9b8b70230128ed82d936949858ddba55680029b6d2e5da4ed3ac9f31ee4cdfc7
name: python-dj-jwt-auth-help
arch: noarch
version: 1.9.0
epoch: 0
release: 1
summary: Development documents and examples for dj-jwt-auth
url: https://www.example.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dj-jwt-auth-1.9.0-1.src.rpm
location_href: Packages/python-dj-jwt-auth-help-1.9.0-1.noarch.rpm
checksum_type: sha256
description:
  This is a package to verify and validate JSON Web Tokens (JWT) in Django.


  1. Install the package using pip:
  ```bash
      pip install dj-jwt-auth
  ```

  2. Add "django_jwt" to your INSTALLED_APPS setting like this::
  ```
      INSTALLED_APPS = [
          ...
          "django_jwt",
      ]
  ```

  3. Add "django_jwt.middleware.JWTAuthMiddleware" to your MIDDLEWARE setting like this::
  ```
      MIDDLEWARE = [
          ...
          "django_jwt.middleware.JWTAuthMiddleware",
      ]
  ```


  Required variables:
  - OIDC_CONFIG_ROUTES - dict of "algorithm": "config_url". Required for using JWTAuthMiddleware. Example:
  ```
     OIDC_CONFIG_ROUTES = {
         "RS256": "https://keyCloak/realms/h/.well-known/openid-configuration",
         "HS256": "https://keyCloak/realms/h/.well-known/openid-configuration",
     }
  ```
  Optional variables:
  - OIDC_AUDIENCE - by default ["account", "broker"]

  User retated variables:
  - OIDC_USER_UPDATE - if True, user model will be updated from userinfo endpoint if MODIFIED date has changed, by default True
  - OIDC_USER_MODIFIED_FIELD - user model field to store last modified date, by default `modified_timestamp`
  - OIDC_TOKEN_MODIFIED_FIELD - access token field to store last modified date, by default `updated_at`
  - OIDC_USER_UID - User model" unique identifier, by default `kc_id`
  - OIDC_TOKEN_USER_UID - access token field to store user UID, by default `sub`
  - OIDC_USER_MAPPING - mapping between JWT claims and user model fields. Can be dict or function. By default:
  ```
      OIDC_USER_MAPPING = {
          "given_name": "first_name",
          "family_name": "last_name",
          "name": "username",
      }
  ```
  OR
  ```
      def OIDC_USER_MAPPING(userinfo):
          return {
              "first_name": userinfo.get("given_name"),
              "last_name": userinfo.get("family_name"),
              "username": userinfo.get("name"),
          }
  - OIDC_USER_DEFAULTS - default values for user model fields, by default:
  ```
      OIDC_USER_DEFAULTS = {
          "is_active": True,
      }
  ```

  - OIDC_USER_ON_CREATE and OIDC_USER_ON_UPDATE - functions to be called on user creation and update, by default:
  ```
      OIDC_USER_ON_CREATE = None
      OIDC_USER_ON_UPDATE = None
  ```
  These functions should accept two arguments: user and request.


  To integrate admin panel with OIDC, add OIDC_ADMIN_ISSUER and OIDC_ADMIN_CLIENT_ID to settings.
  - OIDC_ADMIN_ISSUER - for admin-panel access through OIDC. By default will be used 'ES256' from OIDC_CONFIG_ROUTES. Example:
  ```
      OIDC_ADMIN_ISSUER = "https://keyCloak/realms/h/.well-known/openid-configuration"
  ```
  - OIDC_ADMIN_CLIENT_ID - by default "complete-anatomy"
  To mapping roles to admin panel permissions, use OIDC_ADMIN_ROLES. Example:

  ```python

  from django_jwt.roles import ROLE

  OIDC_ADMIN_ROLES = [
      ROLE(
          name="admin",  # name from token
          is_superuser=True,
      ),
      ROLE(
          name="staff",
          groups=["LMS (Full)", "Organizations (Full)", "Customer Support (Full)"],
          permissions=["Can add user"],
      ),
  ]
  ```
  And add login view to urls.py:
  ```python
  urlpatterns = [
      path("admin/", include("django_jwt.urls")),
      ...
  ]
  ```
  Login URL will be available at `/admin/oidc/`.


  Run command `python runtests.py` to run tests.


pkgId: f4313759cc1527a499b76bb0b5ae70ea57603f5dbf96eb6a794a147046b69bdc
name: python-django-admin-berry-help
arch: noarch
version: 1.0.13
epoch: 0
release: 1
summary: Development documents and examples for django-admin-berry
url: https://app-generator.dev/docs/products/django-libs/theme-berry.html
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-admin-berry-1.0.13-1.src.rpm
location_href: Packages/python-django-admin-berry-help-1.0.13-1.noarch.rpm
checksum_type: sha256
description:
  **[Django Berry](https://app-generator.dev/docs/products/django-libs/theme-berry.html)** - Modern Django Admin Interface provided by **[App-Generator](https://app-generator.dev)**


pkgId: 826f70e55fdc8d7d6adb4512859e7bedbf771a942f7e753648b20e7c91ca4ea5
name: python-django-admin-black-help
arch: noarch
version: 1.0.15
epoch: 0
release: 1
summary: Development documents and examples for django-admin-black
url: https://app-generator.dev/docs/products/django-libs/theme-black-dashboard.html
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-admin-black-1.0.15-1.src.rpm
location_href: Packages/python-django-admin-black-help-1.0.15-1.noarch.rpm
checksum_type: sha256
description:
  **[Django Black Dashboard](https://app-generator.dev/docs/products/django-libs/theme-black-dashboard.html)** - Modern Django Admin Interface provided by **[App-Generator](https://app-generator.dev)**


pkgId: 274dab031354ccd4aed651ef8cae277eb0d25bce2181c606227fbde15532eb19
name: python-django-admin-corporate-help
arch: noarch
version: 1.0.4
epoch: 0
release: 1
summary: Development documents and examples for django-admin-corporate
url: https://app-generator.dev/docs/products/django-libs/theme-corporate.html
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-admin-corporate-1.0.4-1.src.rpm
location_href: Packages/python-django-admin-corporate-help-1.0.4-1.noarch.rpm
checksum_type: sha256
description:
  **[Django Corporate](https://app-generator.dev/docs/products/django-libs/theme-corporate.html)** - Modern Django Admin Interface provided by **[App-Generator](https://app-generator.dev)**


pkgId: 2bdf8c9662fd75be34d6669fd30e498c1eeedb9cf2e16ab45cd8ee71cb0129fa
name: python-django-admin-datta-help
arch: noarch
version: 1.0.16
epoch: 0
release: 1
summary: Development documents and examples for django-admin-datta
url: https://app-generator.dev/docs/products/django-libs/theme-datta-able.html
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-admin-datta-1.0.16-1.src.rpm
location_href: Packages/python-django-admin-datta-help-1.0.16-1.noarch.rpm
checksum_type: sha256
description:
  **[Django Datta Able](https://app-generator.dev/docs/products/django-libs/theme-datta-able.html)** - Modern Django Admin Interface provided by **[App-Generator](https://app-generator.dev)**


pkgId: b407f97b0e0ba3d194de3adeae62dc47d794243491880a36f5a756857db90aa5
name: python-django-admin-soft-dashboard-help
arch: noarch
version: 1.0.24
epoch: 0
release: 1
summary: Development documents and examples for django-admin-soft-dashboard
url: https://app-generator.dev/product/soft-ui-dashboard/django/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-admin-soft-dashboard-1.0.24-1.src.rpm
location_href: Packages/python-django-admin-soft-dashboard-help-1.0.24-1.noarch.rpm
checksum_type: sha256
description:
  **[Django Soft Dashboard](https://app-generator.dev/docs/products/django-libs/theme-soft-dashboard.html)** - Modern Django Admin Interface provided by **[App-Generator](https://app-generator.dev)**


pkgId: cef09ddc66a0a7caf8a9bca2c66d65f5784129c4ae7caa8922bc57efd69ef871
name: python-django-admin-tabler-help
arch: noarch
version: 1.0.5
epoch: 0
release: 1
summary: Development documents and examples for django-admin-tabler
url: https://app-generator.dev/docs/products/django-libs/theme-tabler.html
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-admin-tabler-1.0.5-1.src.rpm
location_href: Packages/python-django-admin-tabler-help-1.0.5-1.noarch.rpm
checksum_type: sha256
description:
  **[Django Tabler](https://app-generator.dev/docs/products/django-libs/theme-tabler.html)** - Modern Django Admin Interface provided by **[App-Generator](https://app-generator.dev)**


pkgId: e238887ab86ac6d22f369850e50d3221ee8dea79acc8a7395f4c663b20e960af
name: python-django-aieditor-help
arch: noarch
version: 1.0.12
epoch: 0
release: 1
summary: Development documents and examples for django-aieditor
url: https://github.com/mircool/django-aieditor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-aieditor-1.0.12-1.src.rpm
location_href: Packages/python-django-aieditor-help-1.0.12-1.noarch.rpm
checksum_type: sha256
description:
  Django-AiEditor 是一个为 Django 框架提供的 AiEditor 富文本编辑器集成包。AiEditor 是一个强大的 Web 富文本编辑器。



  ```bash
  pip install django-aieditor
  ```



  1. 将 'django_aieditor' 添加到你的 INSTALLED_APPS 中：

  ```python
  INSTALLED_APPS = [
      ...
      'django_aieditor',
  ]
  ```

  2. 配置上传URL路由，在项目的urls.py中添加：

  ```python
  from django.urls import path, include

  urlpatterns = [
      ...
      path('aieditor/', include('django_aieditor.urls')),
  ]
  ```


  3. 在你的模型中使用：

  ```python
  from django_aieditor.fields import AiEditorModelField

  class MyModel(models.Model):
      content = AiEditorModelField("内容")
  ```

  4. 在你的表单中使用：

  ```python
  from django_aieditor.fields import AiEditorField

  class MyForm(forms.Form):
      content = AiEditorField()
  ```



  在你的 settings.py 中可以添加以下配置：

  ```python
  AIEDITOR_CONFIG = {
      'toolbar': ['bold', 'italic', 'link', 'image'], # 工具栏
  }
  ```
  更多配置请访问：[https://aieditor.dev/zh/](https://aieditor.dev/zh/)



  - 完整支持 AiEditor 的所有功能
  - 简单的 Django 集成
  - 支持文件上传（支持本地存储和云存储）
  - 支持自定义配置
  - Django Admin 集成



  aiEditor 文档请访问：[https://aieditor.dev/zh/](https://aieditor.dev/zh/)

  Django-AiEditor 文档请访问：[https://github.com/mircool/django-aieditor](https://github.com/mircool/django-aieditor)



  MIT License


pkgId: 780e1c45054d902c1123ea4a607060953826e00d21abdee00d1362a27e2587cf
name: python-django-ansible-base-help
arch: noarch
version: 2024.12.13
epoch: 0
release: 1
summary: Development documents and examples for django-ansible-base
url: https://pypi.org/project/django-ansible-base/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-ansible-base-2024.12.13-1.src.rpm
location_href: Packages/python-django-ansible-base-help-2024.12.13-1.noarch.rpm
checksum_type: sha256
description:
  Django-ansible-base is exactly what it says it is. A base for any Ansible application which will leverage Django.



  Docs for django-ansible-base features can be found in the [docs](docs) directory.

  Information about the test_app and how to start/use it can be found in [test_app/README.md](test_app/README.md)


pkgId: 1781c16bb1c3aabc3cc1c3720d10c7ea2d97be83c849644f1795ceb8095f42d8
name: python-django-autotask-help
arch: noarch
version: 1.6.14
epoch: 0
release: 1
summary: Development documents and examples for django-autotask
url: https://github.com/KerkhoffTechnologies/django-autotask
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-autotask-1.6.14-1.src.rpm
location_href: Packages/python-django-autotask-help-1.6.14-1.noarch.rpm
checksum_type: sha256
description:
  Django app for working with Autotask. Defines models (tickets,
  resources, accounts, etc.).



  -  Python 3.5
  -  Django 2.0

  Other versions may work; we haven't tried.



  From source:

      git clone git@github.com:KerkhoffTechnologies/django-autotask.git
      cd django-autotask
      python setup.py install



  1. Add to INSTALLED_APPS

      ```
      INSTALLED_APPS = [
          ...
          'djautotask',
          ...
      ]
      ```




  ```
  pip install --upgrade -r requirements_test.txt
  ```

  Try one of:

      ./runtests.py
      python setup.py test
      make test



  - Fork this repo
  - Make a branch
  - Make your improvements

      Making migrations? Run:

      ```
      ./makemigrations.py
      ```

  - Run the tests (see above)
  - Make a pull request



  MIT



  ©2018 Kerkhoff Technologies Inc.


pkgId: bea75ba049d58be22962c7abe5957c95846cf32704935595b4f9214fe0e0d8fe
name: python-django-azure-auth-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for django-azure-auth
url: https://github.com/Weird-Sheep-Labs/django-azure-auth
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-azure-auth-2.2.0-1.src.rpm
location_href: Packages/python-django-azure-auth-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Build](https://github.com/Weird-Sheep-Labs/django-azure-auth/actions/workflows/ci.yml/badge.svg)
  ![Coverage Status](./reports/coverage/coverage-badge.svg?dummy=8484744)
  [![PyPI downloads](https://img.shields.io/pypi/dm/django-azure-auth.svg)](https://pypistats.org/packages/django-azure-auth)





  by [Weird Sheep Labs](https://weirdsheeplabs.com)

  <a target="_blank" href="https://weirdsheeplabs.com"><img src="https://weirdsheeplabs.com/android-chrome-192x192.png" height="40" width="40" /></a>



  In March 2024, [Microsoft renamed Azure Active Directory (Azure AD) to Microsoft Entra ID](https://learn.microsoft.com/en-us/entra/fundamentals/new-name).



  `django-azure-auth` is a Django app which wraps the great [MSAL](https://github.com/AzureAD/microsoft-authentication-library-for-python)
  package to enable authentication against Microsoft's Azure Active Directory in Django projects.

  The app includes `login`, `logout` and `callback` authentication views, a decorator
  to protect individual views, and middleware which allows the entire site to require user
  authentication by default, with the ability to exempt specified views.

  This project is in no way affiliated with Microsoft.



  From PyPi:

  ```bash
  pip install django-azure-auth
  ```





  - Register an app at https://portal.azure.com/.
  - Add a client secret and note it down.
  - Add a redirect URI of the format `https://<domain>/azure_auth/callback`.



  Add the following to your `settings.py`, replacing the variables in braces with the values
  from your Azure app:

  ```python
  AZURE_AUTH = {
      "CLIENT_ID": "<client id>",
      "CLIENT_SECRET": "<client secret>",
      "REDIRECT_URI": "https://<domain>/azure_auth/callback",
      "SCOPES": ["User.Read"],
      "AUTHORITY": "https://login.microsoftonline.com/<tenant id>",   # Or https://login.microsoftonline.com/common if multi-tenant
      "LOGOUT_URI": "https://<domain>/logout",    # Optional
      "PUBLIC_URLS": ["<public:view_name>",],  # Optional, public views accessible by non-authenticated users
      "PUBLIC_PATHS": ['/go/',],  # Optional, public paths accessible by non-authenticated users
      "ROLES": {
          "95170e67-2bbf-4e3e-a4d7-e7e5829fe7a7": "GroupName1",
          "3dc6539e-0589-4663-b782-fef100d839aa": "GroupName2"
      },  # Optional, will add user to django group if user is in EntraID group
      "USERNAME_ATTRIBUTE": "mail",   # The AAD attribute or ID token claim you want to use as the value for the user model `USERNAME_FIELD`
      "GROUP_ATTRIBUTE": "roles",   # The AAD attribute or ID token claim you want to use as the value for the user's group memberships
      "EXTRA_FIELDS": [], # Optional, extra AAD user profile attributes you want to make available in the user mapping function
      "USER_MAPPING_FN": "azure_auth.tests.misc.user_mapping_fn", # Optional, path to the function used to map the AAD to Django attributes
      "GRAPH_USER_ENDPOINT": "https://graph.microsoft.com/v1.0/me", # Optional, URL to the Graph endpoint that returns user info
  }
  LOGIN_URL = "/azure_auth/login"
  LOGIN_REDIRECT_URL = "/"    # Or any other endpoint
  ```





  Make sure you configure the `settings.AZURE_AUTH["USERNAME_ATTRIBUTE"]` setting to the AAD attribute or ID token claim you want to use for the `USERNAME_FIELD` of your user model. Common choices are `mail`, `sub` or `oid`.

  > [!NOTE]
  > In version 1.x.x this was hardcoded to `mail`.



  Add the following to your `INSTALLED_APPS`:

  ```python
  INSTALLED_APPS = (
      "...",
      "azure_auth",
      "..."
  )
  ```



  Configure the authentication backend:

  ```python
  AUTHENTICATION_BACKENDS = ("azure_auth.backends.AzureBackend",)
  ```



  Include the app's URLs in your `urlpatterns`:

  ```python
  from django.urls import path, include

  urlpatterns = [
      path("azure_auth/", include("azure_auth.urls"),),
  ]
  ```





  To make user authentication a requirement for accessing an individual view, decorate the
  view like so:

  ```python
  from azure_auth.decorators import azure_auth_required
  from django.shortcuts import HttpResponse

  @azure_auth_required
  def protected_view(request):
      return HttpResponse("A view protected by the decorator")
  ```



  If you want to protect your entire site by default, you can use the middleware by adding the
  following to your `settings.py`:

  ```python
  MIDDLEWARE = [
      "...",
      "azure_auth.middleware.AzureMiddleware",
      "...",
  ]
  ```

  Make sure you add the middleware after Django's `session` and `authentication` middlewares so
  that the request includes the session and user objects. Public URLs which need to be accessed by
  non-authenticated users should be specified in the `settings.AZURE_AUTH["PUBLIC_URLS"]`, as
  shown above.



  A common use-case is to save attributes/claims from AAD on fields of the Django user model. Rather than providing a way to configure a 1-to-1 mapping, `django-azure-auth` allows you to define a function that takes in the AAD attributes/claims and transform/compose them into Django user model values, in a completely customizable way. As an example, suppose you have the following user model:

  ```python
  class User(AbstractUser):
      full_name = models.CharField()
  ```

  You want to populate the `full_name` field using the `givenName` and `surname` AAD user attributes i.e not a 1-to-1 mapping. You also want to mark the user as staff.

  You can do this by simply defining the below function and specifying the `settings.AZURE_AUTH["USER_MAPPING_FN"]` setting as the import path of the function:

  ```python


  def user_mapping_fn(**attributes):
      return {
          "full_name": attributes["givenName"] + attributes["surname"],
          "is_staff": True,
      }
  ```

  > [!NOTE]
  > In this example, the `USER_MAPPING_FN` setting would be specified as "main.utils.user_mapping_fn".

  The attributes passed to the mapping function will include:

  - The default user profile attributes https://learn.microsoft.com/en-us/entra/external-id/customers/concept-user-attributes
  - The ID token claims https://learn.microsoft.com/en-us/entra/identity-platform/id-token-claims-reference
  - Any extra user attributes specified in `settings.AZURE_AUTH["EXTRA_FIELDS"]

  > [!IMPORTANT]
  > The mapping function **must** return a dictionary whose keys are all valid attributes/fields of your user model, otherwise an AttributeError will be raised during authentication.



  Adding a group to the Azure Enterprise application will pass the group id down to the application via the `id_token`, provided that the user is part of the group.
  On how to configure this optional group claim in Azure see here: https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-fed-group-claims

  > [!NOTE]
  > Note that the default key will be `groups` though while the app expects this information under the `roles` key of the `id_token`. To make sure that the group information is fed down as a role claim, select the **Emit groups as role claims** checkbox, when configuring the group claims (https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-fed-group-claims#customize-group-claim-name). Alternatively, you can set `settings.AZURE_AUTH.GROUP_ATTRIBUTE = 'groups'` to use the default attribute


  Groups available in the token are synced with the corresponding django groups. Therfor the group id's from Azure need to be mapped in the
  settings with the Django groups by adding the following to `AZURE_AUTH` in `settings`.

  ```
  "ROLES": {
          "95170e67-2bbf-4e3e-a4d7-e7e5829fe7a7": "GroupName1",
          "3dc6539e-0589-4663-b782-fef100d839aa": "GroupName2"
      }
  ```

  If a user is assigned to one or more of this groups listed in the configuration, the user will be added
  automatically to the respective Django group. The group will be created if it does not exist.
  If a user is not part of a group (revoke permissions case), but is still in the Django group, the user
  will be removed from the Django group.



  During logout, if the ID token includes only the default claims, Active Directory will present the user with a page prompting them to select the account to log out. To disable this, simply enable the `login_hint` optional claim in your client application in Azure, as described in https://learn.microsoft.com/en-us/entra/identity-platform/v2-protocols-oidc#send-a-sign-out-request.



  This app is heavily inspired by and builds on functionality in
  https://github.com/shubhamdipt/django-microsoft-authentication, with both feature
  improvements and code assurance through testing.

  Credit also to:

  - https://github.com/Azure-Samples/ms-identity-python-webapp
  - https://github.com/AzMoo/django-okta-auth

  <div align="center">
      <a target="_blank" href="https://weirdsheeplabs.com"><img src="https://weirdsheeplabs.com/android-chrome-192x192.png" height="50" width="50" /></a>
  </div>


pkgId: 20c3a19ffc41384b76a8b3fa4177fc13468caf29e35e7eb39a7871fdf7ef7c9a
name: python-django-beam-help
arch: noarch
version: 1.7.0
epoch: 0
release: 1
summary: Development documents and examples for django-beam
url: https://github.com/django-beam/django-beam
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-beam-1.7.0-1.src.rpm
location_href: Packages/python-django-beam-help-1.7.0-1.noarch.rpm
checksum_type: sha256
description:
  django-beam provides you with a set of views, templates, and integrations for the most common CRUD applications. It aims to offer the functionality of Django's own admin but in a way that integrates seamlessly with your frontend code.



  - CRUD operations based on class-based views
  - Easily extensible
  - Extensions for common use cases and popular third-party packages



  The full documentation can be found at [https://django-beam.readthedocs.io/en/latest/](https://django-beam.readthedocs.io/en/latest/).



  To get started, you'll need to follow these steps:

  1. Install django-beam:

  ```bash
  pip install django-beam
  ```

  2. Add "beam" and "crispy_forms" to your `INSTALLED_APPS` in `settings.py`:

  ```python
  INSTALLED_APPS = [
      
      "beam",
      "beam.themes.bootstrap4",
      "crispy_forms",
  ]
  ```

  3. Import and use `beam` in your Django project, as shown in the example below:

  ```python

  from django.db import models

  class Book(models.Model):
      title = models.CharField(max_length=255)
      author = models.ForeignKey("Author", on_delete=models.CASCADE, related_name="books")


  class Author(models.Model):
      title = models.CharField(max_length=255)


  import beam

  class BookViewSet(beam.ViewSet):
      model = Book
      fields = ['title', 'author']

  class AuthorViewSet(beam.ViewSet):
      model = Author
      fields = ['title']


  from django.urls import path, include

  urlpatterns = [
      path('books/', include(BookViewSet().get_urls())),
      path('authors/', include(AuthorViewSet().get_urls())),
      
  ]
  ```

  For more examples and detailed explanations of various django-beam features, refer to the [full documentation](https://django-beam.readthedocs.io/en/latest/).



  The `beam.contrib` package provides integration with several third-party Django apps, such as:

  - `beam.contrib.auth`: Viewsets for editing users and groups, and optional templates for default Django registration views.
  - `beam.contrib.autocomplete_light`: Integration with `django-autocomplete-light`.
  - `beam.contrib.reversion`: Experimental integration with `django-reversion`.

  Refer to the documentation for usage instructions on each of the contrib packages.



  You can use the [tox](https://tox.readthedocs.io/en/latest/) testing tool to run the tests:

  ```bash
  tox -e py38-djangolatest
  ```

  Run the tests of a specific test file only:

  ```bash
  tox -e py38-djangolatest -- test_tags
  ```

  Run against all supported versions of Python and Django:

  ```bash
  tox
  ```



  If you encounter any issues or have questions, please refer to the [django-beam documentation](https://django-beam.readthedocs.io/en/latest/) or raise an issue on the [GitHub repository](https://github.com/yourgithubuser/django-beam/issues).


pkgId: f9924dc99546b2f19fce3ff10909c6b94383768941b52d3fc4a92de898d19fa6
name: python-django-better-azure-communication-email-help
arch: noarch
version: 0.0.0
epoch: 0
release: 1
summary: Development documents and examples for django-better-azure-communication-email
url: https://github.com/itm8-CDC/django-better-azure-communication-email
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-better-azure-communication-email-0.0.0-1.src.rpm
location_href: Packages/python-django-better-azure-communication-email-help-0.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/itm8-CDC/django-better-azure-communication-email/graph/badge.svg?token=L167GIRS20)](https://codecov.io/gh/itm8-CDC/django-better-azure-communication-email)


  This is a fork from: https://github.com/retech-us/django-azure-communication-email

  A Django email backend for Azure Communication Email service.


  Run the following on your system:

      pip install django-better-azure-communication-email

  Then, add these settings to your Django `settings.py`:

      EMAIL_BACKEND = 'django_better_azure_communication_email.EmailBackend'

      AZURE_COMMUNICATION_CONNECTION_STRING = '...'
      
      AZURE_KEY_CREDENTIAL = '...'
      AZURE_COMMUNICATION_ENDPOINT = '...'

  If you prefer to use Azure Active Directory authentication, you can use the
  following `settings.py` instead:

      EMAIL_BACKEND = 'django_better_azure_communication_email.EmailBackend'

      AZURE_COMMUNICATION_ENDPOINT = '...'

      
      

  Now, when you use `django.core.mail.send_mail`, Azure Communication Email
  service will send the messages by default.


pkgId: bedf93a8030cf8e59bc7a8059ef496a6183e647708451d48e3e9232268b68316
name: python-django-bird-colony-help
arch: noarch
version: 0.12.0
epoch: 0
release: 1
summary: Development documents and examples for django-bird-colony
url: https://github.com/melizalab/django-bird-colony
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-bird-colony-0.12.0-1.src.rpm
location_href: Packages/python-django-bird-colony-help-0.12.0-1.noarch.rpm
checksum_type: sha256
description:
  |ProjectStatus|_ |Version|_ |BuildStatus|_ |License|_ |PythonVersions|_
  bird-colony is a Django application the Meliza Lab uses to manage its zebra
  finch colony and keep breeding records. You may find it useful, even if you work
  with non-avian species.
  Features:
  * Animals have globally unique identifiers and can optionally have colored and numbered leg bands (one band per animal). This means they keep their identities even if you have to reband them.
  * Record events over the lifespan of each animal, from egg to grave. Events can be linked to locations, so you can find where an animal is, or was on a certain date. Events can also be linked to measurements like weight so you can track these over time or use them to make breeding decisions.
  * Track pairings, pedigrees, and breeding success statistics. You can export a complete pedigree for all living birds in the colony and compute relatedness using external software like the R `pedigree <https://www.rdocumentation.org/packages/pedigree/versions/1.4.2>`_ package.
  * Useful forms for entering data, including periodic nest checks. Easy to track when eggs are laid and hatch and associate them with the correct parents.
  * Associate biological samples with animals and track their physical location.
  You’ll need to have a basic understanding of how to use
  `Django <https://www.djangoproject.com/>`__. ``bird-colony`` is licensed
  for you to use under the BSD License. See COPYING for details
  Quick start
  ~~~~~~~~~~~
  1. Requires Python 3.10+. Runs on Django 4.2 LTS and 5.1.
  2. Install the package using pip: ``pip install django-bird-colony``.
  3. Add ``birds`` and some dependencies to your INSTALLED_APPS setting
     like this:
     INSTALLED_APPS = (
         'widget_tweaks',  # For form tweaking
         'rest_framework',
         'django_filters',
         'widget_tweaks',
         'fullurl',
         'birds',
     )
  2. Include birds in ``urlpatterns`` in your project ``urls.py``. Some of
     the views link to the admin interface, so make sure that is included,
     too:
         path("birds/", include("birds.urls")),
         path("admin/", admin.site.urls),
  3. Run ``python manage.py migrate`` to create the database tables. If
     this is a new django install, run
     ``python migrate.py createsuperuser`` to create your admin user.
  4. Run ``python manage.py loaddata bird_colony_starter_kit`` to create
     some useful initial records.
  5. Start the development server (``python manage.py runserver``) and
     visit http://127.0.0.1:8000/admin/birds/ to set up your colony, as
     described in the next section.
  6. Visit http://127.0.0.1:8000/birds/ to use views.
  Make sure to consult the Django documentation on deployment if you are
  at all concerned about security.
  Initial setup
  ~~~~~~~~~~~~~
  This is a work in progress. Before you start entering birds and events,
  you need to set up some tables using the Django admin app.
  Required steps:
  ^^^^^^^^^^^^^^^
  1. Edit species records in the ``Species`` table. The
     ``bird_colony_starter_kit`` fixture will create a record for zebra
     finches. The ``code`` field is used to give animals their names, so
     if you have zebra finches and use ``zebf`` as your code, your birds
     will be named ``zebf_red_1`` and so forth.
  2. Edit and add locations to the ``Locations`` table. You need to have
     at least one location created. The main use for this field is to
     allow you to find where a bird is by looking at the last event.
  3. Edit and create new event types in the ``Status codes`` table. Common
     event types include ``hatched``, ``added``, ``moved``, ``died``,
     ``used for anatomy``, etc. For each status code, indicate whether it
     adds or removes a bird from the colony. When you create an event that
     removes a bird, it will appear as no longer alive. The ``hatched``
     event is special, because if you add a bird to the database using the
     ``Add new bird`` view using this code, the system will require you to
     enter the bird’s parents. (If you don’t know the bird’s parents, you
     can always create it manually in the admin interface)
  Optional steps:
  ^^^^^^^^^^^^^^^
  1. If your bands are colored, add your colors to the ``Colors`` table.
     This will affect the short name for your animals.
  2. If you’re going to be adding samples to the databse, add or edit
     ``Sample locations`` and ``Sample types`` in the admin interface.
  3. Add additional users to the database. This is particularly useful if
     you want to allow specific users to reserve animals.
  4. If you want to change some of the boilerplate text on the entry
     forms, you’ll need to install the app from source. The templates are
     found under ``birds/templates/birds`` in the source directory.
  Development
  ~~~~~~~~~~~
  Recommend using `uv <https://docs.astral.sh/uv/>`__ for development.
  Run ``uv sync`` to create a virtual environment and install
  dependencies. ``uv sync --no-dev --frozen`` for deployment.
  Testing: ``uv run pytest``. Requires a test database, will use settings
  from ``inventory/test/settings.py``.
  Changelog
  ~~~~~~~~~
  In the 0.4.0 release, the primary key for animal records became the
  animal’s uuid. To migrate from previous version, data must be exported
  as JSON under the 0.3.999 release and then imported under 0.4.0


pkgId: 84f365f9c2606a6731094db9d8672ea164869b2fd148dab2f5808973a37a9e0e
name: python-django-cards-help
arch: noarch
version: 0.11.7
epoch: 0
release: 1
summary: Development documents and examples for django-cards
url: https://github.com/django-advance-utils/django-cards
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-cards-0.11.7-1.src.rpm
location_href: Packages/python-django-cards-help-0.11.7-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/django-cards.svg)](https://badge.fury.io/py/django-cards)



  Django Cards


pkgId: faadf19d044249af9f03c219df27be5fb714e8d95c38b6c626f0a857716f4b77
name: python-django-chunked-field-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for django-chunked-field
url: https://github.com/berkayeren/django-chunked-field
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-chunked-field-0.0.3-1.src.rpm
location_href: Packages/python-django-chunked-field-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  This project provides a custom Django field, `ChunkedTextField`, designed to handle large text data by splitting it into
  manageable chunks for storage in a separate database table. Unlike traditional text fields, which may face size
  limitations in certain database systems, `ChunkedTextField` bypasses these constraints while seamlessly integrating with
  Django's ORM. It works transparently with serializers, admin interfaces, and other ORM features, allowing developers to
  store and retrieve large text data without changing their application logic. The field is particularly useful in
  applications requiring efficient management of text data exceeding database limits, ensuring scalability and ease of
  use.



  - Store large text data exceeding database field size limits.
  - Seamlessly integrates with Django's admin and ORM.
  - Customizable truncation for admin display.



  1. Install the package using pip:
      ```sh
      pip install django-chunked-field
      ```

  2. Add `chunked_field` to your `INSTALLED_APPS` in your Django settings:
      ```python
      INSTALLED_APPS = [
          ...
          'chunked_field',
      ]
      ```

  3. Run the migrations to create the necessary database tables:
      ```sh
      python manage.py migrate
      ```





  To use the `ChunkedTextField`, define it in your model as follows:

  ```python
  from django.db import models
  from chunked_field.fields import ChunkedTextField


  class MyModel(models.Model):
     large_text = ChunkedTextField(truncate_length=100, chunk_size=4000)
  ```



  To display the `DataChunk` model in the Django admin, register it in `admin.py`:

  ```python
  from django.contrib import admin
  from chunked_field.models import DataChunk


  @admin.register(DataChunk)
  class DataChunkAdmin(admin.ModelAdmin):
     list_display = ('content_type', 'object_id', 'field_name', 'sequence')
     list_filter = ('content_type', 'field_name')
     search_fields = ('content',)
  ```



  The `ChunkedTextField` automatically handles the chunking and reassembly of data using Django signals. You do not need
  to manually manage these operations.



  This project is licensed under the MIT License.

  ```

  This update includes installation instructions, usage examples, and admin integration details.


pkgId: db60587626a0d8ea8831bc7df62a6aeef98e61d4fa0587bb1b6bfbcf302c8479
name: python-django-cli-no-admin-help
arch: noarch
version: 2024.12.2
epoch: 0
release: 1
summary: Development documents and examples for django-cli-no-admin
url: https://pypi.org/project/django-cli-no-admin/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-cli-no-admin-2024.12.2-1.src.rpm
location_href: Packages/python-django-cli-no-admin-help-2024.12.2-1.noarch.rpm
checksum_type: sha256
description:
  > Use the Django CLI using "django" without typing "django-admin".

  django-cli-no-admin is a lightweight tool that simplifies working with Django projects. With this package, you can use the `django` command instead of `django-admin` for executing management commands in your Django project.



  You can install django-cli-no-admin using pip:

  ```shell
  pip install django-cli-no-admin
  ```

  Or, if you prefer uv:

  ```shell
  uv pip install django-cli-no-admin
  ```



  Once installed, you can use `django` from the command line in place of `django-admin`:

  ```shell
  django startproject myproject
  ```

  Or any other Django management command:

  ```shell
  django runserver
  ```



  There are no additional dependencies or configurations needed. Simply install the package, and you're ready to go.



  django-cli-no-admin is licensed under the BSD License. See the LICENSE.txt file for details.


pkgId: 9417be3d5003c2b64cd969c4d52fc5162436ff6d1b7aadfc5a72ac88f3803936
name: python-django-components-help
arch: noarch
version: 0.119
epoch: 0
release: 1
summary: Development documents and examples for django-components
url: https://github.com/EmilStenstrom/django-components/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-components-0.119-1.src.rpm
location_href: Packages/python-django-components-help-0.119-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/django-components)](https://pypi.org/project/django-components/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/django-components)](https://pypi.org/project/django-components/) [![PyPI - License](https://img.shields.io/pypi/l/django-components)](https://github.com/EmilStenstrom/django-components/blob/master/LICENSE/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/django-components)](https://pypistats.org/packages/django-components) [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/EmilStenstrom/django-components/tests.yml)](https://github.com/EmilStenstrom/django-components/actions/workflows/tests.yml)

  [**Docs (Work in progress)**](https://EmilStenstrom.github.io/django-components/latest/)

  Django-components is a package that introduces component-based architecture to Django's server-side rendering. It aims to combine Django's templating system with the modularity seen in modern frontend frameworks.



  1. 🧩 **Reusability:** Allows creation of self-contained, reusable UI elements.
  2. 📦 **Encapsulation:** Each component can include its own HTML, CSS, and JavaScript.
  3. 🚀 **Server-side rendering:** Components render on the server, improving initial load times and SEO.
  4. 🐍 **Django integration:** Works within the Django ecosystem, using familiar concepts like template tags.
  5. ⚡ **Asynchronous loading:** Components can render independently opening up for integration with JS frameworks like HTMX or AlpineJS.

  Potential benefits:

  - 🔄 Reduced code duplication
  - 🛠️ Improved maintainability through modular design
  - 🧠 Easier management of complex UIs
  - 🤝 Enhanced collaboration between frontend and backend developers

  Django-components can be particularly useful for larger Django projects that require a more structured approach to UI development, without necessitating a shift to a separate frontend framework.



  django-components lets you create reusable blocks of code needed to generate the front end code you need for a modern app.

  Define a component in `components/calendar/calendar.py` like this:
  ```python
  @register("calendar")
  class Calendar(Component):
      template_name = "template.html"

      def get_context_data(self, date):
          return {"date": date}
  ```

  With this `template.html` file:

  ```htmldjango
  <div class="calendar-component">Today's date is <span>{{ date }}</span></div>
  ```

  Use the component like this:

  ```htmldjango
  {% component "calendar" date="2024-11-06" %}{% endcomponent %}
  ```

  And this is what gets rendered:

  ```html
  <div class="calendar-component">Today's date is <span>2024-11-06</span></div>
  ```

  Read on to learn about all the exciting details and configuration possibilities!

  (If you instead prefer to jump right into the code, [check out the example project](https://github.com/EmilStenstrom/django-components/tree/master/sampleproject))



  Read the [Release Notes](https://github.com/EmilStenstrom/django-components/tree/master/CHANGELOG.md)
  to see the latest features and fixes.



  One of our goals with `django-components` is to make it easy to share components between projects. If you have a set of components that you think would be useful to others, please open a pull request to add them to the list below.

  - [django-htmx-components](https://github.com/iwanalabs/django-htmx-components): A set of components for use with [htmx](https://htmx.org/). Try out the [live demo](https://dhc.iwanalabs.com/).



  Get involved or sponsor this project - [See here](https://emilstenstrom.github.io/django-components/dev/overview/contributing/)

  Running django-components locally for development - [See here](https://emilstenstrom.github.io/django-components/dev/overview/development/)


pkgId: 638da154615fb35617ed7ab325b859de92550c5d47d95f67b33518b56199ad00
name: python-django-dramatiq-result-backend-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for django-dramatiq-result-backend
url: https://github.com/Shrest4647/django-dramatiq-result-backend
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-dramatiq-result-backend-0.1.3-1.src.rpm
location_href: Packages/python-django-dramatiq-result-backend-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  A Django-based ResultBackend for [Dramatiq](https://dramatiq.io/).



  - Store and retrieve task results using Django's ORM.
  - Automatically handle result expiration.



  ```bash
  pip install django-dramatiq-result-backend
  ```





  Add `django_dramatiq_result_backend` to your `INSTALLED_APPS` in `settings.py`.



  ```python


  DRAMATIQ_RESULT_BACKEND = {
      "BACKEND": "django_dramatiq_result_backend.backends.DjangoDramatiqResultBackend",
      "OPTIONS": {
          "model": "django_dramatiq_result_backend.Result",
          "expiration": 30 * 60 * 60 * 24,  # 30 days
      },
  }

  ```



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


pkgId: b06335a77909b4503107a494f2ab35e9b4ea0294de711b3ff99215601579c81c
name: python-django-drf-blog-api-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for django-drf-blog-api
url: https://github.com/osiota10/blog_DRF_api
rpm_license: BSD-3-Clause # Example license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-drf-blog-api-0.0.3-1.src.rpm
location_href: Packages/python-django-drf-blog-api-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  django-drf-blog-api is a Django blog API app






  1. Add "Blog" to your INSTALLED_APPS setting like this::

      INSTALLED_APPS = [
          ...,
          "django-drf-blog-api",
      ]
  ```
  2. Include the polls URLconf in your project urls.py like this::

      path("blog/", include("django-drf-blog-api.urls")),

  3. Run ``python manage.py migrate`` to create the models.

  4. Start the development server and visit the admin to create a poll.

  5. Visit the ``/blog/`` URL to participate in the poll.


pkgId: 6c4d3ced722f32aebeba5c76c4011e3dff443c6bb8d0113f0e16da67dbb63520
name: python-django-dsfr-help
arch: noarch
version: 1.4.5
epoch: 0
release: 1
summary: Development documents and examples for django-dsfr
url: https://github.com/numerique-gouv/django-dsfr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-dsfr-1.4.5-1.src.rpm
location_href: Packages/python-django-dsfr-help-1.4.5-1.noarch.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/github/v/release/numerique-gouv/django-dsfr.svg)](https://github.com/numerique-gouv/django-dsfr/releases/)

  [![image](https://badge.fury.io/py/django-dsfr.svg)](https://pypi.org/project/django-dsfr/)

  [![image](https://github.com/numerique-gouv/django-dsfr/actions/workflows/ci-3-8.yml/badge.svg)](https://github.com/numerique-gouv/django-dsfr/actions/workflows/ci-3-8.yml)

  [![image](https://github.com/numerique-gouv/django-dsfr/actions/workflows/ci-3-10.yml/badge.svg)](https://github.com/numerique-gouv/django-dsfr/actions/workflows/ci-3-10.yml)

  [![image](https://github.com/numerique-gouv/django-dsfr/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/numerique-gouv/django-dsfr/actions/workflows/codeql-analysis.yml)

  [![Security Status](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)



  Django-DSFR is a Django app to integrate the [French government Design System ("Système de design de l’État français")](https://www.systeme-de-design.gouv.fr/).



  See the [documentation (in French)](https://numerique-gouv.github.io/django-dsfr/) for details.

  Django-DSFR implements the [version 1.12.1 of the DSFR](https://www.systeme-de-design.gouv.fr/a-propos/versions/version-courante)
  (see also the [Github releases page](https://github.com/GouvernementFR/dsfr/releases/))



  Tested with Python 3.8 to 3.12 and Django 3.2 to 5.0. Per [vermin](https://github.com/netromdk/vermin), it should work with Python >= 3.6, and it should work with old versions of Django too.

  Note: Only supported versions of Django and Python are supported by this project. You can check the supported versions and their end of life on the following pages:

  -   [Python](https://devguide.python.org/versions/)
  -   [Django](https://www.djangoproject.com/download/#supported-versions)

  ⚠️ Warning: Support for Django < 4.0 and Python < 3.10 will be removed at the end of 2024.



  See the [INSTALL.md](INSTALL.md) file.



  This app was originally created as a part of [Open
  Collectivités](https://github.com/entrepreneur-interet-general/opencollectivites)
  in 2020, and then maintained as part of
  [Aides-territoires](https://github.com/MTES-MCT/aides-territoires) in
  2022-2023.

  It is now maintained as part of
  [\@numerique-gouv](https://github.com/numerique-gouv) alongside the
  Wagtail-based [Sites
  faciles](https://github.com/numerique-gouv/sites-faciles).



  Le contenu de ce projet est placé sous licence MIT, à l’exception de la
  fonte Marianne. Voir [la licence du
  DSFR](https://github.com/GouvernementFR/dsfr/blob/main/doc/legal/cgu.md).



  > Il est formellement interdit à tout autre acteur d’utiliser le Système de Design de l’État (les administrations territoriales ou tout autre acteur privé) pour des sites web ou des applications. Le Système de Design de l’État représente l’identité numérique de l’État. En cas d’usage à des fins trompeuses ou frauduleuses, l’État se réserve le droit d’entreprendre les actions nécessaires pour y mettre un terme.
  >
  > Voir les [conditions générales d’utilisation](https://github.com/GouvernementFR/dsfr/blob/main/doc/legal/cgu.md).



  > This Design System is only meant to be used by official French public
  > services\' websites and apps. Its main purpose is to make it easy to
  > identify governmental websites for citizens. See terms.


pkgId: 15af93af0910027f814952c5b8adace1354f377095532a9c568b4926894b96d4
name: python-django-envconfig-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for django-envconfig
url: https://pypi.org/project/django-envconfig/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-envconfig-0.4.0-1.src.rpm
location_href: Packages/python-django-envconfig-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Test](https://github.com/ely-as/django-envconfig/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/ely-as/django-envconfig/actions/workflows/test.yml)
  [![Coverage](https://cov.ely.as/github/ely-as/django-envconfig/main/badge.svg)](https://cov.ely.as/github/ely-as/django-envconfig/main/latest/)
  [![Version](https://img.shields.io/pypi/v/django-envconfig)](https://pypi.org/project/django-envconfig/)

  ![Django](https://img.shields.io/pypi/djversions/django-envconfig)
  ![Python](https://img.shields.io/pypi/pyversions/django-envconfig)

  Configure Django using environment variables (envvars). `settings.py` optional.




  ```sh
  python -m pip install django-envconfig
  ```


  Edit the `manage.py`, `asgi.py` and `wsgi.py` files generated by Django's
  `startproject` command and modify the following line:
  ```py
  os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'envconfig.settings')
  ```


  The following envvars are required (if `settings.py` is removed):
  - `ALLOWED_HOSTS` (unless you set `DEBUG=on`)

  Environments may be stored in an `.env` file. This file can be stored in your
  root directory (next to `manage.py`) or anywhere on the path (e.g. virtualenv
  directory).



  Any [Django setting](https://docs.djangoproject.com/en/3.2/ref/settings/) can
  be configured as an environment variable.
  - To set booleans: `true|yes|on|1` and `false|no|off|0` (case-insensitive)
  - To set `None`: `none|null` (case-insensitive)
  - Simple lists of strings can be stored comma-separated e.g. `export ALLOWED_HOSTS=127.0.0.1,localhost`
  - Dicts and complex lists should be stored as JSON

  Settings are loaded with the following priority (highest first):
  1. Environment variables.
  2. Settings defined in your projects `settings.py`, if it exists. Note: any
     custom settings should be defined here with their default value.
  3. Settings that *would* be defined by a `settings.py` file generated by
     `startproject`. This should eliminate the need for the file in (2) for most
     projects. Caveats:
     - The default value for `DEBUG` has been changed to `False`.
     - A `SECRET_KEY` is generated but will not persist between sessions (e.g.
       if you restart your server/process manager). Check the
       [Django documentation](https://docs.djangoproject.com/en/dev/ref/settings/#secret-key)
       to see whether you need to set a persistent `SECRET_KEY` as an
       environment variable.



  Helper environment variables to use with django-envconfig:

  | Environment variable | Description |
  | --- | --- |
  | `DJANGO_PROJECT` | May be required if django-envconfig cannot find your project. Set to the name of the module originally generated by `startproject` |
  | `ADD_INSTALLED_APPS` | Add to [`INSTALLED_APPS`](https://docs.djangoproject.com/en/dev/ref/settings/#installed-apps) |
  | `REMOVE_INSTALLED_APPS` | Remove from [`INSTALLED_APPS`](https://docs.djangoproject.com/en/dev/ref/settings/#installed-apps) |
  | `ADD_MIDDLEWARE` | Add to [`MIDDLEWARE`](https://docs.djangoproject.com/en/dev/topics/http/middleware/#activating-middleware) |
  | `REMOVE_MIDDLEWARE` | Remove from [`MIDDLEWARE`](https://docs.djangoproject.com/en/dev/topics/http/middleware/#activating-middleware) |



  If you are using a PostgreSQL backend you do not need to set `DATABASES`. You
  can simply set PostgreSQL environment variables - the minimum is `PGDATABASE`.
  See the
  [PostgreSQL docs](https://www.postgresql.org/docs/current/libpq-envars.html)
  for the full list of envvars. This way the same environment can be used when
  calling
  [PostgreSQL command line utilities](https://www.postgresql.org/docs/current/reference-client.html)
  such as `psql` or `pg_dump`.



  - To separate configuration from code. See
    [The Twelve Factor App](https://12factor.net/).
  - Use serverless services such as AWS Lambda and Heroku.
  - Avoid having to template settings files and keep the auto-generated
    `settings.py` up to date between Django versions.
  - Use .env files for easy switching between environments/deployments
    (e.g. dev, test and prod).



  - [python-dotenv](https://github.com/theskumar/python-dotenv) (BSD 3-clause license)



  [MIT](https://github.com/ely-as/django-envconfig/blob/main/LICENSE).


pkgId: 92eddf9a8e3902070e486e9d1569266c7a67af9ee916a0ff97e248771590d105
name: python-django-filehub-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for django-filehub
url: https://pypi.org/project/django-filehub/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-filehub-0.1.8-1.src.rpm
location_href: Packages/python-django-filehub-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  `django_filehub` is a Django-based file management app that simplifies file handling within your Django projects. It supports file uploads, storage, and retrieval, making it easy to integrate robust file management features into your applications.



  - **File Uploads**: Seamlessly handle file uploads in your Django project.
  - **File Storage**: Organize and store files with customizable configurations.
  - **File Retrieval**: Efficiently access and manage uploaded files.
  - **File Categories**: Automatically categorize files based on type.
  - **Sorting Options**: Flexible sorting by name, size, or date, with ascending/descending order.
  - **Custom Fields**: Use `ImagePickerField` and `ImagePickerWidget` for advanced image selection in forms.



  Install `django_filehub` using `pip`:

  ```bash
  pip install django_filehub
  ```



  ```bash
  python manage.py makemigrations
  python manage.py migrate
  ```



  Add the following settings to your Django project's `settings.py`:
  ```python

  FILEHUB_LOGIN_URL = "/login/"


  MEDIA_ROOT = "path/to/media"  # Set your media root directory
  MEDIA_URL = "/media/"  # Define your media URL


  FILE_TYPE_CATEGORIES = {
      'images': ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'tiff', 'webp'],
      'videos': ['mp4', 'webm', 'ogg', 'avi', 'mkv', 'mov', 'wmv', '3gp', 'mpeg', 'mpg4'],
      'musics': ['mp3', 'wav', 'flac', 'aac', 'wma', 'm4a'],
      'archives': ['zip', 'rar', 'tar', 'gz']
  }
  ```


  Django Filehub also supports the following custom field and widget for advanced image selection:


  A custom Django model field for storing image file paths as text.

  ```python
  from django_filehub.fields import ImagePickerField

  class ExampleModel(models.Model):
      image = ImagePickerField()
  ```


  A custom Django form widget for selecting images from a file picker.

  ```python
  from django_filehub.widgets import ImagePickerWidget
  from django import forms

  class ExampleForm(forms.Form):
      image = forms.CharField(widget=ImagePickerWidget())
  ```


   - Install and configure the app as described above.
   - Add the necessary `MEDIA_ROOT` and `MEDIA_URL` in your settings.
   - Use `ImagePickerField` and `ImagePickerWidget` in your models and forms for advanced file selection capabilities.


  Contributions are welcome! If you'd like to report issues, suggest new features, or contribute to the development, please submit a pull request or open an issue.


pkgId: a2f8d47746bfbc81695a8d87845cd8461a5138225557181a659728d340701a39
name: python-django-firebase-auth-help
arch: noarch
version: 1.2.3
epoch: 0
release: 1
summary: Development documents and examples for django-firebase-auth
url: https://github.com/maycuatroi/django-firebase-auth
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-firebase-auth-1.2.3-1.src.rpm
location_href: Packages/python-django-firebase-auth-help-1.2.3-1.noarch.rpm
checksum_type: sha256
description:
  Project provide Django authentication middle ware using Firebase Authentication Service



  * [Django](https://www.djangoproject.com/)
  * [Firebase Authentication Service](https://firebase.google.com/docs/auth/web/start)



  ```bash
  pip install django-firebase-auth
  ```

  [Generate Firebase Credentials](#generate-firebase-credentials-file)







  - Credentials from file

  ```python
  FIREBASE_CREDENTIALS_FILE = '<YOUR FIREBASE CREDENTIALS PATH>'  # 'firebase-credentials.json'
  ```

  - or using credentials from json dict (where you can use as environment variables )

  <details>
  <summary>Using credentials from json dict</summary>

  ```python
  FIREBASE_CREDENTIALS_DICT = {
      "type": "service_account",
      "project_id": "<YOUR PROJECT ID>",
      "private_key_id": "<YOUR PRIVATE KEY ID>",
      "private_key": '<YOUR PRIVATE KEY>',
      "client_email": "<CLIENT EMAIL>",
      "client_id": "<CLIENT ID>",
      "auth_uri": "https://accounts.google.com/o/oauth2/auth",
      "token_uri": "https://oauth2.googleapis.com/token",
      "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
      "client_x509_cert_url": "<CERT URL>"
  }
  ```

  </details>



  ```python

  INSTALLED_APPS = [
      "...",
      "django_firebase_auth",
  ]
  ```



  ```python
  REST_FRAMEWORK = {
      "DEFAULT_AUTHENTICATION_CLASSES": (
          "django_firebase_auth.firebase_auth.FirebaseAuthentication",
      ),
  }
  ```



  To generate a private key file for your service account:

  1. In the Firebase console, open
     Settings > [Service Accounts](https://console.firebase.google.com/project/_/settings/serviceaccounts/adminsdk).
  2. Click Generate New Private Key, then confirm by clicking Generate Key.
  3. Securely store the JSON file containing the key.

  Add Firebase credentials to settings.py

  Generate Firebase credentials from Firebase console
  ![img.png](docs/img.png)



  - [x] Support supabase
  - [ ] Optimize session management


pkgId: c56cacbc1a92237ef1e68bce1fbcd5ff641eb9267aafb32638b02f8c2f5b3573
name: python-django-forms-frontend-validation-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for django-forms-frontend-validation
url: https://github.com/andrew-kyle92/django-forms-frontend-validation
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-forms-frontend-validation-1.0.1-1.src.rpm
location_href: Packages/python-django-forms-frontend-validation-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ___

  This project provides a comprehensive system for handling and validating HTML forms in Django applications. It combines client-side JavaScript-based validation and server-side Python logic for robust form processing.

  The application is designed to streamline the process of form validation, ensuring user inputs meet the requirements before submitting them to the server. The system offers features like automatic required-field validation, error handling, and dynamic CSRF token management for secure data transmission.


  - Client-Side Validation:
    - Automatically validates required fields.
    - Displays validation errors inline and dynamically updates them upon correction.
    - Adds asterisks to labels of required fields for better user clarity.
  - Server-Side Settings:
    - Control which forms and fields to ignore during validation.
    - Define validation behavior, such as enforcing checks only on form submission.
  - Integration with Django Settings:
    - Use Django's settings to dynamically configure validation rules.
  - Secure Fetch Calls:
    - Includes CSRF token management for secure AJAX-based form submissions.



  1. Include Required Components:
     - Include the JavaScript files in your project to enable client-side functionality.
     - Ensure `form_utils.py` is imported and accessible in your Django app.
  2. Define Settings in settings.py
     - Add `formvalidator` to installed apps.
        ```python
        INSTALLED_APPS = [
          ...,
          'formvalidator',
        ]
        ```
     - Configure the following variables to customize the behavior.
        ```python
        IGNORED_CLASSES = ['example-class', 'example-class-2', ...]
        IGNORE_VALIDATION = ['example-ignore-validation', ...]
        VALIDATE_ONLY_ON_SUBMIT = ['all']  # Options: "__all__", specific class names, or leave empty.
        ```
  3. Initial Forms:
     - Ensure the `_InitializeForms` method is called during page load to attach validation logic to forms dynamically.
     To your HTML template with the form, add this.
     ```html
     <script src="{% static 'dist/forms.bundle.js' %}"></script>
     <script>
      // fv (formsvalidator) is exported from forms.bundle.js
      window.addEventListener("load", () => {
          let ignoredClasses = {{ form_validator.ignored_classes|safe }}; // add more classes that represent forms you want this script to ignore.
          let ignoreValidation = {{ form_validator.ignore_validation|safe }}; // add any form classes that you want to ignore validation
          let validateOnlyOnSubmit = {{ form_validator.validate_only_on_submit|safe }}; // for hitting all forms make index 0 either __all__, all, * or leave blank for false or use false
          let forms = document.getElementsByTagName("form");
          // if (form || userForm) {
          if (forms.length > 0) {
              // calling specific functions on all forms
              fv._InitializeForms(forms, ignoredClasses, ignoreValidation, validateOnlyOnSubmit);
          }
      });
     </script>
     ```
  4. Server-Side Context:
     - Use the `FormsValidator` class to pass configuration to templates:
     ```python
      from formvalidator.form_utils import FormsValidator


      def my_view(request):
          form_validator = FormsValidator()
          context = {
              'form_validator': form_validator.get_context(),
          }
          return render(request, 'my_template.html', context)
     ```


pkgId: cc92e32376367a3ee71a4c9105d0ae98fadd6dfb8e606e3ac2c2116263831419
name: python-django-hawk-drf-help
arch: noarch
version: 1.1.3
epoch: 0
release: 1
summary: Development documents and examples for django-hawk-drf
url: https://github.com/uktrade/django-hawk-drf/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-hawk-drf-1.1.3-1.src.rpm
location_href: Packages/python-django-hawk-drf-help-1.1.3-1.noarch.rpm
checksum_type: sha256
description:
  This package provides [Django Rest Framework](https://github.com/encode/django-rest-framework/) helper classes for use with [Django Hawk](https://github.com/uktrade/django-hawk).



  Read the [Django Hawk installation](https://github.com/uktrade/django-hawk#installation) documentation.



  Read the [Django Hawk example usage](https://github.com/uktrade/django-hawk#example-usage) documentation.

  Add the `HawkResponseMiddleware` to the `MIDDLEWARE` setting in your project like so:

  ```
  MIDDLEWARE = [
      ...
      "django_hawk.middleware.HawkResponseMiddleware",
      "django_hawk_drf.middleware.HawkResponseMiddleware",
      ...
  ]
  ```

  To check the you can use the `django_hawk.authentication.HawkAuthentication` authentication class.

  ```python
  from rest_framework.response import Response
  from rest_framework.viewsets import ViewSet

  from django_hawk_drf.authentication import HawkAuthentication


  class ExampleViewSet(ViewSet):
      authentication_classes = (HawkAuthentication,)
      permission_classes = ()

      def list(self, request):
          return Response([])
  ```



  Tests belong in the `/django_hawk_drf/tests/` directory. You can run the tests by installing the requirements like so:


  ```
  make setup
  ```

  Now you can run the tests using the following command:

  ```
  poetry run python manage.py test
  ```



  We use [tox](https://pypi.org/project/tox/) to test compatibility across different Django versions.

  To run these tests with tox, just run the following:

  ```
  make tox
  ```



  - [PyPI Package](https://pypi.org/project/django-hawk-drf/)
  - [Test PyPI Package](https://test.pypi.org/project/django-hawk-drf/)

  Running `make build-package` will build the package into the `dist/` directory
  Running `make push-pypi-test` will push the built package to Test PyPI
  Running `make push-pypi` will push the built package to PyPI


pkgId: cf220c757cdd0d3af7c796b76c294251f1c196e70b8922b0696d346295ce5c38
name: python-django-hawk-help
arch: noarch
version: 1.2.3
epoch: 0
release: 1
summary: Development documents and examples for django-hawk
url: https://github.com/uktrade/django-hawk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-hawk-1.2.3-1.src.rpm
location_href: Packages/python-django-hawk-help-1.2.3-1.noarch.rpm
checksum_type: sha256
description:
  This package can be used to help create HAWK Authenticated views.



  ```
  pip install django-hawk
  ```

  Add the following to your Django Settings:

  ```python
  DJANGO_HAWK = {
      "HAWK_INCOMING_ACCESS_KEY": "xxx",
      "HAWK_INCOMING_SECRET_KEY": "xxx",
  }
  ```



  To use the HAWK Authentication, we need to do 2 things:

  1. Make sure the `HawkResponseMiddleware` runs
  2. Check the authentication

  Add the `HawkResponseMiddleware` to the `MIDDLEWARE` setting in your project like so:

  ```
  MIDDLEWARE = [
      ...
      "django_hawk.middleware.HawkResponseMiddleware",
      ...
  ]
  ```

  To check the authentication you can call `django_hawk.utils.authenticate_request`, if an exception isn't raised then you know that the request is authenticated, see below for examples.

  ```python
  from django.http import HttpResponse

  from django_hawk.utils import DjangoHawkAuthenticationFailed, authenticate_request

  def simple_view(request):
      
      try:
          authenticate_request(request=request)
      except DjangoHawkAuthenticationFailed as e:
          return HttpResponse(status=401)

      
      return HttpResponse("This is a simple view")
  ```



  Tests belong in the `/django_hawk/tests/` directory. You can run the tests by installing the requirements like so:

  ```
  make setup
  ```

  Now you can run the tests using the following command:

  ```
  poetry run python manage.py test
  ```



  We use [tox](https://pypi.org/project/tox/) to test compatibility across different Django versions.

  To run these tests with tox, just run the following:

  ```
  make tox
  ```



  - [PyPI Package](https://pypi.org/project/django-hawk/)
  - [Test PyPI Package](https://test.pypi.org/project/django-hawk/)

  Running `make build-package` will build the package into the `dist/` directory.

  Running `make push-pypi-test` will push the built package to Test PyPI.

  Running `make push-pypi` will push the built package to PyPI.



  First you will need to add the test pypy repository to your poetry config:

  ```
  poetry config repositories.test-pypi https://test.pypi.org/legacy/
  ```

  Then go to https://test.pypi.org/manage/account/token/ and generate a token.

  Then add it to your poetry config:

  ```
  poetry config pypi-token.test-pypi XXXXXXXX
  ```

  Then you also need to go to https://pypi.org/manage/account/token/ to generate a token for the real PyPI.

  Then add it to your poetry config:

  ```
  poetry config pypi-token.pypi XXXXXXXX
  ```

  Now the make commands should work as expected.


pkgId: 5cb2c84316865d94807dcd3f7bf717eecee8f59bcc6d7e267a4009fb0916774a
name: python-django-i18nfield-help
arch: noarch
version: 1.10.0
epoch: 0
release: 1
summary: Development documents and examples for django-i18nfield
url: https://github.com/raphaelm/django-i18nfield
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-i18nfield-1.10.0-1.src.rpm
location_href: Packages/python-django-i18nfield-help-1.10.0-1.noarch.rpm
checksum_type: sha256
description:
  This is yet another way to store multi-lingual content in Django_. In contrast to other options
  like `django-hvad`_, `django-modeltranslation`_ or `django-parler`_ it does not require additonal
  database tables and you can reconfigure the available languages without any changes to the database
  schema. In constrast to `nece`_, it is not specific to PostgreSQL.
  How does it work then? It stores JSON data into a ``TextField``. Yes, this is kinda dirty and violates
  the `1NF`_. This makes it harder for non-django based programs to interact directly with your database
  and is not perfectly efficient in terms of storage space.
  It also lacks the ability to do useful lookups, searches and indices on internationalized fields.
  If one of those things are important to you, **this project is not for you**, please choose one of the
  ones that we linked above.
  However if those limitations are fine for you, this provides you with a very lightweight, easy to use and
  flexible solution. This approach has been in use in `pretix`_ for quite a while, so it has been tested in
  production. The package contains not only the model fields, but also form fields and everything you need
  to get them running.


pkgId: 9f8e440c2b674996a4b0d8008b43aa4b16414f638ebb07c1ffa2de92de3ad1b0
name: python-django-informixdb-vault-dev-help
arch: noarch
version: 0.1.dev2
epoch: 0
release: 1
summary: Development documents and examples for django-informixdb-vault-dev
url: https://github.com/reecetech/django_informixdb_vault_dev
rpm_license: APLv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-informixdb-vault-dev-0.1.dev2-1.src.rpm
location_href: Packages/python-django-informixdb-vault-dev-help-0.1.dev2-1.noarch.rpm
checksum_type: sha256
description:
  Extends the database driver for Django `django_informixdb_dev` to retrieve credentials from a Hashicorp Vault service.


pkgId: ead3a945c217fdf85a931cd3964cf159b0bb6474253cc4b4458fd4588a6dfd27
name: python-django-informixdb-vault-help
arch: noarch
version: 0.6.2
epoch: 0
release: 1
summary: Development documents and examples for django-informixdb-vault
url: https://github.com/reecetech/django_informixdb_vault
rpm_license: APLv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-informixdb-vault-0.6.2-1.src.rpm
location_href: Packages/python-django-informixdb-vault-help-0.6.2-1.noarch.rpm
checksum_type: sha256
description:
  Extends the database driver for Django `django_informixdb` to retrieve credentials from a Hashicorp Vault service.


pkgId: f8f08180021b919191c46cb18b1e1e0db1f126453f87221567e190eb42b7ec2c
name: python-django-js-lib-alpinejs-help
arch: noarch
version: 3.14.7.1
epoch: 0
release: 1
summary: Development documents and examples for django-js-lib-alpinejs
url: https://pypi.org/project/django-js-lib-alpinejs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-js-lib-alpinejs-3.14.7.1-1.src.rpm
location_href: Packages/python-django-js-lib-alpinejs-help-3.14.7.1-1.noarch.rpm
checksum_type: sha256
description:
  [Alpine.js](TODO) packaged in a Django reusable app.

  This package includes the original JS files from the library.




      pip install django-js-lib-alpinejs



  1. Add `"js_lib_alpinejs"` to your `INSTALLED_APPS` setting like this::

         INSTALLED_APPS = [
             ...
             "js_lib_alpinejs",
             ...
         ]

  2. In your template use:

         {% load static %}

     ...

         <script src="{%static "js_lib_alpinejs/alpinejs.js" %}"></script>


pkgId: fa30e06fbeac0fe9c1e72bf66c00cac740b29647ff7344a5e2cdf6582d961726
name: python-django-locality-two-help
arch: noarch
version: 3.1
epoch: 0
release: 1
summary: Development documents and examples for django-locality-two
url: https://github.com/dekomote/django-locality-two/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-locality-two-3.1-1.src.rpm
location_href: Packages/python-django-locality-two-help-3.1-1.noarch.rpm
checksum_type: sha256
description:
  `django-locality-two` is a drop-in replacement for django-locality with modern python (3.5+) and django (1.11+) support,
  and more tests.
  Locality is a light collection of helpers for handling countries and
  territories in Django.

  Currently, it includes:

    * `locality.json`, a fixture with the world's countries and territories (if
      you notice any missing, [open an
      issue](https://github.com/dekomote/django-locality-two/issues) or [submit a pull
      request](https://github.com/dekomote/django-locality-two/compare/))
    * views returning serialized lists of countries and territories
    * simple form field and widget



  Install from the cheese shop

      pip install django-locality-two

  OR

  Install from GitHub with pip:

      pip install -e git+https://github.com/dekomote/django-locality-two.git#egg=django-locality-two==2.1.1

  Then add `locality` to `INSTALLED_APPS` in your Django settings. To load the
  included data, run:

      python manage.py loaddata locality

  (or whichever equivalent method you use to run "manage.py" commands)



  List all countries:

      >>> from locality.models import Country
      >>> print Country.objects.all()
      [<Country: Andorra>, <Country: United Arab Emirates>,
      <Country: Antigua and Barbuda>, ...]

  or list territories by country:

      >>> from locality.models import Country
      >>> for country in locality.models.Country.objects.all():
      >>>     print country.territories.all()
      ...
      [<Territory: Salta, Argentina>, <Territory: Buenos Aires, Argentina>,
      <Territory: Ciudad Autónoma de Buen os Aires, Argentina>, ...]

  You can create your own models around countries and territories:

      class Address(models.Model):
          country = models.ForeignKey('locality.models.Country')
          territory = models.ForeignKey('locality.models.Territory')



  Please report all bugs to the [GitHub issue
  tracker](https://github.com/dekomote/django-locality-two/issues)


pkgId: d98f0d0d7e60eca22c0f0339a150cd71295d9b2741853bf9b1abb24e6aa97b8a
name: python-django-magic-notifier-help
arch: noarch
version: 0.2.8
epoch: 0
release: 1
summary: Development documents and examples for django-magic-notifier
url: https://github.com/jefcolbi/django-magic-notifier
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-magic-notifier-0.2.8-1.src.rpm
location_href: Packages/python-django-magic-notifier-help-0.2.8-1.noarch.rpm
checksum_type: sha256
description:
  [![travis django-magic-notifier](https://api.travis-ci.com/jefcolbi/django-magic-notifier.svg?branch=main)](https://travis-ci.com/github/jefcolbi/django-magic-notifier) [![coverage django-magic-notifier](https://coveralls.io/repos/github/jefcolbi/django-magic-notifier/badge.svg?branch=main)](https://coveralls.io/github/jefcolbi/django-magic-notifier?branch=main) [![Pypi current version](https://img.shields.io/pypi/v/django-magic-notifier.svg)](https://pypi.org/project/django-magic-notifier/) [![Documentation](http://readthedocs.org/projects/django-magic-notifier/badge/?version=stable)](https://django-magic-notifier.readthedocs.io/en/stable/) ![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat)
  ![Python versions](https://img.shields.io/pypi/pyversions/django-magic-notifier) ![Django versions](https://img.shields.io/pypi/djversions/django-magic-notifier)
  ![](https://img.shields.io/github/stars/jefcolbi/django-magic-notifier.svg) ![](https://img.shields.io/github/forks/jefcolbi/django-magic-notifier.svg) ![](https://img.shields.io/github/tag/jefcolbi/django-magic-notifier.svg) ![](https://img.shields.io/github/issues/jefcolbi/django-magic-notifier.svg)


  Sending notifications in Django has always been a complex subject. Django Magic Notifier solves this by providing only one function **notify()**. The library [will] support sending notifications via email, sms and push notifications.


  [Full documentation](https://django-magic-notifier.readthedocs.io/en/latest/)



  - Send emails
  - Send sms, TWILIO support
  - Send push notifications
  - Support templates
  - Simple API
  - Support files
  - Support multiple gateways
  - Extensible
  - Support MJML



  > pip install --upgrade django-magic-notifier



  If you have already configured SMTP EMAIL SETTINGS in django settings then can ignore this step. Else add a NOTIFIER dict in your settings like this

  ```python
  NOTIFIER = {
      "EMAIL": {
          "default": {
              "HOST": "localhost",
              "PORT": 587,
              "USE_TLS": True,
              "USE_SSL": False,
              "USER": "root@localhost",
              "FROM": "Root <root@localhost>",
              "PASSWORD": "********",
              "CLIENT": "magic_notifier.email_clients.django_email.DjangoEmailClient",
          }
      },
      "USER_FROM_WS_TOKEN_FUNCTION": 'magic_notifier.utils.get_user_from_ws_token'
  }
  ```


  Create a folder named **notifier** in one of app's templates dir. In this folder create another folder named **my_template**
  then create your base templates in this folder. Example:

  *app_name/templates/notifier/my_template/email.html*
  ```
  {% extends "base_notifier/email.html" %}
  {% block content %}
  <tr>
      <td><p>Hello {{ user.email }}
      </td>
  </tr>
  {% endblock %}
  ```

  *app_name/templates/notifier/my_template/email.txt*
  ```
  {% extends "base_notifier/email.txt" %}
  {% block content %}
  Hello {{ user.email }}
  {% endblock %}
  ```

  As you can see, the user to whom the notification goes is automatically added
  in the template's context. To avoid any clash don't send the key `'user'`
  in the context of the  **notifiy()** function presented below.

  Note that it is DMN (Django Magic Notifier) that has the base_notifier template.


  To send a notification via email do
  ```python
      from magic_notifier.notifier import notify

      
      user = User(email="testuser@localhost", username="testuser")
      subject = "Test magic notifier"
      notify(["email"], subject, [user], final_message="Nice if you get this")

      
      user = User(email="testuser@localhost", username="testuser")
      subject = "Test magic notifier"
      notify(["email"], subject, [user], template='hello')

      
      user = User(email="testuser@localhost", username="testuser")
      subject = "Test magic notifier"
      notify(["sms"], subject, [user], template='hello')

      
      user = User(email="testuser@localhost", username="testuser")
      subject = "Test magic notifier"
      notify(["email", "sms"], subject, [user], template='hello')
  ```


  https://django-magic-notifier.readthedocs.io/en/latest/index.html




  - Generate full documentation
  - Translate documentation



  Contribution are welcome.


  As per the license, feel free to use the library as you want.


pkgId: aeeebf6e4a1222935602f9ac6bbefbad2664c627778dfb8115d0ac2089fedd01
name: python-django-meta-og-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for django-meta-og
url: https://gitlab.nic.cz/django-apps/django-meta-og
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-meta-og-1.0.2-1.src.rpm
location_href: Packages/python-django-meta-og-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  HTML Meta tags [OpenGraph](https://ogp.me/) for [Django](https://www.djangoproject.com/).
  The project uses the project [DjangoCMS Meta OG](https://gitlab.nic.cz/djangocms-apps/djangocms-meta-og) project.



  `pip install django-meta-og`


  Add into settings.py:

  ```python
  INSTALLED_APPS = [
      "django_meta_og",
      ...
  ]

  TEMPLATES  = [
      {"OPTIONS": {
              "context_processors": [
                  "django_meta_og.context_processors.meta",
                  ...
              ]
          }
      }
  ]
  ```

  Add into the templates:

  ```django
  {% load django_meta_og %}
  {% django_meta_og_prefix as og_prefix %}
  <head{% if og_prefix %} prefix="{{ og_prefix }}"{% endif %}>
      {% include "django_meta_og/header_meta.html" %}
  ```

  The result can be:

  ```html
  <head prefix="og: https://ogp.me/ns#">
      <meta property="og:type" content="website" />
      <meta property="og:title" content="The Title" />
      ...
  </head>
  ```



  BSD License


pkgId: 6c0601c1b561736f4dd12ec4e6e92ae4c7d74cec0bd7fe4265e5dd875137e6af
name: python-django-modelcluster-help
arch: noarch
version: 6.4
epoch: 0
release: 1
summary: Development documents and examples for django-modelcluster
url: https://github.com/wagtail/django-modelcluster
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-modelcluster-6.4-1.src.rpm
location_href: Packages/python-django-modelcluster-help-6.4-1.noarch.rpm
checksum_type: sha256
description:
  If you had a data model like this:
   class Band(models.Model):
       name = models.CharField(max_length=255)
   class BandMember(models.Model):
       band = models.ForeignKey('Band', related_name='members', on_delete=models.CASCADE)
       name = models.CharField(max_length=255)
  wouldn't it be nice if you could construct bundles of objects like this, independently of the database:
   beatles = Band(name='The Beatles')
   beatles.members = [
       BandMember(name='John Lennon'),
       BandMember(name='Paul McCartney'),
   ]
  Unfortunately, you can't. Objects need to exist in the database for foreign key relations to work:
   IntegrityError: null value in column "band_id" violates not-null constraint
  But what if you could? There are all sorts of scenarios where you might want to work with a 'cluster' of related objects, without necessarily holding them in the database: maybe you want to render a preview of the data the user has just submitted, prior to saving. Maybe you need to construct a tree of things, serialize them and hand them off to some external system. Maybe you have a workflow where your models exist in an incomplete 'draft' state for an extended time, or you need to handle multiple revisions, and you don't want to redesign your database around that requirement.
  **django-modelcluster** extends Django's foreign key relations to make this possible. It introduces a new type of relation, *ParentalKey*, where the related models are stored locally to the 'parent' model until the parent is explicitly saved. Up to that point, the related models can still be accessed through a subset of the QuerySet API:
   from modelcluster.models import ClusterableModel
   from modelcluster.fields import ParentalKey
   class Band(ClusterableModel):
       name = models.CharField(max_length=255)
   class BandMember(models.Model):
       band = ParentalKey('Band', related_name='members', on_delete=models.CASCADE)
       name = models.CharField(max_length=255)
   >>> beatles = Band(name='The Beatles')
   >>> beatles.members = [
   >>> [member.name for member in beatles.members.all()]
   ['John Lennon', 'Paul McCartney']
   >>> beatles.members.add(BandMember(name='George Harrison'))
   >>> beatles.members.count()
   3
   >>> beatles.save()  # only now are the records written to the database
  For more examples, see the unit tests.


pkgId: 5238d78fffff7d080690d6ded7bad2d7fe8d1a0316c78506c2be3f1f16a501c0
name: python-django-ngrok-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for django-ngrok
url: https://pypi.org/project/django-ngrok/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-ngrok-0.1.0-1.src.rpm
location_href: Packages/python-django-ngrok-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  _Expose your local Django app to the internet with ngrok_



  1. Install with pip:

  ```
  pip install django-ngrok
  ```

  2. Add django-ngrok to INSTALLED_APPS in your Django settings file:

  ```python
  INSTALLED_APPS = [
      ...
      'django_ngrok',
  ]
  ```

  3. Set the `NGROK_AUTHTOKEN` environment variable to [your ngrok authtoken](https://dashboard.ngrok.com/get-started/your-authtoken):

  ```bash
  export NGROK_AUTHTOKEN="your-ngrok-authtoken"
  ```

  4. Run `python manage.py runserver_ngrok` to start a django development server and an ngrok tunnel pointing to the server address. You should expect to see the following output:

  ```
  Watching for file changes with StatReloader
  Performing system checks...

  System check identified no issues (0 silenced).
  December 13, 2024 - 19:58:42
  Django version X.Y.ZZ, using settings 'your.settings'
  Starting development server at http://127.0.0.1:8000/
  Quit the server with CONTROL-C.

  ngrok forwarding to http://127.0.0.1:8000 from ingress url: https://your-ngrok-domain.ngrok-free.app
  ```



  django-ngrok uses the `forward` method from [`ngrok-python`](https://github.com/ngrok/ngrok-python) to create a tunnel to the Django development server. If you are using a simple setup, no configuration is necessary, and you can get up-and-running by following the [quick start](#quick-start).

  For a more explicit setup, you can add the `NGROK_CONFIG` setting to your Django settings file. All options below are documented [here](https://github.com/ngrok/ngrok-python#full-configuration). If you have any questions about how to use these options, please direct them to the `ngrok-python` maintainers.

  ```python
  NGROK_CONFIG = {
      
      "authtoken": str,
      "authtoken_from_env": True | False,  # Defaults to True
      "app_protocol": str,
      "session_metadata": str,
      
      "server_addr": str,
      "root_cas": str,
      "session_ca_cert": str,
      
      "metadata": str,
      "domain": str,
      "schemes": list[str],
      "proto": str,
      "proxy_proto": str,
      "labels": str,
      
      "basic_auth": list[str],
      "circuit_breaker":0.1,
      "compression":True,
      "allow_user_agent": str,
      "deny_user_agent": str,
      "allow_cidr": str,
      "deny_cidr": str,
      "crt": bytes,  # I assume bytes, docs don't specify, haven't tested it.
      "key": bytes,
      "mutual_tls_cas": bytes,
      "oauth_provider": str,
      "oauth_allow_domains": list[str],
      "oauth_allow_emails": list[str],
      "oauth_scopes": list[str],
      "oauth_client_id": str,
      "oauth_client_secret": str,
      "oidc_issuer_url": str,
      "oidc_client_id": str,
      "oidc_client_secret": str,
      "oidc_allow_domains": list[str],
      "oidc_allow_emails": list[str],
      "oidc_scopes": list[str],
      "policy": str,
      "request_header_remove": str,
      "response_header_remove": str,
      "request_header_add": str,
      "response_header_add": str,
      "verify_upstream_tls": True | False,
      "verify_webhook_provider": str,
      "verify_webhook_secret": str,
      "websocket_tcp_converter": True | False,
  }
  ```


  Contributions and feedback are welcome! A contribution guide is upcoming, but if you have any questions, please feel free to open an issue or reach out directly.

rpm_license:
  # MIT License  _Copyright (c) 2024 Sam Morgan_  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: 8fb5c4f820ae5ffd764dc1923751a6ab8eb6f248800c93de70b2d392a97f5e9a
name: python-django-object-tool-help
arch: noarch
version: 0.0.12
epoch: 0
release: 1
summary: Development documents and examples for django-object-tool
url: https://github.com/Xavier-Lam/django-object-tool
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-object-tool-0.0.12-1.src.rpm
location_href: Packages/python-django-object-tool-help-0.0.12-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/django-object-tool.svg)](https://pypi.org/project/django-object-tool)
  [![Build Status](https://travis-ci.org/Xavier-Lam/django-object-tool.svg?branch=master)](https://travis-ci.org/Xavier-Lam/django-object-tool)

  **django-object-tool** let you can customize django administration's object-tools bar. You can add actions to object-tools bar beside add-object button. The definition of object-tool action are almost same as django's default action.

  > This is a pre alpha version without any unittest, there may have serveral problems and not compatible with some django or python versions.

  ![](docs/static/images/example.jpg?raw=true)

  - [Quick Start](#quick-start)
    - [Installation](#installation)
    - [Write your first admin](#write-your-first-admin)
    - [Specific view only object tools](#specific-view-only-object-tools)
    - [Shortcuts](#shortcuts)
      - [Shortcut for hyperlinks](#shortcut-for-hyperlinks)
      - [Execute after confirmation](#execute-after-confirmation)
      - [Create a form](#create-a-form)
  - [Advanced usage](#advanced-usage)
    - [Site wide object tools](#site-wide-object-tools)
    - [Work with your own admin template](#work-with-your-own-admin-template)
    - [Use in reusable apps](#use-in-reusable-apps)
    - [Ordering of object tools](#ordering-of-object-tools)
    - [Customize button styles](#customize-button-styles)
  - [Configurations](#configurations)
  - [Compatibilities](#compatibilities)
    - [django-import-export](#django-import-export)
  - [Example app](#example-app)
  - [TODOS](#todos)
  - [Change logs](#change-logs)
    - [0.0.1](#001)



  Install django-object-tool by using pip

      pip install django-object-tool

  then add it to your INSTALLED_APP

      
      INSTALLED_APPS = (
          ...
          "object-tool",
          "your app needs object-tool"
      )

  All prequisites are set up! See [Write your first admin](#Write-your-first-admin) to learn how to use django-object-tool in your project.

   > Note: We've patched django's default admin site(`django.contrib.admin.site`) by default, if you want to write your own admin site, please mix `object_tool.CustomObjectToolAdminSiteMixin` in your admin site class or direct inherit from `object_tool.CustomObjectToolAdminSite`.
   >
   > If you don't want to change the default site generate by django, you can set `OBJECT_TOOL_PATCHADMINSITE` to `False` in your settings file.


  The object tool takes a request and an optional object, when this tool called inside a change view, the current editing object will be passed in.

      from object_tool import CustomObjectToolModelAdminMixin

      class SomeModelAdmin(CustomObjectToolModelAdminMixin, admin.ModelAdmin):
          object_tools = ("some_action",)

          def some_action(self, request, obj=None):
              if obj:
                  obj.some_property = "value"
                  obj.save()
              else:
                  self.get_queryset(request).all().update(some_property="value")

  > The definition of object tool's action is almost same as django's default action, except the third parameter of the function is a optional current editing object rather than a queryset.


  You can define a object tool only show in changelist view or change view by register it to changelist_object_tools or change_object_tools in your model admin.

      from object_tool import CustomObjectToolModelAdminMixin

      class SomeModelAdmin(CustomObjectToolModelAdminMixin, admin.ModelAdmin):
          changelist_object_tools = ("changelist_view_only_action",)
          change_object_tools = ("change_view_only_action", )



  You can create a hyperlink object tool like add-object by using `object_tool.link`, it takes a url as the first parameter and optional short_description as the second parameter.

      from object_tool import CustomObjectToolModelAdminMixin, link

      class SomeModelAdmin(CustomObjectToolModelAdminMixin, admin.ModelAdmin):
          object_tools = ("forkme", )

          forkme = link(
              "https://github.com/Xavier-Lam/django-object-tool",
              "Fork me on github")


      @object_tool.confirm("are you sure to edit s??", "confirm-tool")
      def confirm_action(self, request, obj=None):
          messages.success(request, "success!")


  With `object_tool.form` decorator, it is very easy to create a form view. This decorator takes a Form class as first parameter and it will auto render the form. When form is cleaned, it will actually execute decorated codes.

      from object_tool import CustomObjectToolModelAdminMixin, form

      class Form(forms.Form):
          text = forms.CharField()

      class UserAdmin(CustomObjectToolModelAdminMixin, admin.ModelAdmin):
          object_tools = ("greetings", )

          @form(Form, "greetings")
          def greetings(self, request, form, obj=None):
              text = form.cleaned_data["text"]
              tpl = "greetings to {name}: {text}"
              if obj:
                  msg = tpl.format(name=obj.name, text=text)
              else:
                  msg = tpl.format(name="all users", text=text)
              messages.info(request, msg)



  You can create a site wide object tool by register your object tool to the admin site which inherited from `object_tool.CustomObjectToolAdminSiteMixin`. You can set the second parameter of `object_tool.CustomObjectToolAdminSiteMixin.add_object_tool` to *changelist* or *change* if you want to make your object tool appear in changelist view or change view only.

      admin_site.add_object_tool(lambda modeladmin, request, obj=None: "some action")

  > Note: Apparantly, you need to set your model admin's admin_site to the above site which your object tool registered to.


   In a `object_tool.CustomObjectToolAdminSiteMixin` class, rather than extends your template from `admin/change_list.html` or `admin/change_form.html`, you should extends `admin/object_tool/object-tool-items.html` instead.

  * admin.py

          class SomeModelAdmin(CustomObjectToolModelAdminMixin, admin.ModelAdmin):
              change_list_template = "template.html"

  * template.html

          {% extends 'admin/object_tool/baseview.html' %}

          ...your template code goes here...



  You may run `object_tool.ObjectToolConfig.register()` in your reusable app's ready method. By doing this, users who use your reusable app needn't to add `object_tool` to their INSTALLED_APPS. By default this will not replace the default admin site and modeladmin, you need inherit your modeladmin class from `object_tool.ObjectToolModelAdminMixin`, if you still want to replace the default modeladmin, you need pass True to the register method, but we don't recommend you to do so, this have a side-effect on other apps your installed.

      class AppConfig(AppConfig):
          name = 'app'

          def ready(self):
              import object_tool
              object_tool.ObjectToolConfig.register()



  Refer to the below table which lists the object tools' registration with the highest precedence at the top and lowest at the bottom.

  * admin site global tools
  * admin site global specify view tools
  * tools defined in parent model admins
  * specify view tools defined in parent model admins
  * tools defined in current model admin
  * specify view tools defined in current model admin


  Assign *classes* property to object tool action can add classes to the object tool button.

      def some_action(self, request, obj=None):
          pass

      some_action.classes = "addlink"


  | name | default | description |
  | --- | --- | --- |
  | OBJECT_TOOL_PATCHADMINSITE | True | replace `django.contrib.admin.sites.site` with `object_tool.CustomObjectToolAdminSite` when app loaded |
  | OBJECT_TOOL_PATCHMODELADMIN | False | replace `django.contrib.admin.options.ModelAdmin` with `object_tool.CustomObjectToolModelAdmin` when app loaded |



  We do not support [django-import-export](https://github.com/django-import-export/django-import-export/tree/master/import_export) yet, but we have plan support django-import-export in the future.


  We provided an example app

      git clone git@github.com:Xavier-Lam/django-object-tool.git
      cd django-object-tool/example
      pip install -r requirements.txt
      python manage.py migrate
      python manage.py runserver

  Then visit ***http://127.0.0.1:8000/admin*** and login as super admin by using account ***admin*** with password ***123456***.


  * unittests
  * permissions
  * [django-import-export](https://github.com/django-import-export/django-import-export/tree/master/import_export) compatibility



  * custom object tools


pkgId: b0a9a9f39172a16d8ead1fba53f724f7e43edc91f83c612967db76ea03799632
name: python-django-payments-chile-help
arch: noarch
version: 2024.12.5
epoch: 0
release: 1
summary: Development documents and examples for django-payments-chile
url: https://mariofix.github.io/django-payments-chile/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-payments-chile-2024.12.5-1.src.rpm
location_href: Packages/python-django-payments-chile-help-2024.12.5-1.noarch.rpm
checksum_type: sha256
description:
  `django-payments-chile` es una extensión para [django-payments](https://github.com/jazzband/django-payments), una biblioteca que proporciona una interfaz universal para procesar pagos en aplicaciones Django. Este proyecto añade soporte específico para varios proveedores de pagos chilenos como Flow, Khipu, Webpay, y otros.

  :warning: :warning: **Este proyecto está en desarrollo activo**, usar con precaución. :warning: :warning:

  ![PyPI - Status](https://img.shields.io/pypi/status/django-payments-chile)
  [![Downloads](https://pepy.tech/badge/django-payments-chile)](https://pepy.tech/project/django-payments-chile)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/fde07768d1714b0b93c6addd5e13bb7f)](https://app.codacy.com/gh/mariofix/django-payments-chile/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
  [![Codacy Badge](https://app.codacy.com/project/badge/Coverage/fde07768d1714b0b93c6addd5e13bb7f)](https://app.codacy.com/gh/mariofix/django-payments-chile/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/mariofix/django-payments-chile/main.svg)](https://results.pre-commit.ci/latest/github/mariofix/django-payments-chile/main)
  [![Tests & Coverage](https://github.com/mariofix/django-payments-chile/actions/workflows/tests_coverage.yml/badge.svg?branch=main)](https://github.com/mariofix/django-payments-chile/actions/workflows/tests_coverage.yml)
  ![PyPI](https://img.shields.io/pypi/v/django-payments-chile)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/django-payments-chile)
  ![PyPI - Implementation](https://img.shields.io/pypi/implementation/django-payments-chile)
  ![PyPI - License](https://img.shields.io/pypi/l/django-payments-chile)



  | Proveedor | Estado | Descripcion |
  | --- | --- | --- |
  | Flow | :white_check_mark: | Plataforma chilena para pagos en línea que admite múltiples métodos de pago. |
  | Khipu | :white_check_mark: | Permite pagos mediante transferencia electrónica en tiempo real. |
  | Klap | :x: | Solución de pagos electrónicos enfocados en comercios. |
  | Kushki | :x: | Proveedor de pagos electrónicos que facilita la integración con diversas plataformas. |
  | Payku | :x: | Plataforma de pagos enfocada en pequeñas y medianas empresas. |
  | Webpay | :white_check_mark: | El sistema de pago en línea más utilizado en Chile, operado por Transbank. |



  - Soporte para múltiples proveedores de pago en un solo proyecto.
  - API consistente para crear, procesar y verificar transacciones.
  - Fácil configuración y personalización.
  - Documentación clara para desarrolladores.
  - Soporte para eventos de éxito, fallo, y reembolsos de pagos.



  La biblioteca `django-payments-chile` está disponible en PyPi. Puedes instalarla fácilmente con tu gestor de paquetes favorito, como `pip`, `poetry`, o `pipenv`.

  ```bash
  pip install django-payments-chile
  ```



  Agrega las credenciales de los proveedores de pago en tu archivo de configuración:

  ```python
  PAYMENT_VARIANTS = {
      'flow': ('django_payments_chile.FlowProvider', {
          'api_key': 'tu_api_key_flow',
          'secret': 'tu_secret_flow',
      }),
      'webpay': ('django_payments_chile.WebpayProvider', {
          'commerce_code': 'tu_commerce_code_webpay',
          'api_key': 'tu_api_key_webpay',
      }),
  }
  ```



  Este proyecto no está afiliado, asociado ni patrocinado por ninguna de las empresas mencionadas en el listado de compatibilidad.

  El código de este proyecto está disponible bajo la licencia [MIT](LICENSE), lo que significa que puedes utilizarlo, modificarlo y distribuirlo de manera libre, sujeto a las condiciones establecidas en dicha licencia.


pkgId: 88a033b398ab080d2f718be992e6846159bbb63c91109517069ed8b59d851480
name: python-django-pg-migration-tools-help
arch: noarch
version: 0.1.14
epoch: 0
release: 1
summary: Development documents and examples for django-pg-migration-tools
url: https://pypi.org/project/django-pg-migration-tools/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pg-migration-tools-0.1.14-1.src.rpm
location_href: Packages/python-django-pg-migration-tools-help-0.1.14-1.noarch.rpm
checksum_type: sha256
description:
  Tools to make Django migrations safer and more scalable.



  [Full documentation](https://django-pg-migration-tools.readthedocs.io/en/latest/).

rpm_license:
  BSD 3-Clause License  Copyright (c) 2024, Kraken Technologies Limited  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: 90e472c00ebcd4b73389351b6af6055640992fd48b8ed9fc8af03c50915c6e0d
name: python-django-pgactivity-help
arch: noarch
version: 1.7.1
epoch: 0
release: 1
summary: Development documents and examples for django-pgactivity
url: https://github.com/AmbitionEng/django-pgactivity
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pgactivity-1.7.1-1.src.rpm
location_href: Packages/python-django-pgactivity-help-1.7.1-1.noarch.rpm
checksum_type: sha256
description:
  `django-pgactivity` makes it easy to view, filter, and kill active Postgres queries.

  Some of the features at a glance:

  * The `PGActivity` proxy model and `pgactivity` management command for querying and filtering the [Postgres pg_stat_activity view](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ACTIVITY-VIEW).
  * `pgactivity.context` and `pgactivity.middleware.ActivityMiddleware` for annotating queries with application metadata, such as the request URL.
  * `pgactivity.cancel` and `pgactivity.terminate` for canceling and terminating queries. The `PGActivity` model manager also has these methods.
  * `pgactivity.timeout` for dynamically setting the statement timeout.





  Use `python manage.py pgactivity` to view and filter active queries. Output looks like the following:

      39225 | 0:01:32 | IDLE_IN_TRANSACTION | None | lock auth_user in access exclusiv
      39299 | 0:00:15 | ACTIVE | None | SELECT "auth_user"."id", "auth_user"."password
      39315 | 0:00:00 | ACTIVE | None | WITH _pgactivity_activity_cte AS ( SELECT pid

  The default output attributes are:

  1. The process ID of the connection.
  2. The duration of the query.
  3. The state of the query (see the [Postgres docs](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ACTIVITY-VIEW) for values).
  4. Attached context using `pgactivity.context`.
  5. The query SQL.

  Apply filters with `-f` (or `--filter`). Here we query for all active queries that have a duration longer than a minute:

      python manage.py pgactivity -f state=ACTIVE -f 'duration__gt=1 minute'

  Cancel or terminate activity with `--cancel` or `--terminate`. Here we terminate a query based on the process ID:

      python manage.py pgactivity 39225 --terminate



  You can attach context to queries to better understand where they originate using `pgactivity.context` or by adding `pgactivity.middleware.ActivityMiddleware` to `settings.MIDDLEWARE`. Underneath the hood, a comment is added to the SQL statement and surfaced in `django-pgactivity`.

  When using the middleware, the `url` of the request and the `method` of the request are automatically added. Here's what the output looks like when using the `pgactivity` command:

      39299 | 0:00:15 | ACTIVE | {"url": "/admin/", "method": "GET"} | SELECT "auth_use



  Use the `pgactivity.models.PGActivity` proxy model to query the [Postgres pg_stat_activity view](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ACTIVITY-VIEW). The model contains most of the fields from the view, and the `cancel` and `terminate` methods can be applied to the queryset.



  Dynamically set the SQL statement timeout of code using `pgactivity.timeout``:

  ```python
  import pgactivity

  @pgactivity.timeout(0.5)
  def my_operation():
      
      
  ```



  `django-pgactivity` is compatible with Python 3.9 - 3.13, Django 4.2 - 5.1, Psycopg 2 - 3, and Postgres 13 - 17.



  [View the django-pgactivity docs here](https://django-pgactivity.readthedocs.io) to learn more about:

  * The proxy models and custom queryset methods.
  * Attaching application context to queries.
  * Using and configuring the management command.
  * Setting dynamic statement timeouts.



  Install `django-pgactivity` with:

      pip3 install django-pgactivity
  After this, add `pgactivity` to the `INSTALLED_APPS` setting of your Django project.



  For information on setting up django-pgactivity for development and contributing changes, view [CONTRIBUTING.md](CONTRIBUTING.md).



  - [Wes Kendall](https://github.com/wesleykendall)
  - [Paul Gilmartin](https://github.com/PaulGilmartin)


pkgId: 6c425dbb73456f71507b307ffea3ff144fcb6fd4c81396bf52aeabd09ce0f554
name: python-django-pgbulk-help
arch: noarch
version: 3.2.1
epoch: 0
release: 1
summary: Development documents and examples for django-pgbulk
url: https://github.com/AmbitionEng/django-pgbulk
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pgbulk-3.2.1-1.src.rpm
location_href: Packages/python-django-pgbulk-help-3.2.1-1.noarch.rpm
checksum_type: sha256
description:
  `django-pgbulk` provides functions for doing native Postgres bulk upserts (i.e. [UPDATE ON CONFLICT](https://www.postgresql.org/docs/current/sql-insert.html)), bulk updates, and [COPY FROM](https://www.postgresql.org/docs/current/sql-copy.html).

  Bulk upserts can distinguish between updated/created rows and ignore unchanged updates.

  Bulk updates are true bulk updates, unlike Django's [bulk_update](https://docs.djangoproject.com/en/4.2/ref/models/querysets/#bulk-update) which can still suffer from *O(N)* queries and can create poor locking scenarios.

  Bulk copies can significantly speed-up bulk inserts, sometimes by an order of magnitude over Django's `bulk_create`.







  ```python
  import pgbulk

  pgbulk.upsert(
      MyModel,
      [
          MyModel(int_field=1, some_attr="some_val1"),
          MyModel(int_field=2, some_attr="some_val2"),
      ],
      
      ["int_field"],
      
      
      ["some_attr"]
  )
  ```



  ```python
  import pgbulk

  pgbulk.update(
      MyModel,
      [
          MyModel(id=1, some_attr='some_val1'),
          MyModel(id=2, some_attr='some_val2')
      ],
      
      
      ['some_attr']
  )
  ```



  ```python
  import pgbulk

  pgbulk.copy(
      MyModel,
      
      [
          MyModel(id=1, some_attr='some_val1'),
          MyModel(id=2, some_attr='some_val2')
      ],
  )
  ```



  Here are some advanced features at a glance:

  - `pgbulk.upsert` can categorize which rows were inserted or updated.
  - `pgbulk.upsert` and `pgbulk.update` can ignore updating unchanged fields.
  - `pgbulk.upsert` and `pgbulk.update` can use expressions in updates.



  [View the django-pgbulk docs here](https://django-pgbulk.readthedocs.io/) for more examples.



  `django-pgbulk` is compatible with Python 3.9 - 3.13, Django 4.2 - 5.1, Psycopg 2 - 3, and Postgres 13 - 17.



  Install `django-pgbulk` with:

      pip3 install django-pgbulk



  For information on setting up django-pgbulk for development and contributing changes, view [CONTRIBUTING.md](CONTRIBUTING.md).



  - [Wes Kendall](https://github.com/wesleykendall)



  - @max-muoto
  - @dalberto


