# packages

pkgId: 12f47432b9a53efdb1ad7f0e2f09efe86cd5b4bd71a883a52871485a72ba4f17
name: python-django-pgclone-help
arch: noarch
version: 3.6.1
epoch: 0
release: 1
summary: Development documents and examples for django-pgclone
url: https://github.com/AmbitionEng/django-pgclone
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pgclone-3.6.1-1.src.rpm
location_href: Packages/python-django-pgclone-help-3.6.1-1.noarch.rpm
checksum_type: sha256
description:
  `django-pgclone` makes it easy to dump and restore Postgres databases.
  Here are some key features:

  1. Streaming dumps and restores to configurable storage backends like S3. Instances with limited memory aren't a problem for large databases.
  2. A restoration process that works behind the scenes, swapping in the restored database when finished.
  3. Configurable hooks into the dump and restore process, for example, migrating a restored database before it is swapped.
  4. Reversible restores, making it possible to quickly revert to the initial restore or the previous database.
  5. Re-usable configurations for instrumenting different types of dumps and restores.



  To dump a database, do:

      python manage.py pgclone dump

  To list database dump keys, do:

      python manage.py pgclone ls

  To restore a datase, do:

      python manage.py pgclone restore <dump_key>

  Database dumps are relative to the storage location, which defaults to the local file system. Dump keys are in the format of `<instance>/<database>/<config>/<timestamp>.dump`.

  When listing, use an optional prefix. Restoring supports the same interface, using the latest key that matches the prefix.



  [View the django-pgclone docs here](https://django-pgclone.readthedocs.io/) to learn more about:

  * The basics and an overview of how it works.
  * The core command docs.
  * Configuring an S3 storage backend.
  * Running management command hooks during dumping or restoring.
  * Creating restores that can be quickly reverted.
  * Re-using command parameters for different flows.
  * All settings.
  * Additional details on using AWS RDS databases.



  `django-pgclone` is compatible with Python 3.9 - 3.13, Django 4.2 - 5.1, Psycopg 2 - 3, and Postgres 13 - 17.



  Install `django-pgclone` with:

      pip3 install django-pgclone

  After this, add `pgclone` to the `INSTALLED_APPS` setting of your Django project.

  **Note**  Install the AWS CLI to enable the S3 storage backend. Use `pip install awscli` or follow the [installation guide here](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).



  For information on setting up `django-pgclone` for development and contributing changes, view [CONTRIBUTING.md](CONTRIBUTING.md).



  - @wesleykendall (Wes Kendall)
  - @ethanpobrien (Ethan O'Brien)


pkgId: a77e8f71e17d2f1ea52f9b96c6884f9fc18797de04217ebb5d7e859a43535238
name: python-django-pghistory-help
arch: noarch
version: 3.5.1
epoch: 0
release: 1
summary: Development documents and examples for django-pghistory
url: https://github.com/AmbitionEng/django-pghistory
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pghistory-3.5.1-1.src.rpm
location_href: Packages/python-django-pghistory-help-3.5.1-1.noarch.rpm
checksum_type: sha256
description:
  `django-pghistory` tracks changes to your Django models using [Postgres triggers](https://www.postgresql.org/docs/current/sql-createtrigger.html), providing:

  * Reliable history tracking everywhere with no changes to your application code.
  * Structured history models that mirror the fields of your models.
  * Grouping of history with additional context attached, such as the logged-in user.

  `django-pghistory` has a number of ways in which you can configure history tracking for your application's needs and for performance and scale. An admin integration and middleware is included out of the box too.

  <a id="quick_start"></a>


  Decorate your model with `pghistory.track`. For example:

  ```python
  import pghistory

  @pghistory.track()
  class TrackedModel(models.Model):
      int_field = models.IntegerField()
      text_field = models.TextField()
  ```

  Above we've tracked `TrackedModel`. Copies of the model will be stored in a dynamically-created event model on every insert and update.

  Run `python manage.py makemigrations` followed by `migrate` and *voila*, every change to `TrackedModel` is now stored. This includes bulk methods and even changes that happen in raw SQL. For example:

  ```python
  from myapp.models import TrackedModel

  m = TrackedModel.objects.create(int_field=1, text_field="hello")
  m.int_field = 2
  m.save()

  print(m.events.values("pgh_obj", "int_field"))

  > [{'pgh_obj': 1, 'int_field': 1}, {'pgh_obj': 1, 'int_field': 2}]
  ```

  Above we printed the history of `int_field`. We also printed `pgh_obj`, which references the tracked object. We'll cover how these fields and additional metadata fields are tracked later.

  `django-pghistory` can track a subset of fields and conditionally store events based on specific field transitions. Users can also store free-form context from the application in event metadata, all with no additional database queries. See the next steps below on how to dive deeper and configure it for your use case.



  `django-pghistory` is compatible with Python 3.9 - 3.13, Django 4.2 - 5.1, Psycopg 2 - 3, and Postgres 13 - 17.



  [View the django-pghistory docs here](https://django-pghistory.readthedocs.io/) to learn more about:

  * The basics and terminology.
  * Tracking historical events on models.
  * Attaching dynamic application context to events.
  * Configuring event models.
  * Aggregating events across event models.
  * The Django admin integration.
  * Reverting models to previous versions.
  * A guide on performance and scale.

  There's also additional help, FAQ, and troubleshooting guides.



  Install `django-pghistory` with:

      pip3 install django-pghistory

  After this, add `pghistory` and `pgtrigger` to the `INSTALLED_APPS` setting of your Django project.



  There's a [DjangoCon 2023 talk](https://youtu.be/LFIAqFt9z2s?si=GQBchy9bVAk-b9ok) that walks through how the library works and provides an overview of problems that can be solved through history-tracking in Django, discussing context-tracking, event reversions, and soft-deletes.



  For information on setting up django-pghistory for development and contributing changes, view [CONTRIBUTING.md](CONTRIBUTING.md).



  - [Wes Kendall](https://github.com/wesleykendall)



  - @max-muoto
  - @shivananda-sahu
  - @asucrews
  - @Azurency
  - @dracos
  - @adamchainz
  - @eeriksp
  - @pfouque
  - @tobiasmcnulty
  - @lokhman
  - @SupImDos
  - @pmdevita
  - @pablogadhi
  - @xaitec
  - @foobarna
  - @pmdevita


pkgId: 1f75d94aed0dc632ddae14e5e7af96dead2a173001fe0bb2d7bea0b1e40cb5b6
name: python-django-pglock-help
arch: noarch
version: 1.7.1
epoch: 0
release: 1
summary: Development documents and examples for django-pglock
url: https://github.com/AmbitionEng/django-pglock
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pglock-1.7.1-1.src.rpm
location_href: Packages/python-django-pglock-help-1.7.1-1.noarch.rpm
checksum_type: sha256
description:
  `django-pglock` performs advisory locks, table locks, and helps manage blocking locks.
  Here's some of the functionality at a glance:

  * `pglock.advisory` for application-level locking, for example, ensuring that tasks don't overlap.
  * `pglock.model` for locking an entire model.
  * `pglock.timeout` for dynamically setting the timeout to acquire a lock.
  * `pglock.prioritize` to kill blocking locks for critical code, such as migrations.
  * The `PGLock` and `BlockedPGLock` models for querying active and blocked locks.
  * The `pglock` management command that wraps the models and provides other utilities.





  Use `pglock.advisory` to acquire a [Postgres advisory lock](https://www.postgresql.org/docs/current/explicit-locking.html#ADVISORY-LOCKS):

  ```python
  import pglock

  with pglock.advisory("my_lock_id"):
      
  ```

  Above our code will block until the lock is available, meaning no instances of the function will run simultaneously. Use the `timeout` argument to configure how long to wait for the lock. A timeout of zero will return immediately:

  ```python
  with pglock.advisory("my_lock_id", timeout=0) as acquired:
      if acquired:
          
  ```

  Use `side_effect=pglock.Raise` to raise a `django.db.utils.OperationalError` if the lock can't be acquired. When using the decorator, you can also use `side_effect=pglock.Skip` to skip the function if the lock can't be acquired:

  ```python
  @pglock.advisory(timeout=0, side_effect=pglock.Skip)
  def non_overlapping_func():
      
      
  ```



  `pglock.model` can take a lock on an entire model during a transaction. For example:

  ```python
  from django.db import transaction
  import pglock

  with transaction.atomic():
      pglock.model("auth.User")

      
      
  ```

  `pglock.model` uses [Postgres's LOCK statement](https://www.postgresql.org/docs/current/sql-lock.html>), and it accepts the lock mode as a argument. See the [Postgres docs for more information](https://www.postgresql.org/docs/current/sql-lock.html).

  **Note** `pglock.model` is similar to `pglock.advisory`. Use the `timeout` argument to avoid waiting for locks, and supply the appropriate `side_effect` to adjust runtime behavior.



  `pglock.prioritize` will terminate any locks blocking the wrapped code:

  ```python
  import pglock

  @pglock.prioritize()
  def my_func():
      
      
      MyModel.objects.update(val="value")
  ```

  `pglock.prioritize` is useful for prioritizing code, such as migrations, to avoid situations where locks are held for too long.



  Use `pglock.timeout` to dynamically set [Postgres's lock_timeout runtime setting](https://www.postgresql.org/docs/current/runtime-config-client.html):

  ```python
  import pglock

  @pglock.timeout(1)
  def do_stuff():
      
          
  ```



  Use `pglock.models.PGLock` to query active locks. It wraps [Postgres's pg_locks view](https://www.postgresql.org/docs/current/view-pg-locks.html). Use `pglock.models.BlockedPGLock` to query locks and join the activity that's blocking them.

  Use `python manage.py pglock` to view and kill locks from the command line. It has several options for dynamic filters and re-usable configuration.



  `django-pglock` is compatible with Python 3.9 - 3.13, Django 4.2 - 5.1, Psycopg 2 - 3, and Postgres 13 - 17.



  [View the django-pglock docs here](https://django-pglock.readthedocs.io/) to learn more about:

  * Using advisory locks.
  * Locking models.
  * Setting dynamic lock timeouts.
  * Killing blocking locks.
  * The proxy models and custom queryset methods.
  * Using and configuring the management command.



  Install `django-pglock` with:

      pip3 install django-pglock

  After this, add both `pgactivity` and `pglock` to the `INSTALLED_APPS` setting of your Django project.



  For information on setting up django-pglock for development and contributing changes, view [CONTRIBUTING.md](CONTRIBUTING.md).



  - [Wes Kendall](https://github.com/wesleykendall)
  - [Paul Gilmartin](https://github.com/PaulGilmartin)


pkgId: 30c6b31c3d57f71a87a2ecb5e97671d10de089c75dd5214621399fa627d1a5b4
name: python-django-pgmigrate-help
arch: noarch
version: 1.5.1
epoch: 0
release: 1
summary: Development documents and examples for django-pgmigrate
url: https://github.com/AmbitionEng/django-pgmigrate
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pgmigrate-1.5.1-1.src.rpm
location_href: Packages/python-django-pgmigrate-help-1.5.1-1.noarch.rpm
checksum_type: sha256
description:
  `django-pgmigrate` helps you avoid costly downtime with Postgres migrations.

  Imagine the following happens:

  1. A long-running task queries a model in a transaction and keeps the transaction open.
  2. `python manage.py migrate` tries to change a field on the model.

  Because of how Postgres queues locks, this common scenario causes **every** subsequent query on the model to block until the query from 1) has finished.

  `django-pgmigrate` provides the following features to alleviate problematic locking scenarios when running migrations:

  * Detect blocking queries and terminate them automatically (the default behavior).
  * Print blocking queries so that you can inspect and terminate them manually.
  * Set the lock timeout so that migrations are terminated if they block too long.



  Install `django-pgmigrate` with:

      pip3 install django-pgmigrate

  After this, add `pgactivity`, `pglock`, and `pgmigrate` to the `INSTALLED_APPS` setting of your Django project.



  After following the installation instructions, running `python manage.py migrate` will automatically terminate any blocking queries. Here's an example of what it looks like:

  ![Terminate Blocking](docs/static/terminate_blocking.png)

  There are two additional outputs in the `migrate` command versus the original:

  1. The first output line shows the Postgres process ID. This is useful for querying activity that's blocking the process.
  2. The yellow text shows when a blocking query was detected and terminated. In our case, it was blocking auth migration 12.

  You can configure `django-pgmigrate` to show blocked queries instead of automatically killing them, and you can also set the lock timeout to automatically cancel migrations if they block for too long. See the documentation section below for more details.



  `django-pgmigrate` is compatible with Python 3.9 - 3.13, Django 4.2 - 5.1, Psycopg 2 - 3, and Postgres 13 - 17.



  [View the django-pgmigrate docs here](https://django-pgmigrate.readthedocs.io) to learn more about:

  * How blocking queries are automatically terminated.
  * Configuring the command to show blocking activity instead of terminating it, along with instructions on how to manually view and terminate activity.
  * Configuring lock timeouts to automatically stop migrations if they block for too long.
  * Advanced usage such as creating custom actions to run when queries are blocked.



  For information on setting up django-pgmigrate for development and contributing changes, view [CONTRIBUTING.md](CONTRIBUTING.md).



  - [Wes Kendall](https://github.com/wesleykendall)
  - [Paul Gilmartin](https://github.com/PaulGilmartin)


pkgId: 1946c2462c8e288f6982dff51d23746552bf6297f0faa46c87545ef462994f88
name: python-django-pgstats-help
arch: noarch
version: 1.5.1
epoch: 0
release: 1
summary: Development documents and examples for django-pgstats
url: https://github.com/AmbitionEng/django-pgstats
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pgstats-1.5.1-1.src.rpm
location_href: Packages/python-django-pgstats-help-1.5.1-1.noarch.rpm
checksum_type: sha256
description:
  `django-pgstats` provides commands and models for tracking internal postgres stats. Specifically, the `IndexStats` model stores stats about postgres indices and the `TableStats` model stores stats about postgres tables.

  Postgres stat tables contain global statistical information. `django-pgstats` is meant to be executed periodically so that one can later analyze table and index usage. This is done by periodically calling `python manage.py snapshot_pgstats` using a task runner such as [Celery](http://www.celeryproject.org/).

  Stats are stored as JSON fields in the respective `IndexStats` and `TableStats` models. Each key in the JSON field is in the format of `{schema}.{table}` for table stats or `{schema}.{table}.{index}` for index stats.



  `django-pgstats` is compatible with Python 3.9 - 3.13, Django 4.2 - 5.1, Psycopg 2 - 3, and Postgres 13 - 17.



  [View the django-pgstats docs here](https://django-pgstats.readthedocs.io/)



  Install `django-pgstats` with:

      pip3 install django-pgstats
  After this, add `pgstats` to the `INSTALLED_APPS` setting of your Django project.



  For information on setting up django-pgstats for development and contributing changes, view [CONTRIBUTING.md](CONTRIBUTING.md).



  - @wesleykendall (Wes Kendall)
  - @tomage (Tómas Árni Jónasson)


pkgId: ac09d92072070bd5fe00abb60d5b73c8b6c963e5bc84e89c75871b31495da82b
name: python-django-pgtransaction-help
arch: noarch
version: 1.5.1
epoch: 0
release: 1
summary: Development documents and examples for django-pgtransaction
url: https://github.com/AmbitionEng/django-pgtransaction
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pgtransaction-1.5.1-1.src.rpm
location_href: Packages/python-django-pgtransaction-help-1.5.1-1.noarch.rpm
checksum_type: sha256
description:
  `django-pgtransaction` offers a drop-in replacement for the default `django.db.transaction` module which, when used on top of a PostgreSQL database, extends the functionality of that module with Postgres-specific features.

  At present, django-pgtransaction offers an extension of the `django.db.transaction.atomic` context manager/decorator which allows one to dynamically set the [isolation level](https://www.postgresql.org/docs/current/transaction-iso.html) when opening a transaction, as well as specifying a retry policy for when an operation in that transaction results in a Postgres locking exception. See the quickstart below or [the docs](https://django-pgtransaction.readthedocs.io/) for examples.



  Set the isolation level of a transaction by using `pgtransaction.atomic`:

  ```python
  import pgtransaction

  with pgtransaction.atomic(isolation_level=pgtransaction.SERIALIZABLE):
      
  ```

  There are three isolation levels: `pgtransaction.READ_COMMITTED`, `pgtransaction.REPEATABLE_READ`, and `pgtransaction.SERIALIZABLE`. By default it inherits the parent isolation level, which is Django's default of "READ COMMITTED".

  When using stricter isolation levels like `pgtransaction.SERIALIZABLE`, Postgres will throw serialization errors upon concurrent updates to rows. Use the `retry` argument with the decorator to retry these failures:

  ```python
  @pgtransaction.atomic(isolation_level=pgtransaction.SERIALIZABLE, retry=3)
  def do_queries():
      
  ```

  Note that the `retry` argument will not work when used as a context manager. A `RuntimeError` will be thrown.

  By default, retries are only performed when `psycopg.errors.SerializationError` or `psycopg.errors.DeadlockDetected` errors are raised. Configure retried psycopg errors with `settings.PGTRANSACTION_RETRY_EXCEPTIONS`. You can set a default retry amount with `settings.PGTRANSACTION_RETRY`.

  `pgtransaction.atomic` can be nested, but keep the following in mind:

  1. The isolation level cannot be changed once a query has been performed.
  2. The retry argument only works on the outermost invocation as a decorator, otherwise `RuntimeError` is raised.



  `django-pgtransaction` is compatible with Python 3.9 - 3.13, Django 4.2 - 5.1, Psycopg 2 - 3, and Postgres 13 - 17.



  Check out the [Postgres docs](https://www.postgresql.org/docs/current/transaction-iso.html) to learn about transaction isolation in Postgres.

  [View the django-pgtransaction docs here](https://django-pgtransaction.readthedocs.io/)



  Install `django-pgtransaction` with:

      pip3 install django-pgtransaction
  After this, add `pgtransaction` to the `INSTALLED_APPS` setting of your Django project.



  For information on setting up django-pgtransaction for development and contributing changes, view [CONTRIBUTING.md](CONTRIBUTING.md).



  - [Paul Gilmartin](https://github.com/PaulGilmartin)
  - [Wes Kendall](https://github.com/wesleykendall)


pkgId: 2090fde71264983ce4e408a74ae6e7b0fad75f1162a903808299444732e32449
name: python-django-pgtrigger-help
arch: noarch
version: 4.13.3
epoch: 0
release: 1
summary: Development documents and examples for django-pgtrigger
url: https://github.com/AmbitionEng/django-pgtrigger
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pgtrigger-4.13.3-1.src.rpm
location_href: Packages/python-django-pgtrigger-help-4.13.3-1.noarch.rpm
checksum_type: sha256
description:
  `django-pgtrigger` helps you write [Postgres triggers](https://www.postgresql.org/docs/current/sql-createtrigger.html) for your Django models.



  Triggers can solve a variety of complex problems more reliably, performantly, and succinctly than application code.
  For example,

  * Protecting operations on rows or columns (`pgtrigger.Protect`).
  * Making read-only models or fields (`pgtrigger.ReadOnly`).
  * Soft-deleting models (`pgtrigger.SoftDelete`).
  * Snapshotting and tracking model changes ([django-pghistory](https://django-pghistory.readthedocs.io/)).
  * Enforcing field transitions (`pgtrigger.FSM`).
  * Keeping a search vector updated for full-text search (`pgtrigger.UpdateSearchVector`).
  * Building official interfaces (e.g. enforcing use of `User.objects.create_user` and not `User.objects.create`).
  * Versioning models, mirroring fields, computing unique model hashes, and the list goes on...

  All of these examples require no overridden methods, no base models, and no signal handling.



  Install `django-pgtrigger` with `pip3 install django-pgtrigger` and add `pgtrigger` to `settings.INSTALLED_APPS`.

  `pgtrigger.Trigger` objects are added to `triggers` in model `Meta`. `django-pgtrigger` comes with several trigger classes, such as `pgtrigger.Protect`. In the following, we're protecting the model from being deleted:

  ```python
  import pgtrigger

  class ProtectedModel(models.Model):
      """This model cannot be deleted!"""

      class Meta:
          triggers = [
              pgtrigger.Protect(name="protect_deletes", operation=pgtrigger.Delete)
          ]
  ```

  When migrations are created and executed, `ProtectedModel` will raise an exception anytime a deletion is attempted.

  Let's extend this example further and only protect deletions on inactive objects. In this example, the trigger conditionally runs when the row being deleted (the `OLD` row in trigger terminology) is still active:

  ```python
  import pgtrigger

  class ProtectedModel(models.Model):
      """Active object cannot be deleted!"""
      is_active = models.BooleanField(default=True)

      class Meta:
          triggers = [
              pgtrigger.Protect(
                  name="protect_deletes",
                  operation=pgtrigger.Delete,
                  condition=pgtrigger.Q(old__is_active=True)
              )
          ]
  ```

  `django-pgtrigger` uses `pgtrigger.Q` and `pgtrigger.F` objects to conditionally execute triggers based on the `OLD` and `NEW` rows. Combining these Django idioms with `pgtrigger.Trigger` objects can solve a wide variety of problems without ever writing SQL. Users, however, can still use raw SQL for complex cases.

  Triggers are installed like other database objects. Run `python manage.py makemigrations` and `python manage.py migrate` to install triggers.

  If triggers are new to you, don't worry. The [pgtrigger docs](https://django-pgtrigger.readthedocs.io/) cover triggers in more detail and provide many examples.



  `django-pgtrigger` is compatible with Python 3.9 - 3.13, Django 4.2 - 5.1, Psycopg 2 - 3, and Postgres 13 - 17.



  [View the django-pgtrigger docs here](https://django-pgtrigger.readthedocs.io/) to learn more about:

  * Trigger basics and motivation for using triggers.
  * How to use the built-in triggers and how to build custom ones.
  * Installing triggers on third-party models, many-to-many fields, and other advanced scenarios.
  * Writing conditional triggers.
  * Ignoring triggers dynamically and deferring trigger execution.
  * Multiple database, schema, and partitioning support.
  * Frequently asked questions, common issues, and upgrading.
  * The commands, settings, and module.



  Install `django-pgtrigger` with:

      pip3 install django-pgtrigger
  After this, add `pgtrigger` to the `INSTALLED_APPS` setting of your Django project.



  After you've read the docs, check out [this tutorial](https://wesleykendall.github.io/django-pgtrigger-tutorial/) with interactive examples from a Django meetup talk.

  The [DjangoCon 2021 talk](https://www.youtube.com/watch?v=Tte3d4JjxCk) also breaks down triggers and shows several examples.



  For information on setting up django-pgtrigger for development and contributing changes, view [CONTRIBUTING.md](CONTRIBUTING.md).



  - [Wes Kendall](https://github.com/wesleykendall)



  - @jzmiller1
  - @rrauenza
  - @ralokt
  - @adamchainz
  - @danifus
  - @kekekekule
  - @peterthomassen
  - @pfouque


pkgId: 547fc2104a13ae9c52e20f690a4a507e7844dc19a4c151a30efecf7d0cbdc99c
name: python-django-pictures-help
arch: noarch
version: 1.3.4
epoch: 0
release: 1
summary: Development documents and examples for django-pictures
url: https://pypi.org/project/django-pictures/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pictures-1.3.4-1.src.rpm
location_href: Packages/python-django-pictures-help-1.3.4-1.noarch.rpm
checksum_type: sha256
description:
  ![Django Pictures Logo](https://repository-images.githubusercontent.com/455480246/daaa7870-d28c-4fce-8296-d3e3af487a64)



  Responsive cross-browser image library using modern codes like AVIF & WebP.

  * responsive web images using the [picture](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/picture) tag
  * native grid system support
  * serve files with or without a CDN
  * placeholders for local development
  * migration support
  * async image processing for [Celery], [Dramatiq] or [Django RQ][django-rq]
  * [DRF] support

  [![PyPi Version](https://img.shields.io/pypi/v/django-pictures.svg)](https://pypi.python.org/pypi/django-pictures/)
  [![Test Coverage](https://codecov.io/gh/codingjoe/django-pictures/branch/main/graph/badge.svg)](https://codecov.io/gh/codingjoe/django-pictures)
  [![GitHub License](https://img.shields.io/github/license/codingjoe/django-pictures)](https://raw.githubusercontent.com/codingjoe/django-pictures/master/LICENSE)



  Before you start, it can be a good idea to understand the fundamentals of
  [responsive images](https://developer.mozilla.org/en-US/docs/Learn/HTML/Multimedia_and_embedding/Responsive_images).

  Once you get a feeling how complicated things can get with all device types, you'll probably find
  a new appreciation for this package and are ready to adopt in you project :)

  ```python

  from django.db import models
  from pictures.models import PictureField

  class Profile(models.Model):
      title = models.CharField(max_length=255)
      picture = PictureField(upload_to="avatars")
  ```

  ```html
  <!-- template.html -->
  {% load pictures %}
  {% picture profile.picture img_alt="Spiderman" img_loading="lazy" picture_class="my-picture" m=6 l=4 %}
  ```

  The keyword arguments `m=6 l=4` define the columns the image should take up in
  a grid  at a given breakpoint. So in this example, the image will take up
  6 columns on medium screens and 4 columns on large screens. You can define your
  grid and breakpoints as you want, refer to the [grid columns](#grid-columns) and
  [breakpoints](#breakpoints) sections.

  The template above will render into:
  ```html
  <picture class="my-picture">
    <source type="image/webp"
            srcset="/media/testapp/profile/image/800w.webp 800w, /media/testapp/profile/image/100w.webp 100w, /media/testapp/profile/image/200w.webp 200w, /media/testapp/profile/image/300w.webp 300w, /media/testapp/profile/image/400w.webp 400w, /media/testapp/profile/image/500w.webp 500w, /media/testapp/profile/image/600w.webp 600w, /media/testapp/profile/image/700w.webp 700w"
            sizes="(min-width: 0px) and (max-width: 991px) 100vw, (min-width: 992px) and (max-width: 1199px) 33vw, 600px">
    <img src="/media/testapp/profile/image.jpg" alt="Spiderman" width="800" height="800" loading="lazy">
  </picture>
  ```

  Note that arbitrary attributes can be passed
  to either the `<picture>` or `<img>` element
  by prefixing parameters to the `{% picture %}` tag
  with `picture_` or `img_` respectively.





  ```shell
  python3 -m pip install django-pictures
  ```



  ```python

  INSTALLED_APPS = [
      
      'pictures',
  ]


  PICTURES = {
      "BREAKPOINTS": {
          "xs": 576,
          "s": 768,
          "m": 992,
          "l": 1200,
          "xl": 1400,
      },
      "GRID_COLUMNS": 12,
      "CONTAINER_WIDTH": 1200,
      "FILE_TYPES": ["WEBP"],
      "PIXEL_DENSITIES": [1, 2],
      "USE_PLACEHOLDERS": True,
      "QUEUE_NAME": "pictures",
      "PROCESSOR": "pictures.tasks.process_picture",

  }
  ```

  If you have either Dramatiq or Celery installed, we will default to async
  image processing. You will need workers to listen to the `pictures` queue.



  This library comes with dynamically created placeholders to simplify local
  development. To enable them, add the following to enable the
  `PICTURES["USE_PLACEHOLDERS"]` setting and add the following URL configuration:

  ```python

  from django.urls import include, path
  from pictures.conf import get_settings

  urlpatterns = [
      
  ]

  if get_settings().USE_PLACEHOLDERS:
      urlpatterns += [
          path("_pictures/", include("pictures.urls")),
      ]
  ```



  Although the `picture`-tag is [adequate for most use-cases][caniuse-picture],
  some remain, where a single `img` tag is necessary. Notably in email, where
  [most clients do support WebP][caniemail-webp] but not [srcset][caniemail-srcset].
  The template tag `img_url` returns a single size image URL.
  In addition to the ratio you will need to define the `file_type`
  as well as the `width` (absolute width in pixels).


  ```html
  {% load pictures %}
  <img src="{% img_url profile.picture ratio="3/2" file_type="webp" width=800 %}" alt="profile picture">
  ```

  [caniuse-picture]: https://caniuse.com/picture
  [caniemail-webp]: https://www.caniemail.com/features/image-webp/
  [caniemail-srcset]: https://www.caniemail.com/features/html-srcset/





  You can specify the aspect ratios of your images. Images will be cropped to the
  specified aspect ratio. Aspect ratios are specified as a string with a slash
  between the width and height. For example, `16/9` will crop the image to 16:9.

  ```python

  from django.db import models
  from pictures.models import PictureField


  class Profile(models.Model):
      title = models.CharField(max_length=255)
      picture = PictureField(
        upload_to="avatars",
        aspect_ratios=[None, "1/1", "3/2", "16/9"],
      )
  ```

  ```html

  {% load pictures %}
  {% picture profile.picture img_alt="Spiderman" ratio="16/9" m=6 l=4 %}
  ```

  If you don't specify an aspect ratio or None in your template, the image will be
  served with the original aspect ratio of the file.

  You may only use aspect ratios in templates, that have been defined on the model.
  The model `aspect_ratios` will default to `[None]`, if other value is provided.



  You may define your own breakpoints, they should be identical to the ones used
  in your css library. Simply override the `PICTURES["BREAKPOINTS"]` setting.



  Grids are so common in web design, that they even made it into CSS.
  We default to 12 columns, but you can override this setting, via the
  `PICTURES["GRID_COLUMNS"]` setting.



  Containers are commonly used to limit the maximum width of layouts,
  to promote better readability on larger screens. We default to `1200px`,
  but you can override this setting, via the `PICTURES["CONTAINER_WIDTH"]` setting.

  You may also set it to `None`, should you not use a container.



  Unless you still services IE11 clients, you should be fine serving just
  [WebP](https://caniuse.com/webp). Sadly, [AVIF](https://caniuse.com/avif)
  (WebP's successor) is
  [not yet supported by Pillow](https://github.com/python-pillow/Pillow/pull/5201).

  If you are serving IE11 use add `JPEG` to the list. Beware though, that this may
  drastically increase you storage needs.



  Unless you really care that your images hold of if you hold your UHD phone very
  close to your eyeballs, you should be fine, serving at the default `1x` and `2x`
  densities.



  If you have either Dramatiq or Celery installed, we will default to async
  image processing. You will need workers to listen to the `pictures` queue.
  You can override the queue name, via the `PICTURES["QUEUE_NAME"]` setting.

  You can also override the processor, via the `PICTURES["PROCESSOR"]` setting.
  The default processor is `pictures.tasks.process_picture`. It takes a single
  argument, the `PictureFileFile` instance. You can use this to override the
  processor, should you need to do some custom processing.



  Django doesn't support file field migrations, but we do.
  You can simply auto create the migration and replace Django's
  `AlterField` operation with `AlterPictureField`. That's it.

  You can follow [the example][migration] in our test app, to see how it works.

  [migration]: tests/testapp/migrations/0002_alter_profile_picture.py





  We do ship with a read-only `PictureField` that can be used to include all
  available picture sizes in a DRF serializer.

  ```python
  from rest_framework import serializers
  from pictures.contrib.rest_framework import PictureField

  class PictureSerializer(serializers.Serializer):
      picture = PictureField()
  ```

  The response can be restricted to a fewer aspect ratios and file types, by
  providing the `aspect_ratios` and `file_types` arguments to the DRF field.

  ```python
  from rest_framework import serializers
  from pictures.contrib.rest_framework import PictureField

  class PictureSerializer(serializers.Serializer):
      picture = PictureField(aspect_ratios=["16/9"], file_types=["WEBP"])
  ```

  You also may provide optional GET parameters to the serializer,
  to specify the aspect ratio and breakpoints you want to include in the response.
  The parameters are prefixed with the `fieldname_`
  to avoid conflicts with other fields.

  ```bash
  curl http://localhost:8000/api/path/?picture_ratio=16%2F9&picture_m=6&picture_l=4

  ```

  ```json
  {
    "other_fields": "…",
    "picture": {
      "url": "/path/to/image.jpg",
      "width": 800,
      "height": 800,
      "ratios": {
        "1/1": {
          "sources": {
            "image/webp": {
              "100": "/path/to/image/1/100w.webp",
              "200": "…"
            }
          },
          "media": "(min-width: 0px) and (max-width: 991px) 100vw, (min-width: 992px) and (max-width: 1199px) 33vw, 25vw"
        }
      }
    }
  }
  ```

  Note that the `media` keys are only included, if you have specified breakpoints.



  `PictureField` is compatible with [Django Cleanup](https://github.com/un1t/django-cleanup),
  which automatically deletes its file and corresponding `SimplePicture` files.

  [drf]: https://www.django-rest-framework.org/
  [celery]: https://docs.celeryproject.org/en/stable/
  [dramatiq]: https://dramatiq.io/
  [django-rq]: https://github.com/rq/django-rq


pkgId: 20d76bde393ad7b41a7b0fd67470e96ea97b4b3e66b789892b04bda849e00472
name: python-django-query-to-table-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for django-query-to-table
url: https://github.com/birddevelper/django-query-to-table
rpm_license: GNU
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-query-to-table-1.0.0-1.src.rpm
location_href: Packages/python-django-query-to-table-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/personalized-badge/django-query-to-table?period=total&units=international_system&left_color=black&right_color=green&left_text=Downloads)](https://pepy.tech/project/django-query-to-table)



  You can read more about this package here : [django query to table package](https://mshaeri.com/blog/generate-html-table-report-from-sql-query-in-django/)

  The package contains two functions named:
  - **generate_from_sql**: Generate HTML table by given SQL query
  - **generate_from_queryset**:Generate HTML table by given Django queryset

  Parameters:

  * title : The title of the report that will be shown on top of table
  * sqltext/queryset : The sql select query to retrieve data / django queryset
  * footerCols : A list of columns name that you want to have Sum of values on footer . Example : ['amount','price']
  * htmlClass : Html CSS classes for the table
  * direction (default = "ltr") : Indicates direction of the report page.  "ltr"- Left to Right , "rtl" -  Right to Left
  * font (default = "Tahoma") : Font of title and table contents
  * totalText (default = "Total") : Title of footer row that will be the put below the first column.
  * rowIndex (default = False) : Indicates whether the table should have index column or not.
  * headerRowColor (default = '#eeeeee') :  The header (title) row background color.
  * evenRowColor (default = '#ffffff') :  The even rows background color.
  * oddRowColor (default = '#ffffff') :  The odd rows background color.




  Run following command to install DjangoQtt :

  ```shell
  pip install django-query-to-table
  ```



  - Generate HTML table by SQL query:

  ```python
  from django_query_to_table import DjangoQtt
  from django.http import HttpResponse


  def listOfPersons(request):
    reportTitle = "Employee List"
    sqlQuery = "SELECT FirstName as 'First Name', LastName as 'Last Name', phone as 'Phone Number', salary as 'Salary' FROM persons"
    columnsToBeSummarized = ['Salary']
    fontName = "Arial"
    cssClasses = "reportTable container"
    headerRowBackgroundColor = '#ffeeee'
    evenRowsBackgroundColor = '#ffeeff'
    oddRowsBackgroundColor = '#ffffff'
    rowIndexVisibility = True
    table = DjangoQtt.generate_from_sql(reportTitle, sqlQuery, columnsToBeSummarized, cssClasses,
                                    "ltr", fontName, "Total Salary", rowIndexVisibility,
                                    headerRowBackgroundColor, evenRowsBackgroundColor, oddRowsBackgroundColor
                                    )

    
    return HttpResponse(table)

   ```

  - Generate HTML table from querset:

  ```python
  from django_query_to_table import DjangoQtt
  from django.http import HttpResponse
  from .models import Order

  def listOfPersons(request):

    order_queryset = Order.objects.all().values("customer", "product", "amount")
    reportTitle = "Order List"
    columnsToBeSummarized = ['amount']
    fontName = "Arial"
    cssClasses = "reportTable container"
    headerRowBackgroundColor = '#ffeeee'
    evenRowsBackgroundColor = '#ffeeff'
    oddRowsBackgroundColor = '#ffffff'
    rowIndexVisibility = True
    table = DjangoQtt.generate_from_queryset(reportTitle, order_queryset, columnsToBeSummarized, cssClasses,
                                    "ltr", fontName, "Total amount", rowIndexVisibility,
                                    headerRowBackgroundColor, evenRowsBackgroundColor, oddRowsBackgroundColor
                                    )

    
    return HttpResponse(table)

   ```


pkgId: cdf2f9a026ab56eb3c348556b024c3a888a5ad9fe59ec447105890b2b0b70af1
name: python-django-queryhunter-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for django-queryhunter
url: https://github.com/PaulGilmartin/django-queryhunter
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-queryhunter-1.0.0-1.src.rpm
location_href: Packages/python-django-queryhunter-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Line no: 13 | Code: for post in posts: | Num. Queries: 1 | SQL: SELECT "tests_post"."id", "tests_post"."content", "tests_post"."author_id" FROM "tests_post" | Duration: 4.783299999999713e-05
  Line no: 14 | Code: authors.append(post.author.name) | Num. Queries: 5 | SQL: SELECT "tests_author"."id", "tests_author"."name" FROM "tests_author" WHERE "tests_author"."id" = %s LIMIT 21 | Duration: 8.804199999801199e-05
  ```

  *queryhunter* is lightweight enough to have enabled in production and
  its profiling will have negligible effect on performance. Having it
  continually enabled in production means we can use it as a monitoring tool,
  quickly alerting the developer to any new bottlenecks accidentally introduced.
  We have used this on a production code base and environment and it
  has outperformed similar libraries in diagnosing certain kinds of performance issues.
  We have found that it is adept in identifying missing `select_related` and `prefetch_related` calls in production code.

  ```bash
  pip install django-queryhunter
  ```
  You must then declare the `QUERYHUNTER_BASE_DIR` setting in your settings.py file. This is
  the way that queryhunter knows where to look for your application code (or rather, the point in the stack
  at which to report as being responsible for executing a query).
  You can use the built-in callable `queryhunter.default_base_dir` to set it to be the project root or
  make it a string of your choosing.
  ```python
  import queryhunter
  QUERYHUNTER_BASE_DIR = queryhunter.default_base_dir(__file__)
  ```

  Let's suppose we have a Django application with the following models (a fully functional example can be found in the
  `queryhunter.tests` directory):
  ```python

  from django.db import models
  class Author(models.Model):
      name = models.CharField(max_length=100)
  class Post(models.Model):
      content = models.CharField(max_length=100)
      author = models.ForeignKey(Author, on_delete=models.CASCADE)
  ```
  Now suppose we have another module my_module.py where we fetch our posts and collect their author's names
  in a list. We run this code under the `queryhunter` context manager, which will collect information on the
  lines of code responsible for executing SQL queries inside the context:
  ```python

  from queryhunter.tests.models import Post, Author
  from queryhunter import queryhunter
  def get_authors() -> list[Author]:
      with queryhunter():
          authors = []
          posts = Post.objects.all()  # suppose we have 5 posts
          for post in posts:
              authors.append(post.author.name)
      return authors
  ```
  Let's now run the code
  ```python
  >>> from queryhunter.tests.my_module import get_authors
  >>> get_authors()
  ```
  and see what the output from the queryhunter is:
  ```bash


pkgId: 53f0b91a9e2d32f97be9ebda89299a38f53ebabb6480a9dd2ca5db675e08265b
name: python-django-rbaca-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for django-rbaca
url: https://pypi.org/project/django-rbaca/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-rbaca-1.1.0-1.src.rpm
location_href: Packages/python-django-rbaca-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  <a name="readme-top"></a>

  <br />
  <div align="center">
    <a href="https://github.com/MickaelCormier/django-rbaca/blob/main/assets/rbaca_logo.jpg">
      <img src="assets/rbaca_logo.jpg" alt="Logo" width="80" height="80">
    </a>

  <h3 align="center">django-rbaca</h3>

    <p align="center">
      Role-based Access Control with Attributes for distributed Django projects.
      <br />
    </p>
  </div>


  Welcome to Role-Based Access Control with Attributes for distributed Django projects!

  This project provides a secure and scalable solution for access control in Django applications. It extends the traditional role-based access control (RBAC) model with attributes to offer finer-grained control over resource access. The implementation is designed to allow decentralized nodes to have access to resources controlled by a central endpoint.

  The project offers a Django app for easy integration into existing projects. It includes models for defining roles, attributes, access control policies, as well as an authorization backend for enforcing access control rules. The app also features an API for querying the access control system.


  - **Role-based access control**: Users are assigned roles that define their access to resources.
  - **Attribute-based access control**: Attributes are assigned to resources and users for finer-grained control over access.
  - **Access control API for external nodes**: Centralized access control interface for decentralized nodes.
  - **Easy integration**: The Django app is designed for seamless integration into existing projects.



  **Using pip (from PyPI):**

  ```bash
  pip install django-rbaca
  ```

  **Using poetry (local development):**

  1. Clone the repository:

  ```bash
  git clone https://github.com/MickaelCormier/django-rbaca
  ```

  2. Navigate to the project directory:

  ```bash
  cd django-rbaca
  ```

  3. Install dependencies:

  ```bash
  poetry install
  ```


  For more detailed information, including prerequisites, configuration, and usage examples, please refer to the [documentation](url).


  If you find this project useful in your research, please consider cite:

  ```bash
  @misc{django-rbaca,
      title={django-rbaca: Roll-based Access Control with Attributes for distributed Django projects.},
      author={Bruch, Steven and Cormier, Mickael},
      howpublished = {\url{https://github.com/MickaelCormier/django-rbaca/}},
      year={2024}
  }
  ```

  <p align="right">(<a href="#readme-top">back to top</a>)</p>


pkgId: 97e628e70d11335a23829bfa4e1f24ed4bfa2c06a692af203e18e1c0f76423ca
name: python-django-request-approval-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for django-request-approval
url: https://github.com/briansimpo/django-request-approval
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-request-approval-1.0.1-1.src.rpm
location_href: Packages/python-django-request-approval-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  This is a package of base classes for approval process.
  To use this package, you have to create classes that inherit base classes from this package.
  Detailed documentation is in the "docs" directory.



  1. Add `django_request_approval` to your INSTALLED_APPS setting like this::

  ```python

      INSTALLED_APPS = [
          ...,
          "django_request_approval",
      ]

  ```






  The package contains 4 base classes
  1. BaseStage -> Represents Approval Stages (Stage 1, Stage 2, Stage 3)
  2. BaseApprover -> Represents Stage Approver (Stage, User Group)
  3. BaseRequest -> Represents the Request to be approved
  4. BaseApproval -> Represents the actual Approval made by Approver


pkgId: 5339b4fe62a235d5c491440f56dc2a483d7c6fe059e96be506745df937314166
name: python-django-restit-help
arch: noarch
version: 4.2.164
epoch: 0
release: 1
summary: Development documents and examples for django-restit
url: https://pypi.org/project/django-restit/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-restit-4.2.164-1.src.rpm
location_href: Packages/python-django-restit-help-4.2.164-1.noarch.rpm
checksum_type: sha256
description:
  1. Install framework

  2. Add "restit" to DJANGO apps.

  3. Add "middleware"

      'rest.middleware.SessionMiddleware',
          'rest.middleware.GlobalRequestMiddleware',
          'rest.middleware.CorsMiddleware',

  4. add url(r'^rpc/', include('rest.urls')) to your urlpatterns in urls.py



  This framework makes it easy to build a rest framework to use with any web or applicaiton development.

  You can take any model and turn them into a REST Model by inheriting from RestModel.

  ```python
  class ExampleTODO(models.Model, RestModel):
      your standard django fields
    ...
  ```



  Next in your DJANGO app create a "rpc.py" file.

  ```python

  @rd.url('todo')
  @rd.url('todo/<int:pk>')
  @login_required
  def on_rest_todo(request, pk=None):
      return ExampleTODO.on_rest_request(request, pk)
  ```

  This will give you a full rest interface into your Django model.





  This framework is pretty powerful and allow you to define how you want to return your model objects, and how deep!

  ```python
  class ExampleTODO(models.Model, RestModel):
      class RestMeta:
          GRAPHS = {
              "default": {
          "exclude":["priority"],
                  "graphs":{
                      "user":"default"
                  }
              },
              "list": {
          "fields":["id", "name", "priority"]
              }
          }
      user = models.ForeignKey(User, related_name="+")
    name = models.CharField(max_length=80)
    description = models.TextField(max_length=80)
    priority = models.IntegerField(default=0)
  ```

  Above you can we we can define "graphs" that let us control what is returned.

  So if we go to http://localhost:8000/rpc/rest_example/todo it will default to the "list" graph and return something that looks like...

  ```json
  {
      "status": true,
      "size": 25,
      "count": 2,
      "data": [
          {
              "id": 1,
              "name": "test 1",
              "priority": 1,
        "user": 21
          },
          {
              "id": 2,
              "name": "test 2",
              "priority": 1,
        "user": 21
          },
      ]
  }
  ```



  So if we go to http://localhost:8000/rpc/rest_example/todo?graph=default

  ```json
  {
      "status": true,
      "size": 25,
      "count": 2,
      "data": [
          {
              "id": 1,
              "name": "test 1",
              "description": "this is test 1",
        "user": {
          "id": 21,
          "username": "jsmith",
          "display_name": "TEST USER 5",
          "avatar": "http://localhost:8000/media/ax1fg.png"
        }
          },
          {
              "id": 2,
              "name": "test 2",
              "description": "this is test 2",
        "user": {
          "id": 21,
          "username": "jsmith",
          "display_name": "TEST USER 5",
          "avatar": "http://localhost:8000/media/ax1fg.png"
        }
          },
      ]
  }
  ```









  The RestModel Class is a helper class that helps existing models adapt to the REST framework.  It is not required but highly recommended.



  Key methods you can override

  ```
      def on_rest_get(self, request):
          
          return self.restGet(request, graph)

      def on_rest_post(self, request):
          
          return self.restGet(request, graph)

      def on_rest_pre_save(self, request):
          
          pass

      def on_rest_created(self, request):
          
          pass

      def on_rest_saved(self, request):
          
          pass

      def on_rest_delete(self, request):
          can_delete = getattr(self.RestMeta, "CAN_DELETE", False)
          if not can_delete:
              return self.restStatus(request, False, error="deletion not allowed via rest for this model.")
          self.delete()
          return GRAPH_HELPERS.restStatus(request, True)

      @classmethod
      def onRestCanSave(cls, request):
          
          return True

      @classmethod
      def on_rest_list_filter(cls, request, qset):
          
          
          return qset

      @classmethod
      def on_rest_list(cls, request, qset=None):
          
          return cls.restList(request, qset)

      @classmethod
      def on_rest_create(cls, request, pk=None):
          obj = cls.createFromRequest(request)
          return obj.restGet(request)
  ```





  `createFromRequest(request, **kwargs)` - this allows you to pass a request object (normally a post) and create a new model from that request.  You can also pass in any override fields after the request.

  ```
      MyModel.createFromRequest(request, owner=request.user)
  ```

  `saveFromRequest(request, **kwargs)` - this allows you to pass a request object (normally a post) and save data to the model from that request.  You can also pass in any override fields after the request.

  ```
      mode_instance.saveFromRequest(request, modified_by=request.user)
  ```



  `getFromRequest(cls, model_name)` - @classmethod - attempts to get the model instance from a request, check for the classname and classname+ "_id" in the REQUEST params.


  `restGetModel(app_name, model_name)` - @staticmethod - grab Model class by app and model name.

  `restGetGenericModel(self, fieldname)` - grab Model class by app and model name.

  `restGetGenericRelation(self, fieldname)` - grab Model class by app and model name.



  Graphs can easily be built automatically from your models by setting the appropriate RestMeta properties.

  `getGraph(name)` - @classmethod - Specify the name of the graph you want to return.



  This is a Property class you add to your models to define your graphs.

  By default a graph will return just the fields with no recurse into of Foreign models.


pkgId: df945621c466a7ace7d69140ac5ca884972372c721e8c534add25fe138672a6c
name: python-django-rudra-log-help
arch: noarch
version: 0.5.2
epoch: 0
release: 1
summary: Development documents and examples for django-rudra-log
url: https://github.com/Rudra370
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-rudra-log-0.5.2-1.src.rpm
location_href: Packages/python-django-rudra-log-help-0.5.2-1.noarch.rpm
checksum_type: sha256
description:
  1. update version in setup.cfg
  2. build command = py -m build
  3. publish command = py -m twine upload --repository pypi dist/*


pkgId: 1fe37834d7a6182e1a2c7da799f0b484239bf4c280a1f37746205cb53531524c
name: python-django-sage-language-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for django-sage-language
url: https://pypi.org/project/django-sage-language/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-sage-language-0.1.1-1.src.rpm
location_href: Packages/python-django-sage-language-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  This Django project provides middleware and utility classes to support multilingual applications through URL prefixes and cookies for language settings. The core feature is a custom `CookieLocaleMiddleware`, which dynamically manages user language preferences and redirects users to the appropriate language version of the site based on URL paths or cookies.



  - **Dynamic Language Detection**: Determines the preferred language by examining URL prefixes and cookies.
  - **Custom Middleware**: `CookieLocaleMiddleware` extends Django's default `LocaleMiddleware`, enhancing support for multilingual content.
  - **URL Prefix Management**: Utilities to add or remove language prefixes in URLs, supporting a clean and consistent URL structure.
  - **Customizable Language Settings**: Integrates with Django's internationalization settings (`LANGUAGES`, `LANGUAGE_CODE`, etc.) for easy customization.
  - **Error Checking**: Ensures proper configuration of language settings and middleware placement.



  - `middlewares/cookie.py`: Contains `CookieLocaleMiddleware` to manage language preferences dynamically.
  - `utils/locale.py`: Provides `MultilingualService`, a utility class for adding and removing language prefixes in URLs.
  - `views/locale.py`: Implements `SetLanguageView`, allowing users to set their preferred language through a POST request.
  - `checks.py`: Validates the configuration of middleware, language settings, and cookies.
  - `settings.py`: Configures Django's settings, including `LANGUAGES`, `LANGUAGE_CODE`, and middleware setup.
  - `urls.py`: Configures routes for language switching and i18n patterns.





  1. **Create a Virtual Environment**:
      ```bash
      python -m venv .venv
      ```

  2. **Activate the Virtual Environment**:
      - On Windows:
          ```bash
          .venv\Scripts\activate
          ```
      - On macOS and Linux:
          ```bash
          source .venv/bin/activate
          ```

  3. **Install the Package**:
      ```bash
      pip install python-sage-bbb
      ```



  1. **Install Poetry**: Follow the official installation instructions at the [Poetry website](https://python-poetry.org/docs/#installation).

  2. **Create a New Project (Optional)**:
      ```bash
      poetry new myproject
      cd myproject
      ```

  3. **Add the Package as a Dependency**:
      ```bash
      poetry add python-sage-bbb
      ```

  4. **Activate the Virtual Environment**:
      ```bash
      poetry shell
      ```



  1. **Add `sage_language` to `INSTALLED_APPS`** in `settings.py`:
     ```python
     INSTALLED_APPS = [
         ...
         'sage_language',
     ]
     ```

  2. **Middleware Configuration**:
     Ensure `CookieLocaleMiddleware` is added immediately after `SessionMiddleware` in the `MIDDLEWARE` setting:
     ```python
     MIDDLEWARE = [
         'django.middleware.security.SecurityMiddleware',
         'django.contrib.sessions.middleware.SessionMiddleware',
         'sage_language.middlewares.cookie.CookieLocaleMiddleware',
         ...
     ]
     ```

  3. **Set Language Settings**:
     Define supported languages, default language, and cookie names:
     ```python
     LANGUAGES = [
         ('en', 'English'),
         ('fa', 'Farsi'),
         ('es', 'Spanish'),
     ]
     LANGUAGE_CODE = 'en'
     SAGE_LANGUAGE_COOKIE_NAME = "ivan_language"
     LANGUAGE_COOKIE_NAME = SAGE_LANGUAGE_COOKIE_NAME
     ```

  4. **Add URL Configuration for Language Switching**:
     In `urls.py`, set up the language switching view:
     ```python
     from sage_language.views import SetLanguageView
     urlpatterns = [
         path('set-language/', SetLanguageView.as_view(), name='set_language'),
         path("i18n/", include("django.conf.urls.i18n")),
     ]
     ```



  1. **Setting Language Preference**:
     To change the language preference, make a POST request to `/set-language/` with `language` and `next` parameters:
     - `language`: The desired language code (e.g., 'en', 'fa', 'es').
     - `next`: The URL to redirect to after setting the language.

  2. **URL Prefix Management**:
     The middleware automatically adds or removes language prefixes from URLs based on the user’s selected language and cookie settings.

  3. **Automatic Language Redirection**:
     If a user’s preferred language (stored in a cookie) differs from the language in the URL, the middleware will redirect them to the correct URL.



  - Make sure to set `USE_I18N`, `USE_L10N`, and `USE_TZ` to `True` in `settings.py` for proper internationalization support.
  - For production use, ensure `SAGE_LANGUAGE_COOKIE_NAME` and `LANGUAGE_COOKIE_NAME` are set to the same value for consistent cookie management.


pkgId: 34be9643415d8cb943ad169d8e67b897748dce72074fdeb3378ed8709302943e
name: python-django-setup-configuration-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for django-setup-configuration
url: https://github.com/maykinmedia/django-setup-configuration
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-setup-configuration-0.5.0-1.src.rpm
location_href: Packages/python-django-setup-configuration-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  |build-status| |code-quality| |black| |coverage| |docs|
  |python-versions| |django-versions| |pypi-version|
  Manage your configuration via django command.

rpm_license:
  Copyright 2024 Maykin Media  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: 3fa187c25f4651b30618da270733944228b412f82c9f6ded5ab9529bc0bc2c54
name: python-django-silk-help
arch: noarch
version: 5.3.2
epoch: 0
release: 1
summary: Development documents and examples for django-silk
url: https://github.com/jazzband/django-silk
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-silk-5.3.2-1.src.rpm
location_href: Packages/python-django-silk-help-5.3.2-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub Actions](https://github.com/jazzband/django-silk/workflows/Test/badge.svg)](https://github.com/jazzband/django-silk/actions)
  [![GitHub Actions](https://codecov.io/gh/jazzband/django-silk/branch/master/graph/badge.svg)](https://codecov.io/gh/jazzband/django-silk)
  [![PyPI Download](https://img.shields.io/pypi/v/django-silk.svg)](https://pypi.python.org/pypi/django-silk)
  [![PyPI Python Versions](https://img.shields.io/pypi/pyversions/django-silk.svg)](https://pypi.python.org/pypi/django-silk)
  [![Supported Django versions](https://img.shields.io/pypi/djversions/django-silk.svg)](https://pypi.python.org/pypi/django-silk)
  [![Jazzband](https://jazzband.co/static/img/badge.svg)](https://jazzband.co/)

  Silk is a live profiling and inspection tool for the Django framework. Silk intercepts and stores HTTP requests and database queries before presenting them in a user interface for further inspection:

  <img src="https://raw.githubusercontent.com/jazzband/django-silk/master/screenshots/1.png" width="720px"/>



  * [Requirements](#requirements)
  * [Installation](#installation)
  * [Features](#features)
  * [Configuration](#configuration)
    * [Authentication/Authorisation](#authenticationauthorisation)
    * [Request/Response bodies](#requestresponse-bodies)
    * [Meta-Profiling](#meta-profiling)
    * [Recording a fraction of requests](#recording-a-fraction-of-requests)
    * [Limiting request/response data](#limiting-requestresponse-data)
    * [Clearing logged data](#clearing-logged-data)
  * [Contributing](#contributing)
    * [Development Environment](#development-environment)



  Silk has been tested with:

  * Django: 4.2, 5.0, 5.1
  * Python: 3.9, 3.10, 3.11, 3.12, 3.13



  Via pip into a `virtualenv`:

  ```bash
  pip install django-silk
  ```

  In `settings.py` add the following:

  ```python
  MIDDLEWARE = [
      ...
      'silk.middleware.SilkyMiddleware',
      ...
  ]

  INSTALLED_APPS = (
      ...
      'silk'
  )
  ```

  **Note:** The order of middleware is sensitive. If any middleware placed before `silk.middleware.SilkyMiddleware` returns a response without invoking its `get_response`, the `SilkyMiddleware` won’t run. To avoid this, ensure that middleware preceding `SilkyMiddleware` does not bypass or return a response without calling its `get_response`. For further details, check out the [Django documentation](https://docs.djangoproject.com/en/dev/topics/http/middleware/#middleware-order-and-layering).

  **Note:** If you are using `django.middleware.gzip.GZipMiddleware`, place that **before** `silk.middleware.SilkyMiddleware`, otherwise you will get an encoding error.

  If you want to use custom middleware, for example you developed the subclass of `silk.middleware.SilkyMiddleware`, so you can use this combination of settings:

  ```python

  SILKY_MIDDLEWARE_CLASS = 'path.to.your.middleware.MyCustomSilkyMiddleware'


  MIDDLEWARE = [
      ...
      SILKY_MIDDLEWARE_CLASS,
      ...
  ]
  ```

  To enable access to the user interface add the following to your `urls.py`:

  ```python
  urlpatterns += [path('silk/', include('silk.urls', namespace='silk'))]
  ```

  before running migrate:

  ```bash
  python manage.py migrate

  python manage.py collectstatic
  ```


  Silk will automatically begin interception of requests and you can proceed to add profiling
  if required. The UI can be reached at `/silk/`



  Via [github tags](https://github.com/jazzband/django-silk/releases):

  ```bash
  pip install https://github.com/jazzband/silk/archive/<version>.tar.gz
  ```

  You can install from master using the following, but please be aware that the version in master
  may not be working for all versions specified in [requirements](#requirements)

  ```bash
  pip install -e git+https://github.com/jazzband/django-silk.git#egg=django-silk
  ```



  Silk primarily consists of:

  * Middleware for intercepting Requests/Responses
  * A wrapper around SQL execution for profiling of database queries
  * A context manager/decorator for profiling blocks of code and functions either manually or dynamically.
  * A user interface for inspection and visualisation of the above.



  The Silk middleware intercepts and stores requests and responses in the configured database.
  These requests can then be filtered and inspecting using Silk's UI through the request overview:

  <img src="https://raw.githubusercontent.com/jazzband/django-silk/master/screenshots/1.png" width="720px"/>

  It records things like:

  * Time taken
  * Num. queries
  * Time spent on queries
  * Request/Response headers
  * Request/Response bodies

  and so on.

  Further details on each request are also available by clicking the relevant request:

  <img src="https://raw.githubusercontent.com/jazzband/django-silk/master/screenshots/2.png" width="720px"/>



  Silk also intercepts SQL queries that are generated by each request. We can get a summary on things like
  the tables involved, number of joins and execution time (the table can be sorted by clicking on a column header):

  <img src="https://raw.githubusercontent.com/jazzband/django-silk/master/screenshots/3.png" width="720px"/>

  Before diving into the stack trace to figure out where this request is coming from:

  <img src="https://raw.githubusercontent.com/jazzband/django-silk/master/screenshots/5.png" width="720px"/>



  Turn on the SILKY_PYTHON_PROFILER setting to use Python's built-in `cProfile` profiler. Each request will be separately profiled and the profiler's output will be available on the request's Profiling page in the Silk UI.  Note that as of Python 3.12, `cProfile` cannot run concurrently so [django-silk under Python 3.12 and later will not profile if another profile is running](https://github.com/jazzband/django-silk/pull/692) (even its own profiler in another thread).

  ```python
  SILKY_PYTHON_PROFILER = True
  ```

  If you would like to also generate a binary `.prof` file set the following:

  ```python
  SILKY_PYTHON_PROFILER_BINARY = True
  ```

  When enabled, a graph visualisation generated using [gprof2dot](https://github.com/jrfonseca/gprof2dot) and [viz.js](https://github.com/almende/vis) is shown in the profile detail page:

  <img src="https://raw.githubusercontent.com/jazzband/django-silk/master/screenshots/10.png" width="720px"/>


  A custom storage class can be used for the saved generated binary `.prof` files:

  ```python


  STORAGES = {
      'SILKY_STORAGE': {
          'BACKEND': 'path.to.StorageClass',
      },
      
  }


  SILKY_STORAGE_CLASS = 'path.to.StorageClass'
  ```

  The default storage class is `silk.storage.ProfilerResultStorage`, and when using that you can specify a path of your choosing. You must ensure the specified directory exists.

  ```python

  SILKY_PYTHON_PROFILER_RESULT_PATH = '/path/to/profiles/'
  ```

  A download button will become available with a binary `.prof` file for every request. This file can be used for further analysis using [snakeviz](https://github.com/jiffyclub/snakeviz) or other cProfile tools

  To retrieve which endpoint generates a specific profile file it is possible to add a stub of the request path in the file name with the following:

  ```python
  SILKY_PYTHON_PROFILER_EXTENDED_FILE_NAME = True
  ```

  Silk can also be used to profile specific blocks of code/functions. It provides a decorator and a context
  manager for this purpose.

  For example:

  ```python
  from silk.profiling.profiler import silk_profile


  @silk_profile(name='View Blog Post')
  def post(request, post_id):
      p = Post.objects.get(pk=post_id)
      return render(request, 'post.html', {
          'post': p
      })
  ```

  Whenever a blog post is viewed we get an entry within the Silk UI:

  <img src="https://raw.githubusercontent.com/jazzband/django-silk/master/screenshots/7.png" width="720px"/>

  Silk profiling not only provides execution time, but also collects SQL queries executed within the block in the same fashion as with requests:

  <img src="https://raw.githubusercontent.com/jazzband/django-silk/master/screenshots/8.png" width="720px"/>



  The silk decorator can be applied to both functions and methods

  ```python
  from silk.profiling.profiler import silk_profile



  @silk_profile(name='View Blog Post')
  def post(request, post_id):
      p = Post.objects.get(pk=post_id)
      return render(request, 'post.html', {
          'post': p
      })



  class MyView(View):
      @silk_profile(name='View Blog Post')
      def get(self, request):
          p = Post.objects.get(pk=post_id)
          return render(request, 'post.html', {
              'post': p
          })
  ```



  Using a context manager means we can add additional context to the name which can be useful for
  narrowing down slowness to particular database records.

  ```python
  def post(request, post_id):
      with silk_profile(name='View Blog Post #%d' % self.pk):
          p = Post.objects.get(pk=post_id)
          return render(request, 'post.html', {
              'post': p
          })
  ```



  One of Silk's more interesting features is dynamic profiling. If for example we wanted to profile a function in a dependency to which we only have read-only access (e.g. system python libraries owned by root) we can add the following to `settings.py` to apply a decorator at runtime:

  ```python
  SILKY_DYNAMIC_PROFILING = [{
      'module': 'path.to.module',
      'function': 'MyClass.bar'
  }]
  ```

  which is roughly equivalent to:

  ```python
  class MyClass:
      @silk_profile()
      def bar(self):
          pass
  ```

  The below summarizes the possibilities:

  ```python

  """
  Dynamic function decorator
  """

  SILKY_DYNAMIC_PROFILING = [{
      'module': 'path.to.module',
      'function': 'foo'
  }]


  @silk_profile()
  def foo():
      pass

  """
  Dynamic method decorator
  """

  SILKY_DYNAMIC_PROFILING = [{
      'module': 'path.to.module',
      'function': 'MyClass.bar'
  }]


  class MyClass:

      @silk_profile()
      def bar(self):
          pass

  """
  Dynamic code block profiling
  """

  SILKY_DYNAMIC_PROFILING = [{
      'module': 'path.to.module',
      'function': 'foo',
      
      'start_line': 1,
      'end_line': 2,
      'name': 'Slow Foo'
  }]


  def foo():
      with silk_profile(name='Slow Foo'):
          print (1)
          print (2)
      print(3)
      print(4)
  ```

  Note that dynamic profiling behaves in a similar fashion to that of the python mock framework in that
  we modify the function in-place e.g:

  ```python
  """ my.module """
  from another.module import foo


  foo()

  ```

  ,we would profile `foo` by dynamically decorating `my.module.foo` as opposed to `another.module.foo`:

  ```python
  SILKY_DYNAMIC_PROFILING = [{
      'module': 'my.module',
      'function': 'foo'
  }]
  ```

  If we were to apply the dynamic profile to the functions source module `another.module.foo` **after**
  it has already been imported, no profiling would be triggered.




  Sometimes you may want to dynamically control when the profiler runs. You can write your own logic for when to enable the profiler. To do this add the following to your `settings.py`:

  This setting is mutually exclusive with SILKY_PYTHON_PROFILER and will be used over it if present. It will work with SILKY_DYNAMIC_PROFILING.

  ```python
  def my_custom_logic(request):
      return 'profile_requests' in request.session

  SILKY_PYTHON_PROFILER_FUNC = my_custom_logic # profile only session has recording enabled.
  ```

  You can also use a `lambda`.

  ```python

  SILKY_PYTHON_PROFILER_FUNC = lambda request: 'profile_requests' in request.session
  ```



  Silk currently generates two bits of code per request:

  <img src="https://raw.githubusercontent.com/jazzband/django-silk/master/screenshots/9.png" width="720px"/>

  Both are intended for use in replaying the request. The curl command can be used to replay via command-line and the python code can be used within a Django unit test or simply as a standalone script.





  By default anybody can access the Silk user interface by heading to `/silk/`. To enable your Django
  auth backend place the following in `settings.py`:

  ```python
  SILKY_AUTHENTICATION = True  # User must login
  SILKY_AUTHORISATION = True  # User must have permissions
  ```

  If `SILKY_AUTHORISATION` is `True`, by default Silk will only authorise users with `is_staff` attribute set to `True`.

  You can customise this using the following in `settings.py`:

  ```python
  def my_custom_perms(user):
      return user.is_allowed_to_use_silk

  SILKY_PERMISSIONS = my_custom_perms
  ```

  You can also use a `lambda`.

  ```python
  SILKY_PERMISSIONS = lambda user: user.is_superuser
  ```



  By default, Silk will save down the request and response bodies for each request for future viewing
  no matter how large. If Silk is used in production under heavy volume with large bodies this can have
  a huge impact on space/time performance. This behaviour can be configured with the following options:

  ```python
  SILKY_MAX_REQUEST_BODY_SIZE = -1  # Silk takes anything <0 as no limit
  SILKY_MAX_RESPONSE_BODY_SIZE = 1024  # If response body>1024 bytes, ignore
  ```



  Sometimes it is useful to be able to see what effect Silk is having on the request/response time. To do this add
  the following to your `settings.py`:

  ```python
  SILKY_META = True
  ```

  Silk will then record how long it takes to save everything down to the database at the end of each
  request:

  <img src="https://raw.githubusercontent.com/jazzband/django-silk/master/screenshots/meta.png"/>

  Note that in the above screenshot, this means that the request took 29ms (22ms from Django and 7ms from Silk)



  On high-load sites it may be helpful to only record a fraction of the requests that are made. To do this add the following to your `settings.py`:

  Note: This setting is mutually exclusive with SILKY_INTERCEPT_FUNC.

  ```python
  SILKY_INTERCEPT_PERCENT = 50 # log only 50% of requests
  ```



  On high-load sites it may also be helpful to write your own logic for when to intercept requests. To do this add the following to your `settings.py`:

  Note: This setting is mutually exclusive with SILKY_INTERCEPT_PERCENT.

  ```python
  def my_custom_logic(request):
      return 'record_requests' in request.session

  SILKY_INTERCEPT_FUNC = my_custom_logic # log only session has recording enabled.
  ```

  You can also use a `lambda`.

  ```python

  SILKY_INTERCEPT_FUNC = lambda request: 'record_requests' in request.session
  ```



  To make sure silky garbage collects old request/response data, a config var can be set to limit the number of request/response rows it stores.

  ```python
  SILKY_MAX_RECORDED_REQUESTS = 10**4
  ```

  The garbage collection is only run on a percentage of requests to reduce overhead.  It can be adjusted with this config:

  ```python
  SILKY_MAX_RECORDED_REQUESTS_CHECK_PERCENT = 10
  ```

  In case you want decouple silk's garbage collection from your webserver's request processing, set SILKY_MAX_RECORDED_REQUESTS_CHECK_PERCENT=0 and trigger it manually, e.g. in a cron job:

  ```bash
  python manage.py silk_request_garbage_collect
  ```



  To enable query analysis when supported by the dbms a config var can be set in order to execute queries with the analyze features.

  ```python
  SILKY_ANALYZE_QUERIES = True
  ```

  **Warning:** This setting may cause the database to execute the same query twice, depending on the backend. For instance, `EXPLAIN ANALYZE` in Postgres will [actually execute the query](https://www.postgresql.org/docs/current/sql-explain.html), which may result in unexpected data updates. Set this to True with caution.

  To pass additional params for profiling when supported by the dbms (e.g. VERBOSE, FORMAT JSON), you can do this in the following manner.

  ```python
  SILKY_EXPLAIN_FLAGS = {'format':'JSON', 'costs': True}
  ```




  By default, Silk is filtering values that contains the following keys (they are case insensitive)

  ```python
  SILKY_SENSITIVE_KEYS = {'username', 'api', 'token', 'key', 'secret', 'password', 'signature'}
  ```

  But sometimes, you might want to have your own sensitive keywords, then above configuration can be modified

  ```python
  SILKY_SENSITIVE_KEYS = {'custom-password'}
  ```




  A management command will wipe out all logged data:

  ```bash
  python manage.py silk_clear_request_log
  ```



  [![Jazzband](https://jazzband.co/static/img/jazzband.svg)](https://jazzband.co/)

  This is a [Jazzband](https://jazzband.co/) project. By contributing you agree to abide by the [Contributor Code of Conduct](https://jazzband.co/about/conduct) and follow the [guidelines](https://jazzband.co/about/guidelines).



  Silk features a project named `project` that can be used for `silk` development. It has the `silk` code symlinked so
  you can work on the sample `project` and on the `silk` package at the same time.

  In order to setup local development you should first install all the dependencies for the test `project`. From the
  root of the `project` directory:

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

  You will also need to install `silk`'s dependencies. From the root of the git repository:

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

  At this point your virtual environment should have everything it needs to run both the sample `project` and
  `silk` successfully.

  Before running, you must set the `DB_ENGINE` and `DB_NAME` environment variables:

  ```bash
  export DB_ENGINE=sqlite3
  export DB_NAME=db.sqlite3
  ```

  For other combinations, check [`tox.ini`](./tox.ini).

  Now from the root of the sample `project` apply the migrations

  ```bash
  python manage.py migrate
  ```

  Now from the root of the sample `project` directory start the django server

  ```bash
  python manage.py runserver
  ```



  ```bash
  cd project
  python manage.py test
  ```

  Happy profiling!


pkgId: 304f3e54c77078789718e2b64509287157027e67b89d4cb71a89cf9359546048
name: python-django-sphinx-hosting-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for django-sphinx-hosting
url: https://pypi.org/project/django-sphinx-hosting/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-sphinx-hosting-1.6.0-1.src.rpm
location_href: Packages/python-django-sphinx-hosting-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  **Documentation**: [django-sphinx-hosting.readthedocs.org](https://django-sphinx-hosting.readthedocs.org)

  This reusable Django application provides models, views, permissions, REST API
  endpoints and management commands for making a private Sphinx documentation
  hosting platform.

  This is useful for when you want Sphinx documentation for your internal software
  projects, but that is too sensitive to be shared with a third party.



  * Users must be authenticated to view docs
  * Multiple levels of privileges within the system based on Django authentication
  * Manage multiple versions of your docs per project
  * Automatically build and display navigation for each version of your documentaion
  * Renders all documentation published within with a consistent theme
  * Tag projects with classifiers to refine searching and filtering
  * Search across all projects
  * Use REST API to programmatically interact with the system.  Useful for
    integrating into a CI/CD system



  See the [documentation](https://django-sphinx-hosting.readthedocs.org) for how
  to install and configure `django-sphinx-hosting` in your Django project.


pkgId: 9fb2151acf3adbdf83d2ef0546a597de8b159ac90b5dc0203e150a0e87601859
name: python-django-templateyak-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for django-templateyak
url: https://django-templateyak.levit.be
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-templateyak-0.0.2-1.src.rpm
location_href: Packages/python-django-templateyak-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  YAK in **Django TemplateYAK** stands for Yet Another Komponent.

  This library provides class-based templatetags for Django.

  Writing templatetags in Django that don't fit [simple_tag](https://docs.djangoproject.com/en/dev/howto/custom-template-tags/#simple-tags) or [inclusion_tag](https://docs.djangoproject.com/en/dev/howto/custom-template-tags/#inclusion-tags) is non-trivial. Class-based templatetags is an attempt at making it less complicated.

  As a bonus, you'll find a Django Komponent system also included in this library. You can use it straight out of the box or as a reference for implementing your own templatetags.



  Documentation available at https://django-templateyak.levit.be


pkgId: 966c0cbf6812cb8f7026f3513cd319bac326445daf6ab29b99f120e455323637
name: python-django-theme-academy-help
arch: noarch
version: 0.3.11
epoch: 0
release: 1
summary: Development documents and examples for django-theme-academy
url: https://github.com/caltechads/django-theme-academy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-theme-academy-0.3.11-1.src.rpm
location_href: Packages/python-django-theme-academy-help-0.3.11-1.noarch.rpm
checksum_type: sha256
description:
  `django-theme-academy` provides the Academy theme for Django websites and applications.  Academy provides the following features:

  * Built with Tabler, and Bootstrap 5
  * A fixed left sidebar with configurable logo
  * Breadcrumbs
  * A footer with contact information for your organiization
  * Includes [django-wildewidgets](https://github.com/caltechads/django-wildewidgets) support



  `django-theme-academy` supports Python 3.7+, and Django 3+.

  To install from PyPI:

  ```bash
  pip install django-theme-academy
  ```



  Register the module in `INSTALLED_APPS`:

  ```python
  INSTALLED_APPS = [
      ...
      'academy_theme',
      ...
  ]
  ```

  Add the custom template context processor:

  ```python
  TEMPLATES = [
      {
          'BACKEND': 'django.template.backends.django.DjangoTemplates',
          'OPTIONS': {
              ...
              'context_processors': [
                  ...
                  'academy_theme.context_processors.theme',
                  ...
              ],
          },
      },
  ]
  ```

  Optionally configure the theme specific settings.  You don't need to define all of these, but instead
  only the ones you wish to override:

  ```python
  ACADEMY_THEME_SETTINGS = {
      
      'APPLE_TOUCH_ICON': 'myapp/images/apple-touch-icon.png',
      'FAVICON_32': 'myapp/images/favicon-32x32.png',
      'FAVICON_16': 'myapp/images/favicon-16x16.png',
      'FAVICON': 'myapp/images/favicon.ico',
      'SITE_WEBMANIFEST': 'myapp/images/site.webmanifest',
      'LOGOUT_TITLE': 'Log out of this site',
      'LOGOUT_LINK': '/my/logout/link'

      
      'ORGANIZATION_LINK': 'https://myorg.com',
      'ORGANIZATION_NAME': 'Organization Name',
      'ORGANIZATION_ADDRESS': 'Organization Address',
      'COPYRIGHT_ORGANIZATION': 'Copyright Organization'
      'FOOTER_LINKS': []
  }
  ```



  `django-theme-academy` ships with two different base templates:

  * `academy_theme/base.html`, for regular Django template development
  * `academy_theme/base--wildewidgets.html`, for [django-wildewidgets](https://github.com/caltechads/django-wildewidgets) based Django development



  To use `academy_theme/base.html`, create your own `base.html` that extends it
  and overrides its blocks as needed.  Example:

  ```html
  {% extends 'academy_theme/base.html' %}
  {% load static academy_theme i18n %}

  {% block title %}{% trans 'My App Title' %}{% endblock %}

  {% block extra_css %}
    <link rel="stylesheet" href="{% static 'myapp/css/styles.css' %}">
  {% endblock %}

  {% block extra_header_js %}
    <script src="{% static 'myapp/js/app.js %}" ></script>
  {% endblock %}

  {% block menu %}
  <nav class="navbar navbar-vertical navbar-expand-lg navbar-dark">
   <div class="container-lg ms-0">
      <a class="navbar-brand" href="#">
          <img src="{% static 'myapp/images/logo.png' %} alt="My App" width="100%">
      </a>
      <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContentV_9628" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
        <span class="navbar-toggler-icon"></span>
      </button>
      <div class="collapse navbar-collapse" id="navbarSupportedContent">
        <ul class="navbar-nav me-1">
         <li class="nav-item">
            <a class="nav-link" href="/">Home</a>
          </li>
        </ul>
      </div>
    </div>
  </nav>
  {% endblock %}

  {% block breadcrumbs %}
    <ol class="breadcrumb">
      {% block breadcrumb-items %}
          {% breadcrumb 'Home' 'myapp:home' %}
      {% endblock %}
    </ol>
  {% endblock %}
  ```



  If you don't need to add any Javascript or CSS, this can be used directly in
  your ``django-wildewidgets`` based views, like so:

  ```python
  from typing import List, Tuple, Type

  from academy_theme.wildewidgets import AcademyThemeMainMenu
  from django.templatetags.static import static
  from wildewidgets import (
      BasicMenu,
      BreadcrumbBlock
      CardWidget,
      MenuMixin,
      StandardWidgetMixin,
      WidgetListLayout
  )

  class MainMenu(AcademyThemeMainMenu):
      brand_image: str = static("myapp/images/logo.png")
      brand_text: str = "My App"
      items: List[Tuple[str, str]] = [
          ('Home', 'myapp:home'),
      ]


  class BaseBreadcrumbs(BreadcrumbBlock):
      def __init__(self, *args, **kwargs):
          super().__init__(*args, **kwargs)
          self.add_breadcrumb('Home', reverse('myapp:home'))


  class WildewidgetsView(
      MenuMixin,
      StandardWidgetMixin,
      TemplateView
  ):
      template_name: str = "academy_theme/base--wildewidgets.html"
      menu_class: Type[BasicMenu] = MainMenu
      menu_item: str = "Home"

      def get_content(self) -> WidgetListLayout:
          layout = WidgetListLayout("Wildewidgets Example")
          layout.add_widget(
              CardWidget(
                  card_title='My Card',
                  widget='Here is my card body',
              ),
              title='My Card',
              icon='info-square'
          )
          return layout

      def get_breadcrumbs(self) -> BreadcrumbBlock:
          breadcrumbs = BaseBreadcrumbs()
          breadcrumbs.add_breadcrumb('Wildewidgets')
          return breadcrumbs
  ```

  If you do need to add Javascript or CSS, create your own `base--wildewidgets.html` that extends the `acadmey_theme`
  one and and overrides its blocks as needed.  Example:

  ```html
  {% extends 'academy_theme/base--wildewidgets.html' %}
  {% load static %}

  {% block extra_css %}
    <link rel="stylesheet" href="{% static 'myapp/css/styles.css' %}">
  {% endblock %}

  {% block extra_header_js %}
    <script src="{% static 'myapp/js/app.js %}" ></script>
  {% endblock %}
  ```


pkgId: 524a66b7bbd7095f49e24b8d60535632960c5c557f3af75b231696a56d42e170
name: python-django-theme-material-kit-help
arch: noarch
version: 1.0.26
epoch: 0
release: 1
summary: Development documents and examples for django-theme-material-kit
url: https://app-generator.dev/docs/products/django-libs/theme-material-kit.html
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-theme-material-kit-1.0.26-1.src.rpm
location_href: Packages/python-django-theme-material-kit-help-1.0.26-1.noarch.rpm
checksum_type: sha256
description:
  **[Django Material Kit](https://app-generator.dev/docs/products/django-libs/theme-material-kit.html)** - Modern Django UI Library provided by **[App-Generator](https://app-generator.dev)**


pkgId: 574c4835258e58a12d7d296212acbf016bb09e291934fa137fe16ba71576efa4
name: python-django-theme-pixel-help
arch: noarch
version: 1.0.6
epoch: 0
release: 1
summary: Development documents and examples for django-theme-pixel
url: https://app-generator.dev/docs/products/django-libs/theme-pixel.html
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-theme-pixel-1.0.6-1.src.rpm
location_href: Packages/python-django-theme-pixel-help-1.0.6-1.noarch.rpm
checksum_type: sha256
description:
  **[Django Pixel UI](https://app-generator.dev/docs/products/django-libs/theme-pixel.html)** - Modern Django UI Library provided by **[App-Generator](https://app-generator.dev)**


pkgId: b71c76a08ee7abc07ac8d13813a062ebdaa74b7f6ae1fd02bc3370eb8691b24f
name: python-django-tomselect-help
arch: noarch
version: 2024.12.1
epoch: 0
release: 1
summary: Development documents and examples for django-tomselect
url: https://pypi.org/project/django-tomselect/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-tomselect-2024.12.1-1.src.rpm
location_href: Packages/python-django-tomselect-help-2024.12.1-1.noarch.rpm
checksum_type: sha256
description:
  A powerful, lightweight Django package for dynamic select inputs with autocomplete, tagging, and more.

  [![PyPI version](https://badge.fury.io/py/django-tomselect.svg)](https://badge.fury.io/py/django-tomselect)
  [![License](https://img.shields.io/pypi/l/django-tomselect)](https://github.com/OmenApps/django-tomselect/blob/main/LICENSE)

  Django TomSelect integrates [Tom Select](https://tom-select.js.org/) into your Django projects, providing beautiful and intuitive select inputs with features like:

  - **Live Search & Autocomplete**
      - Real-time filtering and highlighting as you type
      - Server-side search with customizable lookups
      - Automatic pagination for large datasets
  	- Customizable minimum query length

  - **Rich UI Options**
      - Single and multiple selection modes
      - Tabular display with custom columns
      - Bootstrap 4/5 theming support
  	- Clear/remove buttons
  	- Dropdown headers & footers
  	- Checkbox options
      - Customizable templates

  ![Tom Select With Single Select](https://raw.githubusercontent.com/jacklinke/django-tomselect/main/docs/images/Single.png)
  ![Tom Select Tabular With Multiple Select](https://raw.githubusercontent.com/jacklinke/django-tomselect/main/docs/images/Multiple_Tabular.png)



  1. **Install the package:**
  ```bash
  pip install django-tomselect
  ```

  2. **Update settings.py:**
  ```python
  INSTALLED_APPS = [
      ...
      "django_tomselect"
  ]

  MIDDLEWARE = [
      ...
      "django_tomselect.middleware.TomSelectMiddleware",
      ...
  ]

  TEMPLATES = [
      {
          "OPTIONS": {
              "context_processors": [
                  ...
                  "django_tomselect.context_processors.tomselect",
                  ...
              ],
          },
      },
  ]
  ```

  3. **Create an autocomplete view:**
  ```python
  from django_tomselect.autocompletes import AutocompleteModelView

  class PersonAutocompleteView(AutocompleteModelView):
      model = Person
      search_lookups = ["full_name__icontains"]
  ```

  4. **Add URL pattern:**
  ```python
  urlpatterns = [
      path("person-autocomplete/", PersonAutocompleteView.as_view(), name="person_autocomplete"),
  ]
  ```

  5. **Use in your forms:**
  ```python
  from django_tomselect.forms import TomSelectModelChoiceField

  class MyForm(forms.Form):
      person = TomSelectModelChoiceField(
          url="person_autocomplete",
          value_field="id",
          label_field="full_name",
      )
  ```

  6. **Include in your template:**
  ```html
  {{ form.media }}  {# Adds the required CSS/JS #}

  {{ form }}
  ```




  - Dependent/chained select fields
  - Field exclusion support
  - Custom search implementations
  - Hooks for overriding functionality


  - Support for [Tom Select Plugins](https://tom-select.js.org/plugins/)
  - Global settings and per-form-field configuration
  - Override any template


  - Built-in permission handling
  	- including django auth, custom auth, object perms


  - Translation support
  - Customizable messages



  - [Complete Usage Guide](https://django-tomselect.readthedocs.io/en/latest/usage/)
  - [Configuration Reference](https://django-tomselect.readthedocs.io/en/latest/api/config/)
  - [API Reference](https://django-tomselect.readthedocs.io/en/latest/api/)



  Contributions are welcome! Check out our [Contributor Guide](https://github.com/OmenApps/django-tomselect/blob/main/CONTRIBUTING.md) to get started.



  This project is licensed under the MIT License - see the [License](https://github.com/OmenApps/django-tomselect/blob/main/LICENSE) file for details.



  This package builds on the excellent work of [Philip Becker](https://pypi.org/user/actionb/) in [mizdb-tomselect](https://www.pypi.org/project/mizdb-tomselect/), with a focus on generalization, Django templates, translations, and customization.


pkgId: bbb53120f678b107f0c664fda9769ecb35552d71c0f413307ef6f938c1c414fc
name: python-django-ts-routes-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for django-ts-routes
url: https://pypi.org/project/django-ts-routes/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-ts-routes-1.0.0-1.src.rpm
location_href: Packages/python-django-ts-routes-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  **django-ts-routes** is a Django application allowing to expose and perform reverse lookups of Django named URL patterns in a TypeScript code base. This codebase is based on [django-js-routes](https://github.com/ellmetha/django-js-routes). Big thanks to the original author of this package.



  - [Installation](#installation)
  - [Usage](#usage)
  - [Settings](#settings)
  - [Advanced features](#advanced-features)
  - [License](#license)



  To install django-ts-routes, please use the pip command as follows:

  ```shell
  $ pip install django-ts-routes
  ```

  Once the package is installed, you'll have to add the application to `INSTALLED_APPS` in your project's settings module:

  ```python
  INSTALLED_APPS = (
      
      'ts_routes',
  )
  ```

  You can then define which URL patterns or URL namespaces you want to expose by setting the `TS_ROUTES_INCLUSION_LIST` setting (for compatibility with [django-js-routes](https://github.com/ellmetha/django-js-routes) you can also use `JS_ROUTES_INCLUSION_LIST`). This setting allows to define which URLs should be serialized and made available to the client side through the generated and / or exported TypeScript helper. This list should contain only URL pattern names or namespaces. Here is an example:

  ```python
  TS_ROUTES_INCLUSION_LIST = [
      'home',
      'catalog:product_list',
      'catalog:product_detail',
  ]
  ```

  Note that if a namespace is included in this list, all the underlying URLs will be made available to the client side through the generated TypeScript helper. Django-ts-routes is safe by design in the sense that _only_ the URLs that you configure in this inclusion list will be publicly exposed on the client side.

  Once the list of URLs to expose is configured, you can dump the routes with the management command `dump_routes_resolver`:

  ```shell
  $ python manage.py dump_routes_resolver --output-dir=static/src/routes
  ```



  The URL patterns you configured through the `TS_ROUTES_INCLUSION_LIST` setting will be exported to TypeScript files in the `output-dir` directory. This directory will contain a `index.ts` with routes of the default language, other supported languages will be in separate files. The files export the `reverseUrl` function that can be used to generate URLs in your TypeScript code.

  ```typescript
  import reverseUrl from "@/routes";

  reverseUrl("home");
  reverseUrl("catalog:product_list");
  reverseUrl("catalog:product_detail", { pk: productId });
  ```





  Default: `[]`

  The `TS_ROUTES_INCLUSION_LIST` setting allows to define the URL patterns and URL namespaces that should be exposed.



  MIT. See `LICENSE` for more details.


pkgId: 3a40feb089149ff01c9f894135e128374ca63dc7ab0bceebdf8339e5cb563c09
name: python-django-uidfield-help
arch: noarch
version: 0.3.5
epoch: 0
release: 1
summary: Development documents and examples for django-uidfield
url: https://github.com/ivelum/django-uidfield/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-uidfield-0.3.5-1.src.rpm
location_href: Packages/python-django-uidfield-help-0.3.5-1.noarch.rpm
checksum_type: sha256
description:
  Pretty UID fields for your Django models, with customizable prefixes and
  controlled length. Tested against Python 3.5, 3.6, 3.7, 3.8, 3.9, 3.10, 3.11,
  3.12, 3.13 and Django 2.2, 3.1, 3.2, 4.0, 4.1, 4.2, 5.0, 5.1.


pkgId: efcfbc00ff44e9f0457241044bb1c582f39061feb4a0b9c64b6500b7821bf023
name: python-djangocms-export-page-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for djangocms-export-page
url: https://github.com/maykinmedia/djangocms_export_page
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-djangocms-export-page-0.2.1-1.src.rpm
location_href: Packages/python-djangocms-export-page-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  |build-status| |code-quality| |black| |coverage|
  |python-versions| |django-versions| |pypi-version|
  Export a Django CMS page or a model view to a DOCX document

rpm_license:
  Copyright {% now "Y" %} Maykin Media  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: 71f5303a8879a85eb23ad8f1be9b508a4e06d08a6422e01e5762a1ba2972c981
name: python-djangocms-meta-og-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for djangocms-meta-og
url: https://gitlab.nic.cz/djangocms-apps/djangocms-meta-og
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-djangocms-meta-og-1.0.0-1.src.rpm
location_href: Packages/python-djangocms-meta-og-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  HTML Meta tags [OpenGraph](https://ogp.me/) for [DjangoCMS](https://www.django-cms.org/).
  The project is based on the [Django Meta OG](https://gitlab.nic.cz/django-apps/django-meta-og) project.



  `pip install djangocms-meta-og`


  Add into settings.py:

  ```python
  INSTALLED_APPS = [
      "django_meta_og",
      "djangocms_meta_og",
      ...
  ]

  TEMPLATES  = [
      {"OPTIONS": {
              "context_processors": [
                  "djangocms_meta_og.context_processors.meta",
                  ...
              ]
          }
      }
  ]
  ```

  Add into the templates:

  ```django
  {% load djangocms_meta_og %}
  {% djangocms_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: 5becff365379cc0a36c05c238c8b0dfdf2764f8c5cb2b12cbd934d1a42f83fc7
name: python-djangocms-text-ckeditor5-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for djangocms-text-ckeditor5
url: https://github.com/django-cms/djangocms-text-ckeditor5
rpm_license: LGPL 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-djangocms-text-ckeditor5-0.1.0-1.src.rpm
location_href: Packages/python-djangocms-text-ckeditor5-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  |pypi| |djangocms| |djangocms4|
  djangocms-text-ckeditor5 is an extension to ``djangocms-text`` offering CKEditor5 as
  a rich text editor to djangocms-text.


pkgId: cac399d95b5bc0babc11653d402e29bdd4e063c077cf12d6701bc27d1d8f8855
name: python-djangorestframework-stubs-help
arch: noarch
version: 3.15.2
epoch: 0
release: 1
summary: Development documents and examples for djangorestframework-stubs
url: https://github.com/typeddjango/djangorestframework-stubs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-djangorestframework-stubs-3.15.2-1.src.rpm
location_href: Packages/python-djangorestframework-stubs-help-3.15.2-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://mypy-lang.org/static/mypy_light.svg" alt="mypy logo" width="300px"/>



  [![Build status](https://github.com/typeddjango/djangorestframework-stubs/workflows/test/badge.svg?branch=master&event=push)](https://github.com/typeddjango/djangorestframework-stubs/actions?query=workflow%3Atest)
  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
  [![Gitter](https://badges.gitter.im/mypy-django/Lobby.svg)](https://gitter.im/mypy-django/Lobby)
  [![StackOverflow](https://shields.io/badge/ask-stackoverflow-orange?logo=stackoverflow)](https://stackoverflow.com/questions/tagged/django-stubs?tab=Active)


  Mypy stubs for [Django REST Framework](https://pypi.org/project/djangorestframework/).
  Supports Python 3.8 and up.



  ```bash
  pip install djangorestframework-stubs[compatible-mypy]
  ```

  To make mypy aware of the plugin, you need to add

  ```ini
  [mypy]
  plugins =
      mypy_drf_plugin.main
  ```

  in your `mypy.ini` file.





  When subclassing `ModelSerializer`, add a [type argument](https://peps.python.org/pep-0484/#generics) to type-hint the related model class, for example:

  ```python
  class MyModelSerializer(serializers.ModelSerializer[MyModel]):
      class Meta:
          model = MyModel
          fields = ("id", "example")
  ```

  Which means that methods where the model is being passed around will know the actual type of the model instead of being `Any`. The `instance` attribute on the above serializer will be `Union[MyModel, typing.Sequence[MyModel], None]`.



  We have Gitter here: <https://gitter.im/mypy-django/Lobby>
  If you think you have more generic typing issue, please refer to <https://github.com/python/mypy> and their Gitter.



  This project is open source and community driven. As such we encourage contributions big and small. You can contribute by doing any of the following:

  1. Contribute code (e.g. improve stubs, add plugin capabilities, write tests etc) - to do so please follow the [contribution guide](./CONTRIBUTING.md).
  2. Assist in code reviews and discussions in issues.
  3. Identify bugs and issues and report these

  You can always also reach out in gitter to discuss your contributions!


pkgId: d55ceede3f166037b2edc79b6ba7c2fa81322120e17cd7452343c84423cf6025
name: python-djantic2-help
arch: noarch
version: 1.0.5
epoch: 0
release: 1
summary: Development documents and examples for djantic2
url: https://github.com/jonathan-s/djantic2/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-djantic2-1.0.5-1.src.rpm
location_href: Packages/python-djantic2-help-1.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Djantic2 is a fork of djantic which works with pydantic >2, it is a library that provides a configurable utility class for automatically creating a Pydantic model instance for any Django model class. It is intended to support all of the underlying Pydantic model functionality such as JSON schema generation and introduces custom behaviour for exporting Django model instance data.

  Install using pip:
  ```shell
  pip install djantic2
  ```
  Create a model schema:
  ```python
  from users.models import User
  from pydantic import ConfigDict
  from djantic import ModelSchema
  class UserSchema(ModelSchema):
      model_config = ConfigDict(model=User, include=["id", "first_name"])
  print(UserSchema.schema())
  ```
  **Output:**
  ```python
  {
      "description": "A user of the application.",
      "properties": {
          "id": {
              "anyOf": [{"type": "integer"}, {"type": "null"}],
              "default": None,
              "description": "id",
              "title": "Id",
          },
          "first_name": {
              "description": "first_name",
              "maxLength": 50,
              "title": "First Name",
              "type": "string",
          },
      },
      "required": ["first_name"],
      "title": "UserSchema",
      "type": "object",
  }
  ```
  See https://pydantic-docs.helpmanual.io/usage/models/ for more.

  Use the `from_django` method on the model schema to load a Django model instance for <a href="https://pydantic-docs.helpmanual.io/usage/exporting_models/">export</a>:
  ```python
  user = User.objects.create(
      first_name="Jordan",
      last_name="Eremieff",
      email="jordan@eremieff.com"
  )
  user_schema = UserSchema.from_django(user)
  print(user_schema.json(indent=2))
  ```
  **Output:**
  ```json
  {
      "profile": null,
      "id": 1,
      "first_name": "Jordan",
      "last_name": "Eremieff",
      "email": "jordan@eremieff.com",
      "created_at": "2020-08-15T16:50:30.606345+00:00",
      "updated_at": "2020-08-15T16:50:30.606452+00:00"
  }
  ```

  Djantic supports multiple level relations. This includes foreign keys, many-to-many, and one-to-one relationships.
  Consider the following example Django model and Djantic model schema definitions for a number of related database records:
  ```python

  from django.db import models
  class OrderUser(models.Model):
      email = models.EmailField(unique=True)
  class OrderUserProfile(models.Model):
      address = models.CharField(max_length=255)
      user = models.OneToOneField(OrderUser, on_delete=models.CASCADE, related_name='profile')
  class Order(models.Model):
      total_price = models.DecimalField(max_digits=8, decimal_places=5, default=0)
      user = models.ForeignKey(
          OrderUser, on_delete=models.CASCADE, related_name="orders"
      )
  class OrderItem(models.Model):
      price = models.DecimalField(max_digits=8, decimal_places=5, default=0)
      quantity = models.IntegerField(default=0)
      order = models.ForeignKey(
          Order, on_delete=models.CASCADE, related_name="items"
      )
  class OrderItemDetail(models.Model):
      name = models.CharField(max_length=30)
      order_item = models.ForeignKey(
          OrderItem, on_delete=models.CASCADE, related_name="details"
      )
  ```
  ```python

  from djantic import ModelSchema
  from pydantic import ConfigDict
  from orders.models import OrderItemDetail, OrderItem, Order, OrderUserProfile
  class OrderItemDetailSchema(ModelSchema):
      model_config = ConfigDict(model=OrderItemDetail)
  class OrderItemSchema(ModelSchema):
      details: List[OrderItemDetailSchema]
      model_config = ConfigDict(model=OrderItem)
  class OrderSchema(ModelSchema):
      items: List[OrderItemSchema]
      model_config = ConfigDict(model=Order)
  class OrderUserProfileSchema(ModelSchema):
      model_config = ConfigDict(model=OrderUserProfile)
  class OrderUserSchema(ModelSchema):
      orders: List[OrderSchema]
      profile: OrderUserProfileSchema
      model_config = ConfigDict(model=OrderUser)
  ```
  Now let's assume you're interested in exporting the order and profile information for a particular user into a JSON format that contains the details accross all of the related item objects:
  ```python
  user = OrderUser.objects.first()
  print(OrderUserSchema.from_django(user).json(ident=4))
  ```
  **Output:**
  ```json
  {
      "profile": {
          "id": 1,
          "address": "",
          "user": 1
      },
      "orders": [
          {
              "items": [
                  {
                      "details": [
                          {
                              "id": 1,
                              "name": "",
                              "order_item": 1
                          }
                      ],
                      "id": 1,
                      "price": 0.0,
                      "quantity": 0,
                      "order": 1
                  }
              ],
              "id": 1,
              "total_price": 0.0,
              "user": 1
          }
      ],
      "id": 1,
      "email": ""
  }
  ```
  The model schema definitions are composable and support customization of the output according to the auto-generated fields and any additional annotations.

  The fields exposed in the model instance may be configured using two options: `include` and `exclude`. These represent iterables that should contain a list of field name strings. Only one of these options may be set at the same time, and if neither are set then the default behaviour is to include all of the fields from the Django model.
  For example, to include all of the fields from a user model <i>except</i> a field named `email_address`, you would use the `exclude` option:
  ```python
  from pydantic import ConfigDict
  class UserSchema(ModelSchema):
      model_config = ConfigDict(model=User, exclude=["email_address"])
  ```
  In addition to this, you may also limit the fields to <i>only</i> include annotations from the model schema class by setting the `include` option to a special string value: `"__annotations__"`.
  ```python
  from pydantic import ConfigDict
  class ProfileSchema(ModelSchema):
          website: str
          model_config = ConfigDict(model=Profile, include="__annotations__")
      assert ProfileSchema.schema() == {
          "title": "ProfileSchema",
          "description": "A user's profile.",
          "type": "object",
          "properties": {
              "website": {
                  "title": "Website",
                  "type": "string"
              }
          },
          "required": [
              "website"
          ]
      }
  ```


pkgId: 488fd88c12f8964e40b565f359939bdecda54f0e8a3d1e95f4171306ca113962
name: python-djehuty-help
arch: noarch
version: 24.12
epoch: 0
release: 1
summary: Development documents and examples for djehuty
url: https://data.4tu.nl/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-djehuty-24.12-1.src.rpm
location_href: Packages/python-djehuty-help-24.12-1.noarch.rpm
checksum_type: sha256
description:
  This Python package provides the repository system for 4TU.ResearchData and Nikhef.

  To create a development environment, use the following snippet:
  ```bash
  python -m venv djehuty-env
  . djehuty-env/bin/activate
  cd /path/to/the/repository/checkout/root
  pip install -r requirements.txt
  ```
  Note: On Windows Powershell, replace `. djehuty-env/bin/activate` with
  `djehuty-env\Scripts\Activate.ps1`.

  To get an interactive development environment, use:
  ```python
  sed -e 's/@VERSION@/0.0.1/g' pyproject.toml.in > pyproject.toml
  pip install --editable .
  cp etc/djehuty/djehuty-example-config.xml djehuty.xml
  djehuty web --config-file djehuty.xml
  ```
  Note: On Windows, instead of the `sed` command, copy `pyproject.toml.in`
  to `pyproject.toml` and change the version from `@VERSION@` to `0.0.1`.

  To update packages in the virtual environment, use the following command
  inside an activated virtual environment:
  ```bash
  pip freeze | grep -v "djehuty.git" | cut -d= -f1 | xargs -n1 pip install -U
  ```

  Djehuty needs a SPARQL 1.1 endpoint such as
  [Virtuoso OSE](https://github.com/openlink/virtuoso-opensource) or
  [Jena Fuseki](https://jena.apache.org/documentation/fuseki2/) to
  store its state.

  Upon first run, `djehuty` needs to initialize the database with categories,
  licences and accounts.  To do so, pass the `--initialize` option to the
  `djehuty web` command:
  ```bash
  djehuty web --initialize --config djehuty.xml
  ```


  Create a portable executable with:
  ```bash
  pip install pyinstaller
  pyinstaller --onefile \
              --hidden-import=_cffi_backend \
              --add-data "src/djehuty/web/resources:djehuty/web/resources" \
              --name djehuty \
              /path/to/djehuty-env/bin/djehuty
  ```
  On Windows, use:
  ```bash
  pip install pyinstaller
  pyinstaller --onefile \
              --hidden-import=_cffi_backend \
              --add-data="src/djehuty/web/resources;djehuty/web/resources" \
              --icon="src/djehuty/web/resources/static/images/favicon.ico" \
              --name=djehuty \
              /path/to/djehuty-env/bin/djehuty
  ```

  While no support can be provided for this, the following notes may help.
  Allegedly, using Python 3.8.6 works well.  Activating the virtual
  environment works best from a `cmd.exe`, which can be started using:
  ```bash
  wine cmd
  ```

  ```bash
  pip install nuitka
  nuitka --standalone \
         --include-module=rdflib.plugins \
         --include-module=_cffi_backend \
         --include-package-data=djehuty \
         --onefile \
         --linux-onefile-icon="src/djehuty/web/resources/static/images/favicon.png" \
         /path/to/djehuty-env/bin/djehuty \
         -o djehuty.appimage
  ```

  Building RPMs can be done via the Autotools scripts:
  ```bash
  autoreconf -vif
  ./configure
  make dist-rpm
  ```
  The RPMs will be available under `rpmbuild/RPMS/noarch`.


  ```bash
  djehuty web --config-file=djehuty.xml
  ```
  An example of a configuration file can be found in [etc/djehuty/djehuty-example-config.xml](./etc/djehuty/djehuty-example-config.xml).
  Use the `maximum-workers` configuration option to use forking rather than threading.

  On EL7, install `uwsgi` and `uwsgi-plugin-python36`.
  ```bash
  uwsgi --plugins-dir /usr/lib64/uwsgi --need-plugin python36,http --http :8080 --wsgi-file src/djehuty/web/ui.py -H <path-to-your-virtualenv-root> --env DJEHUTY_CONFIG_FILE=djehuty.xml --master --processes 4 --threads 2
  ```


pkgId: 15af972c870525ca6de0bd0f9f5b2417a7d562f7570fe70cb69e468fccd11a0c
name: python-djlds-help
arch: noarch
version: 1.3.9
epoch: 0
release: 1
summary: Development documents and examples for djlds
url: https://github.com/ldsxp/django-utils-lds
rpm_license: GNU GPL 3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-djlds-1.3.9-1.src.rpm
location_href: Packages/python-djlds-help-1.3.9-1.noarch.rpm
checksum_type: sha256
description:
  **djlds** Django 相关的模块，我们会把 ilds 里面和 Django 相关的功能，移动到这里来。

  查看 [更改日志](https://github.com/ldsxp/django-utils-lds/blob/master/CHANGELOG.md)


  ```shell
  pip install -U djlds
  ```




  ```python
  ...
  ```


pkgId: 1fd100ec614e48b4dad7ce6bec188eee96c66a8af223af6aa6f7ddca8fd4919d
name: python-dkist-processing-common-help
arch: noarch
version: 10.5.3
epoch: 0
release: 1
summary: Development documents and examples for dkist-processing-common
url: https://nso.edu/dkist/data-center/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dkist-processing-common-10.5.3-1.src.rpm
location_href: Packages/python-dkist-processing-common-help-10.5.3-1.noarch.rpm
checksum_type: sha256
description:
  This repository works in concert with `dkist-processing-core <https://pypi.org/project/dkist-processing-core/>`_ and `dkist-processing-*instrument*` to
  form the DKIST calibration processing stack.


pkgId: cfdd3cd33df0b158e4b9978a20b3b272a4d26d41bec91f8b1e925319033bee89
name: python-dkist-processing-ops-help
arch: noarch
version: 1.6.24
epoch: 0
release: 1
summary: Development documents and examples for dkist-processing-ops
url: https://pypi.org/project/dkist-processing-ops/
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dkist-processing-ops-1.6.24-1.src.rpm
location_href: Packages/python-dkist-processing-ops-help-1.6.24-1.noarch.rpm
checksum_type: sha256
description:
  |codecov|
  This repository works in concert with `dkist-processing-core <https://pypi.org/project/dkist-processing-core/>`_ and
  `dkist-processing-common <https://pypi.org/project/dkist-processing-common/>`_ to provide workflows for the
  operational management and smoke testing of the `Automated Processing <https://nso.atlassian.net/wiki/spaces/DPD/pages/3671451/04+-+Automated+Processing>`_ stack.
  Developer Setup
  ~~~~~~~~~~~~~~~
      pip install -e .[test]
      pip install pre-commit
      pre-commit install


pkgId: 9b478f6f6803eda1872ed7fdb1c50f04d35269e3161e757f1c8f5904f90c092a
name: python-dkist-quality-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for dkist-quality
url: https://pypi.org/project/dkist-quality/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dkist-quality-1.1.1-1.src.rpm
location_href: Packages/python-dkist-quality-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  |codecov|
  Provides the ability to create a pdf quality report from structured quality data.
  Sample Usage
  ~~~~~~~~~~~~
      from dkist_quality.report import format_report
      def create_quality_report(report_data: dict | list[dict], dataset_id: str) -> bytes:
          """
          Generate a quality report in pdf format.
          """
          return format_report(report_data=report_data, dataset_id=dataset_id)
  Developer Setup
  ~~~~~~~~~~~~~~~
      pip install -e .[test]
      pip install pre-commit
      pre-commit install


pkgId: 32a5b03fa5edba123cad9e07193f749b9f16bb2c1342adfbb07981dc571c34f9
name: python-dkpy-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for dkpy
url: https://github.com/decargroup/dkpy
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dkpy-0.1.6-1.src.rpm
location_href: Packages/python-dkpy-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  ``dkpy`` is a `D-K iteration <https://doi.org/10.1109/ACC.1994.735077>`_
  library written in Python, aiming to build upon
  `python-control <https://github.com/python-control/python-control>`_.
  The package is currently a work-in-progress, and no API stability guarantees
  will be made until version 1.0.0.

rpm_license:
  MIT License  Copyright (c) 2024 DECAR  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: f22c4217394d9326516dc730922d23a3d29077aa5ee66611e70439f03a879b5d
name: python-dlomix-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for dlomix
url: https://github.com/wilhelm-lab/dlomix
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dlomix-0.1.6-1.src.rpm
location_href: Packages/python-dlomix-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  [![Docs](https://readthedocs.org/projects/dlomix/badge/?version=stable)](https://dlomix.readthedocs.io/en/stable/?badge=stable)
  [![Build](https://github.com/wilhelm-lab/dlomix/actions/workflows/build.yaml/badge.svg)](https://github.com/wilhelm-lab/dlomix/actions/workflows/build.yaml)
  [![PyPI](https://github.com/wilhelm-lab/dlomix/actions/workflows/pypi.yaml/badge.svg)](https://github.com/wilhelm-lab/dlomix/actions/workflows/pypi.yaml)

  **DLOmix** is a Python framework for Deep Learning in Proteomics. Initially built on top of TensorFlow/Keras, support for PyTorch can however be integrated once the main API is established.


  Experiment a simple retention time prediction use-case using Google Colab &nbsp;&nbsp; [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/wilhelm-lab/dlomix/blob/develop/notebooks/Example_RTModel_Walkthrough_colab.ipynb)

  A version that includes experiment tracking with [Weights and Biases](https://www.wandb.ai) is available here &nbsp;&nbsp; [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/wilhelm-lab/dlomix/blob/develop/notebooks/Example_RTModel_Walkthrough_colab-weights-and-biases.ipynb)

  **Resources Repository**

  More learning resources can be found in the [dlomix-resources](https://github.com/wilhelm-lab/dlomix-resources) repository.



  Run the following to install:
  ```bash
  $ pip install dlomix
  ```

  If you would like to use [Weights & Biases](wandb.ai) for experiment tracking and use the available reports for Retention Time under `/notebooks`, please install the optional `wandb` python dependency with `dlomix` by running:

  ```bash
  $ pip install dlomix[wandb]
  ```

  **General Overview**
  -  `data`: structures for modeling the input data, processing functions, and feature extractions based on Hugging Face datasets `Dataset` and `DatasetDict`
  -  `eval`: classes for evaluating models and reporting results
  -  `layers`: custom layers used for building models, based on `tf.keras.layers.Layer`
  -  `losses`: custom losses to be used for training with `model.fit()`
  - `models`: common model architectures for the relevant use-cases based on `tf.keras.Model` to allow for using the Keras training API
  -  `pipelines`: an exemplary high-level pipeline implementation
  -  `reports`: classes for generating reports related to the different tasks
  -  `constants.py`: constants and configuration values


  **Use-cases**

  - Retention Time Prediction:
      - a regression problem where the retention time of a peptide sequence is to be predicted.

  - Fragment Ion Intensity Prediction:
      - a multi-output regression problem where the intensity values for fragment ions are predicted given a peptide sequence along with some additional features.

  - Peptide Detectability (Pfly) [4]:
      - a multi-class classification problem where the detectability of a peptide is predicted given the peptide sequence.



  **To-Do**

  Functionality:
  - [X] integrate prosit
  - [X] integrate hugging face datasets
  - [X] extend data representation to include modifications
  - [X] add PTM features
  - [X] add residual plots to reporting, possibly other regression analysis tools
  - [X] output reporting results as PDF
  - [X] refactor reporting module to use W&B Report API (Retention Time)
  - [X] add additional detectability task
  - [ ] extend pipeline for different types of models and backbones
  - [ ] extend pipeline to allow for fine-tuning with custom datasets



  Package structure:

  - [X] integrate `deeplc.py` into `models.py`, preferably introduce a package structure (e.g. `models.retention_time`)
  - [X] add references for implemented models in the ReadMe
  - [X] introduce formatting and precommit hooks
  - [X] plan documentation (sphinx and readthedocs)
  - [X] refactor following best practices for cleaner install



  To install dlomix, along with the tools needed to develop and run tests, run the following command in your virtualenv:
  ```bash
  $ pip install -e .[dev]
  ```


  **References:**

  [**Prosit**]

  [1] Gessulat, S., Schmidt, T., Zolg, D. P., Samaras, P., Schnatbaum, K., Zerweck, J., ... & Wilhelm, M. (2019). Prosit: proteome-wide prediction of peptide tandem mass spectra by deep learning. Nature methods, 16(6), 509-518.

  [**DeepLC**]

  [2] DeepLC can predict retention times for peptides that carry as-yet unseen modifications
  Robbin Bouwmeester, Ralf Gabriels, Niels Hulstaert, Lennart Martens, Sven Degroeve
  bioRxiv 2020.03.28.013003; doi: 10.1101/2020.03.28.013003

  [3] Bouwmeester, R., Gabriels, R., Hulstaert, N. et al. DeepLC can predict retention times for peptides that carry as-yet unseen modifications. Nat Methods 18, 1363–1369 (2021). https://doi.org/10.1038/s41592-021-01301-5

  [**Detectability - Pfly**]

  [4] Abdul-Khalek, N., Picciani, M., Wimmer, R., Overgaard, M. T., Wilhelm, M., & Gregersen Echers, S. (2024). To fly, or not to fly, that is the question: A deep learning model for peptide detectability prediction in mass spectrometry. bioRxiv, 2024-10.


pkgId: ee54c8dce21346b8ee571f852e829acfcc0584a27a433d51abad4aece456b5ee
name: python-dlt-help
arch: noarch
version: 1.5.0
epoch: 0
release: 1
summary: Development documents and examples for dlt
url: https://github.com/dlt-hub
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dlt-1.5.0-1.src.rpm
location_href: Packages/python-dlt-help-1.5.0-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
      <strong>data load tool (dlt) — the open-source Python library for data loading</strong>
  </h1>
  <p align="center">
  Be it a Google Colab notebook, AWS Lambda function, an Airflow DAG, your local laptop,<br/>or a GPT-4 assisted development playground—<strong>dlt</strong> can be dropped in anywhere.
  </p>


  <h3 align="center">

  🚀 Join our thriving community of likeminded developers and build the future together!

  </h3>

  <div align="center">
    <a target="_blank" href="https://dlthub.com/community" style="background:none">
      <img src="https://img.shields.io/badge/slack-join-dlt.svg?labelColor=191937&color=6F6FF7&logo=slack" style="width: 260px;"  />
    </a>
  </div>
  <div align="center">
    <a target="_blank" href="https://pypi.org/project/dlt/" style="background:none">
      <img src="https://img.shields.io/pypi/v/dlt?labelColor=191937&color=6F6FF7">
    </a>
    <a target="_blank" href="https://pypi.org/project/dlt/" style="background:none">
      <img src="https://img.shields.io/pypi/pyversions/dlt?labelColor=191937&color=6F6FF7">
    </a>
  </div>



  dlt supports Python 3.8+.

  ```sh
  pip install dlt
  ```

  More options: [Install via Conda or Pixi](https://dlthub.com/docs/reference/installation#install-dlt-via-pixi-and-conda)




  Load chess game data from chess.com API and save it in DuckDB:

  ```python
  import dlt
  from dlt.sources.helpers import requests



  pipeline = dlt.pipeline(
      pipeline_name='chess_pipeline',
      destination='duckdb',
      dataset_name='player_data'
  )


  data = []
  for player in ['magnuscarlsen', 'rpragchess']:
      response = requests.get(f'https://api.chess.com/pub/player/{player}')
      response.raise_for_status()
      data.append(response.json())


  pipeline.run(data, table_name='player')
  ```


  Try it out in our **[Colab Demo](https://colab.research.google.com/drive/1NfSB1DpwbbHX9_t5vlalBTf13utwpMGx?usp=sharing)**



  - **Automatic Schema:** Data structure inspection and schema creation for the destination.
  - **Data Normalization:** Consistent and verified data before loading.
  - **Seamless Integration:** Colab, AWS Lambda, Airflow, and local environments.
  - **Scalable:** Adapts to growing data needs in production.
  - **Easy Maintenance:** Clear data pipeline structure for updates.
  - **Rapid Exploration:** Quickly explore and gain insights from new data sources.
  - **Versatile Usage:** Suitable for ad-hoc exploration to advanced loading infrastructures.
  - **Start in Seconds with CLI:** Powerful CLI for managing, deploying and inspecting local pipelines.
  - **Incremental Loading:** Load only new or changed data and avoid loading old records again.
  - **Open Source:** Free and Apache 2.0 Licensed.



  Explore ready to use sources (e.g. Google Sheets) in the [Verified Sources docs](https://dlthub.com/docs/dlt-ecosystem/verified-sources) and supported destinations (e.g. DuckDB) in the [Destinations docs](https://dlthub.com/docs/dlt-ecosystem/destinations).



  For detailed usage and configuration, please refer to the [official documentation](https://dlthub.com/docs).



  You can find examples for various use cases in the [examples](docs/examples) folder.



  `dlt` follows the semantic versioning with the [`MAJOR.MINOR.PATCH`](https://peps.python.org/pep-0440/#semantic-versioning) pattern.

  * `major` means breaking changes and removed deprecations
  * `minor` new features, sometimes automatic migrations
  * `patch` bug fixes

  We suggest that you allow only `patch` level updates automatically:
  * Using the [Compatible Release Specifier](https://packaging.python.org/en/latest/specifications/version-specifiers/#compatible-release). For example **dlt~=1.0** allows only versions **>=1.0** and less than **<1.1**
  * Poetry [caret requirements](https://python-poetry.org/docs/dependency-specification/). For example **^1.0** allows only versions **>=1.0** to **<1.0**



  The dlt project is quickly growing, and we're excited to have you join our community! Here's how you can get involved:

  - **Connect with the Community**: Join other dlt users and contributors on our [Slack](https://dlthub.com/community)
  - **Report issues and suggest features**: Please use the [GitHub Issues](https://github.com/dlt-hub/dlt/issues) to report bugs or suggest new features. Before creating a new issue, make sure to search the tracker for possible duplicates and add a comment if you find one.
  - **Track progress of our work and our plans**: Please check out our [public Github project](https://github.com/orgs/dlt-hub/projects/9)
  - **Contribute Verified Sources**: Contribute your custom sources to the [dlt-hub/verified-sources](https://github.com/dlt-hub/verified-sources) to help other folks in handling their data tasks.
  - **Contribute code**: Check out our [contributing guidelines](CONTRIBUTING.md) for information on how to make a pull request.
  - **Improve documentation**: Help us enhance the dlt documentation.



  `dlt` is released under the [Apache 2.0 License](LICENSE.txt).


pkgId: b1be0e66797e3696a2ee761319fd0c664f6f11b28c19070ff41d2398ff2bd2ab
name: python-dms_check-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for dms_check
url: https://pypi.org/project/dms_check/
rpm_license: Google
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dms_check-0.1.4-1.src.rpm
location_href: Packages/python-dms_check-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  This script checks an Oracle database compatibility for DMS, generating a report in either text or HTML format.  It's designed to assist in verifying the readiness of a database for GCP Data Migration Service (DMS) processes.



  * **Configuration-driven:** Uses a YAML configuration file to define the database checks to perform.  This allows for easy customization and maintenance. Simply use --config option to provide a custom yaml.
  * **Secure password handling:** Supports password retrieval from Google Cloud Secret Manager, enhancing security.  Alternatively, you can directly provide the password as a command-line argument.
  * **Flexible output:** Generates reports in both text and HTML formats. The HTML report includes styling for improved readability.
  * **Error handling:** Includes basic error handling for missing environment variables and connection issues.




  * **Python 3.9+:** The script is written in Python and requires Python 3.9 or higher.



  pip install dms_check
  1. **Install dependencies:**  Install the Python package: pip install dms_check
  2. **(Optional) Configure Google Cloud Secret Manager:** If you choose to store the database password in Google Cloud Secret Manager, set the `GOOGLE_CLOUD_PROJECT` environment variable to your Google Cloud project ID.  Then, refer to the secret in your command-line argument (see Usage section).





  ```bash
  ora_check --user <your_oracle_username> --password <your_password> --host <your_host> --port <your_port> --service <your_service_name> [--config <config_file_path>] [--format text|html]
  ```

  **Example ( using tns):**
  If you are using Oracle Client and tns please ensure that LD_LIBRARY_PATH is updated with the oracle_client path. i.e:

  export LD_LIBRARY_PATH=~/oracle-client/instantclient_23_5:$LD_LIBRARY_PATH


  ```bash
  ora_check --user <your_oracle_username> --password <your_password> --tns <oracle_tns_alias> --tns_path <tnsnames.ora_path> [--config <config_file_path>] [--format text|html]
  ```

  * Replace `<your_username>`, `<your_password>`, `<your_host>`, `<your_port>`, and `<your_service_name>` with your Oracle database credentials and connection details.
  * You can use `gcp-secret:<secret_name>` for the `--password` argument to retrieve the password from Google Secret Manager.
  *  The `--format` argument specifies the output format (`text` or `html`).  Defaults to `text`.




  ```bash
  export GOOGLE_CLOUD_PROJECT="your-gcp-project-id"
  ora_check --user your_username --password gcp-secret:your-secret-name --host your_host --port 1521 --service your_service_name --format html
  ```


  **Optional - Configure the YAML file:** If you want to customize checks create/update the `config_oracle.yaml` file (or specify a different path using the `--config` command-line argument) in the same directory as the script.  This file should contain a list of database checks in YAML format.  See the example below.

  **Example `config_oracle.yaml`:**

  ```yaml
  owner_exclude_list: ['SYS', 'SYSTEM', 'CTXSYS', 'MDSYS', 'WMSYS', 'XDB', 'ORDDATA', 'AUDSYS', 'OJVMSYS', 'DBSFWUSER','DBSNMP', 'GSMADMIN_INTERNAL', 'DVSYS', 'OUTLN', 'APPQOSSYS', 'ORDSYS', 'LBACSYS']
  validations:
    - name: "Unsupported Columns"
      description: "Columns with unsupported data types"
      query: |
        SELECT
            OWNER,
            TABLE_NAME,
            COLUMN_NAME,
            DATA_TYPE
        FROM DBA_TAB_COLS
        WHERE DATA_TYPE IN (
          'ANYDATA', 'BFILE', 'INTERVAL DAY TO SECOND', 'INTERVAL YEAR TO MONTH',
          'LONG', 'LONG RAW', 'SDO_GEOMETRY', 'UDT', 'UROWID', 'XMLTYPE'
        )
        AND OWNER NOT IN ({owner_exclude_list})
      warning_message: |
        Warning: The following columns have unsupported data types and will be replaced with NULL values:
    - name: "Lob Data Types"
      description: "Checks for LOB data types"
      query: |
        SELECT
            OWNER,
            TABLE_NAME,
            COLUMN_NAME
        FROM DBA_TAB_COLS
        WHERE DATA_TYPE IN ('BLOB', 'CLOB', 'NCLOB') AND OWNER NOT IN ({owner_exclude_list})
      warning_message: |
        Warning: The following LOB columns are not replicated unless 'streamLargeObjects' is enabled:
    - name: "Tables without Primary Keys"
      description: "Tables missing primary keys"
      query: |
        SELECT
            OWNER,
            TABLE_NAME
        FROM DBA_TABLES
        WHERE TEMPORARY = 'N' AND OWNER NOT IN ({owner_exclude_list})
        AND (OWNER, TABLE_NAME) NOT IN (
          SELECT OWNER, TABLE_NAME FROM DBA_CONS_COLUMNS WHERE CONSTRAINT_NAME IN (
            SELECT CONSTRAINT_NAME FROM DBA_CONSTRAINTS WHERE CONSTRAINT_TYPE = 'P'
          )
        )
      warning_message: |
        Warning: The following tables have no primary keys, so ROWID will be used for merging and migration operations:
    - name: "Temporary Tables"
      description: "Temporary tables are unsupported"
      query: |
        SELECT
            OWNER,
            TABLE_NAME
        FROM DBA_TABLES
        WHERE TEMPORARY = 'Y' AND OWNER NOT IN ({owner_exclude_list})
      warning_message: |
        Warning: Temporary tables are not supported and will not be replicated:
    - name: "Logminer Limitations"
      description: "Checks for long table or column names that exceed LogMiner limits"
      query: |
        SELECT
            OWNER,
            TABLE_NAME,
            COLUMN_NAME
        FROM DBA_TAB_COLUMNS
        WHERE LENGTH(TABLE_NAME) > 30 OR LENGTH(COLUMN_NAME) > 30 AND OWNER NOT IN ({owner_exclude_list})
      warning_message: |
        Error: The following table or column names exceed LogMiner's 30-character limit and cannot be replicated:
    - name: "LOBs greater than 100mb"
      description: "Checks for lob column if they may exceed DMS limitation of 100mb"
      query: |
        SELECT
            owner,
            table_name,
            column_name,
            segment_name,
            sum(chunk) / (1024 * 1024) AS total_lob_size_in_mb,
            (sum(chunk) / (1024 * 1024))/COUNT(1) AS avg_lob_size_in_mb
        FROM
            dba_lobs
        WHERE
            segment_name IS NOT NULL
            AND OWNER NOT IN ({owner_exclude_list})
        GROUP BY owner, table_name, column_name, segment_name
        HAVING (sum(chunk) / (1024 * 1024))/COUNT(1) > 100
      warning_message: |
        Warning: The following lob columns may exceed DMS's 100mb limit and cannot be replicated:
    - name: "Unsupported Character Set"
      description: "Checks for unsupported character sets"
      query: |
        SELECT
            VALUE AS NLS_CHARACTERSET
        FROM NLS_DATABASE_PARAMETERS
        WHERE parameter='NLS_CHARACTERSET' and VALUE NOT IN ('AL16UTF16', 'AL32UTF8', 'IN8ISCII', 'JA16SJIS', 'US7ASCII', 'UTF8', 'WE8ISO8859P1', 'WE8ISO8859P9', 'WE8ISO8859P15', 'WE8MSWIN1252', 'ZHT16BIG5')
      warning_message: |
        Error: The database character set is not supported.
    - name: "Unsupported Table Names"
      description: "Checks for unsupported characters in table names"
      query: |
        SELECT
            OWNER,
            TABLE_NAME
        FROM DBA_TABLES
        WHERE REGEXP_LIKE(TABLE_NAME, '[^a-zA-Z0-9_]') AND OWNER NOT IN ({owner_exclude_list})
      warning_message: |
        Error: The following table names contain unsupported characters:
    - name: "Unsupported Column Names"
      description: "Checks for unsupported characters in column names"
      query: |
        SELECT
            OWNER,
            TABLE_NAME,
            COLUMN_NAME
        FROM DBA_TAB_COLUMNS
        WHERE REGEXP_LIKE(COLUMN_NAME, '[^a-zA-Z0-9_]') AND OWNER NOT IN ({owner_exclude_list})
      warning_message: |
        Error: The following column names contain unsupported characters:
    - name: "Too Many Tables"
      description: "Checks if the number of tables exceeds the limit"
      query: |
        SELECT COUNT(*) TABLE_COUNT FROM DBA_TABLES WHERE OWNER NOT IN ({owner_exclude_list})
        HAVING COUNT(*) > 10000
      warning_message: |
        Error: The number of tables exceeds the limit of 10,000.
    - name: "Index-Organized Tables"
      description: "Checks for Index-organized tables"
      query: |
        SELECT
            OWNER,
            TABLE_NAME
        FROM DBA_TABLES
        WHERE IOT_TYPE IS NOT NULL AND OWNER NOT IN ({owner_exclude_list})
      warning_message: |
        Error: Index-organized tables are not supported:
  ```



  Google


pkgId: 09beeebb571ec296e8eace4bcf7e3b8a61936ae306963cf36fca7aedc4180236
name: python-dns-smtp-email-validator-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for dns-smtp-email-validator
url: https://github.com/shaileshpandit141/dns-smtp-email-validator.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dns-smtp-email-validator-0.1.1-1.src.rpm
location_href: Packages/python-dns-smtp-email-validator-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  - **Email Format Validation**: Ensure the email address matches a valid format.
  - **Domain Validation**: Validate email domains against a customizable allowlist.
  - **MX Record Lookup**: Check for valid mail exchange (MX) records for the domain.
  - **SMTP Communication**: Optionally verify the existence of the recipient email address via the SMTP protocol.


pkgId: 34d1cbe859e576a484eb8422c7bbf136e9fda3cea99947190ffdd8744e9d4cb4
name: python-dnscli-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for dnscli
url: https://github.com/liwanggui/dnscli
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dnscli-0.0.3-1.src.rpm
location_href: Packages/python-dnscli-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  DNS 命令行工具，支持域名解析记录的增删改查。 现已适配以下DNS服务商

  - [阿里云](https://www.aliyun.com/)
  - [腾讯云](https://cloud.tencent.com/)
  - ...



  ```bash
  pip install dnscli
  ```



  - alidns: 阿里云 DNS 命令行工具
  - dnspod: 腾讯云 DNS 命令行工具



  以 alidns 为例，其他命令使用方式类似

  1. 配置 API 信息
      ```bash
      alidns configure --secret-id xxxxx --secret-key xxxxx
      ```
  2. 查看域名列表
      ```bash
      alidns list-domain
      +------+---------------+--------------+--------+
      | 序号 | 域名           | 创建时间       | 记录数  |
      +------+---------------+--------------+--------+
      | 1    | test1.com     | 1592393820.0 | 9      |
      | 2    | test2.com     | 1592393160.0 | 6      |
      | 3    | test.cn       | 1448347860.0 | 14     |
      +------+---------------+--------------+--------+
      ```
  3. 查看域名解析记录
      ```bash
      alidns list test.cn
      +------+--------+----------+-------------------------------------+---------+-----+--------------------+--------------+--------------+
      | 序号 | 子域名 | 记录类型 | 记录值                              | 线路    | TTL | 记录 ID            | 创建时间     | 更新时间     |
      +------+--------+----------+-------------------------------------+---------+-----+--------------------+--------------+--------------+
      | 1    | tt     | AAAA     | ::12                                | default | 600 | 913272411669522432 | 1724317196.0 | 1724317196.0 |
      | 2    | wfga   | CNAME    | www.baidu.com                       | default | 600 | 913225766055557120 | 1724294954.0 | 1724311099.0 |
      +------+--------+----------+-------------------------------------+---------+-----+--------------------+--------------+--------------+
      ```
  4. 添加域名解析记录
      ```bash
      alidns create test.cn -n abc -v 1.2.3.4
      +------+--------+----------+---------+---------+-----+----------+
      | 序号 | 子域名 | 记录类型 | 记录值  | 线路    | TTL | 执行状态 |
      +------+--------+----------+---------+---------+-----+----------+
      | 1    | abc    | A        | 1.2.3.4 | default | 600 | 创建成功 |
      +------+--------+----------+---------+---------+-----+----------+
      ```
  5. 更新域名解析记录
      ```bash
      alidns update test.cn -n abc -v 1.2.3.4 -nn foo -nv 22.2.111.1
      +------+--------+----------+------------+---------+-----+--------------------+----------+
      | 序号 | 子域名 | 记录类型 | 记录值     | 线路    | TTL | 记录ID             | 执行状态 |
      +------+--------+----------+------------+---------+-----+--------------------+----------+
      | 1    | foo    | A        | 22.2.111.1 | default | 600 | 913431792258240512 | 修改成功 |
      +------+--------+----------+------------+---------+-----+--------------------+----------+
      ```
  6. 删除域名解析记录
      ```bash
      alidns delete test.cn -n foo
      +------+--------+----------+------------+---------+-----+----------+
      | 序号 | 子域名 | 记录类型 | 记录值     | 线路    | TTL | 执行状态 |
      +------+--------+----------+------------+---------+-----+----------+
      | 1    | foo    | A        | 22.2.111.1 | default | 600 | 删除成功 |
      +------+--------+----------+------------+---------+-----+----------+
      ```
      > 注意：
      > 1. 删除记录时, 子域名为必须参数
      > 2. 删除记录时，只指定子域名，删除与子域名匹配的所有记录。
      > 3. 如需删除特定的记录，请指定 记录ID (--record-id)



  1. 创建虚拟环境
  2. 安装 `pip install -e .`


pkgId: 1eefc328c7b79275fb9eeadb95008c5b98d416f8e1ec9d76e6b9cc07b59b743d
name: python-do-sdk-platform-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for do-sdk-platform
url: https://pypi.org/project/do-sdk-platform/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-do-sdk-platform-1.1.0-1.src.rpm
location_href: Packages/python-do-sdk-platform-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
      No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)


pkgId: 6755342f8aed9f7856ff4bfcaacc4c7fcdc8c7fa20d21d04deaaf8b4e8bf1a76
name: python-doc-to-readme-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for doc-to-readme
url: https://github.com/ziselsberger/doc_to_readme
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-doc-to-readme-1.2.0-1.src.rpm
location_href: Packages/python-doc-to-readme-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  _Copyright &copy; 2023 by Mirjam Ziselsberger_
  _This code is free to use under the terms of the [MIT license](/LICENSE)._


  | Type | Name/Call | Description |
  | --- | --- | --- |
  | function  | <pre lang='py'>loop_through_repo(&#13;  file: str, &#13;  root_dir: str = None, &#13;  exclude_modules: Optional[Tuple[str, ...]] = None, &#13;  specified_modules: Optional[Tuple[str, ...]] = None&#13;) -> None</pre> | Collect documentation from functions & classes. |
  | function  | <pre lang='py'>add_summary_to_md(&#13;  overview_dict: Dict[str, Optional[Union[str, Dict[str, str]]]], &#13;  markdown: str, &#13;  separate: bool = True&#13;)</pre> | Add Table with all Functions & Classes to Markdown file. |
  | function  | <pre lang='py'>update_markdown_file(&#13;  file: str = "../../README.md", &#13;  root_dir: str = None, &#13;  exclude_modules: Optional[Tuple[str, ...]] = (&#13;    "test", &#13;    "functions_for_testing", &#13;    "classes_for_testing", &#13;    "doc_to_md"&#13;  ), &#13;  specified_modules: Optional[Tuple[str, ...]] = None, &#13;  separate: bool = True&#13;)</pre> | Add/update 'Functions & Classes' Section in Markdown file. |
  | function  | <pre lang='py'>parse_through_file(file: str) -> Dict[str, Dict[str, str]]</pre> | Parse through file, return dict with classes and functions. |

  | Type | Name/Call | Description |
  | --- | --- | --- |
  | class  | <pre lang='py'>LoopThroughRepo</pre> | None |
  | method (LoopThroughRepo) | <pre lang='py'>setUp(self) -> None</pre> | None |
  | method (LoopThroughRepo) | <pre lang='py'>test_loop_through_repo(self)</pre> | None |
  | method (LoopThroughRepo) | <pre lang='py'>test_loop_through_repo_specified_modules(self)</pre> | None |
  | method (LoopThroughRepo) | <pre lang='py'>test_loop_through_repo_exclude_modules(self)</pre> | None |
  Created with: [doc_to_readme](https://github.com/ziselsberger/doc_to_readme)

rpm_license:
  MIT License  Copyright (c) 2023 Mirjam Ziselsberger  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: 08194b940e3a8b2928b73ebecfa24e13ad68e181148f6521e3e0a6f87bcc4887
name: python-docapi-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for docapi
url: https://pypi.org/project/docapi/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-docapi-1.1.0-1.src.rpm
location_href: Packages/python-docapi-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - **Version 1.x.x** introduces significant changes compared to **Version 0.x.x**. Please refer to the updated usage guide below.
  - By default, generating or updating documentation requires the API service's dependency environment.


pkgId: fe1b022659e837277cad3cfd6c9379eeb13740c1852d9612254661b9ea2e11b2
name: python-docker-tidy-help
arch: noarch
version: 3.0.3
epoch: 0
release: 1
summary: Development documents and examples for docker-tidy
url: https://docker-tidy.geekdocs.de/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-docker-tidy-3.0.3-1.src.rpm
location_href: Packages/python-docker-tidy-help-3.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Keep docker hosts tidy

  [![Build Status](https://ci.thegeeklab.de/api/badges/thegeeklab/docker-tidy/status.svg)](https://ci.thegeeklab.de/repos/thegeeklab/docker-tidy)
  [![Docker Hub](https://img.shields.io/badge/docker-latest-blue.svg?logo=docker&logoColor=white)](https://hub.docker.com/r/thegeeklab/docker-tidy)
  [![Python Version](https://img.shields.io/pypi/pyversions/docker-tidy.svg)](https://pypi.org/project/docker-tidy/)
  [![PyPI Status](https://img.shields.io/pypi/status/docker-tidy.svg)](https://pypi.org/project/docker-tidy/)
  [![PyPI Release](https://img.shields.io/pypi/v/docker-tidy.svg)](https://pypi.org/project/docker-tidy/)
  [![GitHub contributors](https://img.shields.io/github/contributors/thegeeklab/docker-tidy)](https://github.com/thegeeklab/docker-tidy/graphs/contributors)
  [![Source: GitHub](https://img.shields.io/badge/source-github-blue.svg?logo=github&logoColor=white)](https://github.com/thegeeklab/docker-tidy)
  [![License: Apache-2.0](https://img.shields.io/github/license/thegeeklab/docker-tidy)](https://github.com/thegeeklab/docker-tidy/blob/main/LICENSE)

  This project is a fork of [Yelp/docker-custodian](https://github.com/Yelp/docker-custodian). Keep docker hosts tidy.

  You can find the full documentation at [https://docker-tidy.geekdocs.de](https://docker-tidy.geekdocs.de/).



  Special thanks to all [contributors](https://github.com/thegeeklab/docker-tidy/graphs/contributors). If you would like to contribute,
  please see the [instructions](https://github.com/thegeeklab/docker-tidy/blob/main/CONTRIBUTING.md).



  This project is licensed under the Apache-2.0 License - see the [LICENSE](https://github.com/thegeeklab/docker-tidy/blob/main/LICENSE) file for details.


pkgId: 0da48712c9586a85ea6e97c4752e255192c7ccdcb7e49d9bb5ec1b4764bd91cb
name: python-docling-core-help
arch: noarch
version: 2.10.0
epoch: 0
release: 1
summary: Development documents and examples for docling-core
url: https://ds4sd.github.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-docling-core-2.10.0-1.src.rpm
location_href: Packages/python-docling-core-help-2.10.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/docling-core)](https://pypi.org/project/docling-core/)
  ![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%20%203.11%20%7C%203.12%20%7C%203.13-blue)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
  [![Pydantic v2](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydantic/pydantic/main/docs/badge/v2.json)](https://pydantic.dev)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![License MIT](https://img.shields.io/github/license/ds4sd/docling-core)](https://opensource.org/licenses/MIT)

  Docling Core is a library that defines the data types in [Docling](https://github.com/DS4SD/docling), leveraging pydantic models.



  To use Docling Core, simply install `docling-core` from your package manager, e.g. pip:
  ```bash
  pip install docling-core
  ```



  To develop for Docling Core, you need Python 3.9 / 3.10 / 3.11 / 3.12 / 3.13 and Poetry. You can then install from your local clone's root dir:
  ```bash
  poetry install
  ```

  To run the pytest suite, execute:
  ```
  poetry run pytest test
  ```



  - You can validate your JSON objects using the pydantic class definition.

    ```py
    from docling_core.types import DoclingDocument

    data_dict = {...}  # here the object you want to validate, as a dictionary
    DoclingDocument.model_validate(data_dict)

    data_str = {...}  # here the object as a JSON string
    DoclingDocument.model_validate_json(data_str)
    ```

  - You can generate the JSON schema of a model with the script `generate_jsonschema`.

    ```py
    
    generate_jsonschema DoclingDocument

    
    generate_jsonschema Record
    ```



  Docling Core contains 3 top-level data types:

  - **DoclingDocument** for publications like books, articles, reports, or patents. The JSON that can be exported using Docling follows this schema.
    The DoclingDocument type also models the metadata that may be attached to the converted document.
    Check [DoclingDocument](docs/DoclingDocument.json) for the full JSON schema.
  - **Record** for structured database records, centered on an entity or _subject_ that is provided with a list of attributes.
    Related to records, the statements can represent annotations on text by Natural Language Processing (NLP) tools.
    Check [Record](docs/Record.json) for the full JSON schema.
  - **Generic** for any data representation, ensuring minimal configuration and maximum flexibility.
    Check [Generic](docs/Generic.json) for the full JSON schema.

  The data schemas are defined using [pydantic](https://pydantic-docs.helpmanual.io/) models, which provide built-in processes to support the creation of data that adhere to those models.



  Please read [Contributing to Docling Core](./CONTRIBUTING.md) for details.



  If you use Docling Core in your projects, please consider citing the following:

  ```bib
  @techreport{Docling,
    author = "Deep Search Team",
    month = 8,
    title = "Docling Technical Report",
    url = "https://arxiv.org/abs/2408.09869",
    eprint = "2408.09869",
    doi = "10.48550/arXiv.2408.09869",
    version = "1.0.0",
    year = 2024
  }
  ```



  The Docling Core codebase is under MIT license.
  For individual model usage, please refer to the model licenses found in the original packages.


pkgId: a2689ece158bf90aac68eabdaf667192420d2e0be92d8d6ed4f7d3f033ba2b3c
name: python-docling-help
arch: noarch
version: 2.12.0
epoch: 0
release: 1
summary: Development documents and examples for docling
url: https://github.com/DS4SD/docling
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-docling-2.12.0-1.src.rpm
location_href: Packages/python-docling-help-2.12.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/ds4sd/docling">
      <img loading="lazy" alt="Docling" src="https://github.com/DS4SD/docling/raw/main/docs/assets/docling_processing.png" width="100%"/>
    </a>
  </p>



  <p align="center">
    <a href="https://trendshift.io/repositories/12132" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12132" alt="DS4SD%2Fdocling | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
  </p>

  [![arXiv](https://img.shields.io/badge/arXiv-2408.09869-b31b1b.svg)](https://arxiv.org/abs/2408.09869)
  [![Docs](https://img.shields.io/badge/docs-live-brightgreen)](https://ds4sd.github.io/docling/)
  [![PyPI version](https://img.shields.io/pypi/v/docling)](https://pypi.org/project/docling/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/docling)](https://pypi.org/project/docling/)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![Pydantic v2](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydantic/pydantic/main/docs/badge/v2.json)](https://pydantic.dev)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![License MIT](https://img.shields.io/github/license/DS4SD/docling)](https://opensource.org/licenses/MIT)
  [![PyPI Downloads](https://static.pepy.tech/badge/docling/month)](https://pepy.tech/projects/docling)

  Docling parses documents and exports them to the desired format with ease and speed.



  * 🗂️ Reads popular document formats (PDF, DOCX, PPTX, XLSX, Images, HTML, AsciiDoc & Markdown) and exports to HTML, Markdown and JSON (with embedded and referenced images)
  * 📑 Advanced PDF document understanding including page layout, reading order & table structures
  * 🧩 Unified, expressive [DoclingDocument](https://ds4sd.github.io/docling/concepts/docling_document/) representation format
  * 🤖 Easy integration with 🦙 LlamaIndex & 🦜🔗 LangChain for powerful RAG / QA applications
  * 🔍 OCR support for scanned PDFs
  * 💻 Simple and convenient CLI

  Explore the [documentation](https://ds4sd.github.io/docling/) to discover plenty examples and unlock the full power of Docling!



  * ♾️ Equation & code extraction
  * 📝 Metadata extraction, including title, authors, references & language
  * 🦜🔗 Native LangChain extension



  To use Docling, simply install `docling` from your package manager, e.g. pip:
  ```bash
  pip install docling
  ```

  Works on macOS, Linux and Windows environments. Both x86_64 and arm64 architectures.

  More [detailed installation instructions](https://ds4sd.github.io/docling/installation/) are available in the docs.



  To convert individual documents, use `convert()`, for example:

  ```python
  from docling.document_converter import DocumentConverter

  source = "https://arxiv.org/pdf/2408.09869"  # document per local path or URL
  converter = DocumentConverter()
  result = converter.convert(source)
  print(result.document.export_to_markdown())  # output: "## Docling Technical Report[...]"
  ```

  More [advanced usage options](https://ds4sd.github.io/docling/usage/) are available in
  the docs.



  Check out Docling's [documentation](https://ds4sd.github.io/docling/), for details on
  installation, usage, concepts, recipes, extensions, and more.



  Go hands-on with our [examples](https://ds4sd.github.io/docling/examples/),
  demonstrating how to address different application use cases with Docling.



  To further accelerate your AI application development, check out Docling's native
  [integrations](https://ds4sd.github.io/docling/integrations/) with popular frameworks
  and tools.



  Please feel free to connect with us using the [discussion section](https://github.com/DS4SD/docling/discussions).



  For more details on Docling's inner workings, check out the [Docling Technical Report](https://arxiv.org/abs/2408.09869).



  Please read [Contributing to Docling](https://github.com/DS4SD/docling/blob/main/CONTRIBUTING.md) for details.



  If you use Docling in your projects, please consider citing the following:

  ```bib
  @techreport{Docling,
    author = {Deep Search Team},
    month = {8},
    title = {Docling Technical Report},
    url = {https://arxiv.org/abs/2408.09869},
    eprint = {2408.09869},
    doi = {10.48550/arXiv.2408.09869},
    version = {1.0.0},
    year = {2024}
  }
  ```



  The Docling codebase is under MIT license.
  For individual model usage, please refer to the model licenses found in the original packages.



  Docling has been brought to you by IBM.


pkgId: 2a57f0e662fe49a611be891912da841ffdb3fc5df75c542f48527071307973e0
name: python-docling-ibm-models-help
arch: noarch
version: 3.1.0
epoch: 0
release: 1
summary: Development documents and examples for docling-ibm-models
url: https://pypi.org/project/docling-ibm-models/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-docling-ibm-models-3.1.0-1.src.rpm
location_href: Packages/python-docling-ibm-models-help-3.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/docling-ibm-models)](https://pypi.org/project/docling-ibm-models/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/docling-ibm-models)](https://pypi.org/project/docling-ibm-models/)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![Models on Hugging Face](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Model-blue)](https://huggingface.co/ds4sd/docling-models/)
  [![License MIT](https://img.shields.io/github/license/ds4sd/deepsearch-toolkit)](https://opensource.org/licenses/MIT)



  AI modules to support the Docling PDF document conversion project.

  - TableFormer is an AI module that recognizes the structure of a table and the bounding boxes of the table content.
  - Layout model is an AI model that provides among other things ability to detect tables on the page. This package contains inference code for Layout model.






  To install `poetry` locally, use either `pip` or `homebrew`.

  To install `poetry` on a docker container, do the following:
  ```
  ENV POETRY_NO_INTERACTION=1 \
      POETRY_VIRTUALENVS_CREATE=false


  RUN curl -sSL 'https://install.python-poetry.org' > install-poetry.py \
      && python install-poetry.py \
      && poetry --version \
      && rm install-poetry.py
  ```

  To install and run the package, simply set up a poetry environment

  ```
  poetry env use $(which python3.10)
  poetry shell
  ```

  and install all the dependencies,

  ```
  poetry install # this will only install the deps from the poetry.lock

  poetry install --no-dev # this will skip installing dev dependencies
  ```

  To update or add new dependencies from `pyproject.toml`, rebuild `poetry.lock`
  ```
  poetry update
  ```



  When in development mode on MacOS with Intel chips, one can use compatible dependencies with

  ```console
  poetry update --with mac_intel
  ```



  ![Architecture](docs/tablemodel_overview_color.png)


  Below we list datasets used with their description, source, and ***"TableFormer Format"***. The TableFormer Format is our processed version of the version of the original format to work with the dataloader out of the box, and to augment the dataset when necassary to add missing groundtruth (bounding boxes for empty cells).


  | Name        | Description      | URL |
  | ------------- |:-------------:|----|
  | PubTabNet | PubTabNet contains heterogeneous tables in both image and HTML format, 516k+ tables in the PubMed Central Open Access Subset  | [PubTabNet](https://developer.ibm.com/exchanges/data/all/pubtabnet/) |
  | FinTabNet| A dataset for Financial Report Tables with corresponding ground truth location and structure. 112k+ tables included.| [FinTabNet](https://developer.ibm.com/exchanges/data/all/fintabnet/) |
  | TableBank| TableBank is a new image-based table detection and recognition dataset built with novel weak supervision from Word and Latex documents on the internet, contains 417K high-quality labeled tables. | [TableBank](https://github.com/doc-analysis/TableBank) |




  ![TableModel04](docs/tbm04.png)
  **TableModel04rs (OTSL)** is our SOTA method that using transformers in order to predict table structure and bounding box.




  Example configuration can be found inside test `tests/test_tf_predictor.py`
  These are the main sections of the configuration file:

  - `dataset`: The directory for prepared data and the parameters used during the data loading.
  - `model`: The type, name and hyperparameters of the model. Also the directory to save/load the
    trained checkpoint files.
  - `train`: Parameters for the training of the model.
  - `predict`: Parameters for the evaluation of the model.
  - `dataset_wordmap`: Very important part that contains token maps.




  You can download the model weights and config files from the links:

  - [TableFormer Checkpoint](https://huggingface.co/ds4sd/docling-models/tree/main/model_artifacts/tableformer)
  - [beehive_v0.0.5](https://huggingface.co/ds4sd/docling-models/tree/main/model_artifacts/layout/beehive_v0.0.5)




  You can run the inference tests for the models with:

  ```
  python -m pytest tests/
  ```

  This will also generate prediction and matching visualizations that can be found here:
  `tests\test_data\viz\`

  Visualization outlines:
  - `Light Pink`: border of recognized table
  - `Grey`: OCR cells
  - `Green`: prediction bboxes
  - `Red`: OCR cells matched with prediction
  - `Blue`: Post processed, match
  - `Bold Blue`: column header
  - `Bold Magenta`: row header
  - `Bold Brown`: section row (if table have one)




  A demo application allows to apply the `LayoutPredictor` on a directory `<input_dir>` that contains
  `png` images and visualize the predictions inside another directory `<viz_dir>`.

  First download the model weights (see above), then run:
  ```
  python -m demo.demo_layout_predictor -i <input_dir> -v <viz_dir>
  ```

  e.g.
  ```
  python -m demo.demo_layout_predictor -i tests/test_data/samples -v viz/
  ```


pkgId: 1d96a977a0f75d3d4ec21f5d5335b06649b49d1d39e0dfa32c80c4028bfb48cb
name: python-docplex-help
arch: noarch
version: 2.29.241
epoch: 0
release: 1
summary: Development documents and examples for docplex
url: https://www.ibm.com/cloud/decision-optimization-for-watson-studio
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-docplex-2.29.241-1.src.rpm
location_href: Packages/python-docplex-help-2.29.241-1.noarch.rpm
checksum_type: sha256
description:
  Welcome to the IBM Decision Optimization CPLEX Modeling for Python.
  Licensed under the Apache License v2.0.
  With this library, you can quickly and easily add the power of optimization to
  your application. You need IBM ILOG CPLEX Optimization Studio to solve the models.
  This library is composed of 2 modules:
      * IBM Decision Optimization CPLEX Optimizer Modeling for Python - with namespace docplex.mp
      * IBM Decision Optimization CP Optimizer Modeling for Python - with namespace docplex.cp
  Solving with CPLEX locally requires that IBM ILOG CPLEX Optimization Studio V12.8 or later
  is installed on your machine.
  This library is `numpy` friendly.
  `Documentation <http://ibmdecisionoptimization.github.io/docplex-doc/>`_
  `Examples <https://github.com/IBMDecisionOptimization/docplex-examples>`_


pkgId: cc11a2d723ec5dda677417a6010d8e26e3d5916cf314d184da66a8003a01353e
name: python-docsteady-help
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: Development documents and examples for docsteady
url: https://docsteady.lsst.io
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-docsteady-3.0.0-1.src.rpm
location_href: Packages/python-docsteady-help-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
  docsteady is a python package (and optionally Docker container) that talks to
  Jira and the Zephy Scale Test Management system to output Test folders and
  Test plans to a variety of documents by utilizing pandoc.

  Pip install the package ::
     pip install docsteady>1.2
  Credentials are needed by `docsteady` to log into JIRA. The easiest way to do this is
  by setting up the following environment variables::
    export ZEPHYR_TOKEN=<jira-token>
    export JIRA_USER=<user>
    export JIRA_PASSWORD=<password>
  The defaults of docsteady are to build documents based on DM defaults. The
  following commands are available:
  * `generate-spec`: to generate a Test Specification (baselining test cases)
  * `generate-report`: for test plans and reports
  * `generate-vcd`: to generate the Verification Control Documents
  * `baseline-ve`: to generate Verification Elements baseline documents.
  See [the docsteady documentation](https://docsteady.lsst.io/).

  Please refer to the [Developer Guide](https://docsteady.lsst.io/developer.html) for contribution information.

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


pkgId: 921c078f05ab5746a7ea548e5e29cb04e70461fa357f6446438cb2fd8926cfc5
name: python-doctor-trans-debuginfo
arch: aarch64
version: 1.0.1
epoch: 0
release: 1
summary: Debug information for package python-doctor-trans
url: https://pypi.org/project/doctor-trans/
rpm_license: None
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-doctor-trans-1.0.1-1.src.rpm
location_href: Packages/python-doctor-trans-debuginfo-1.0.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-doctor-trans.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 3882362941fad587444ebd86376c5be625203587158948740c17ba942517c6da
name: python-doctor-trans-debugsource
arch: aarch64
version: 1.0.1
epoch: 0
release: 1
summary: Debug sources for package python-doctor-trans
url: https://pypi.org/project/doctor-trans/
rpm_license: None
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-doctor-trans-1.0.1-1.src.rpm
location_href: Packages/python-doctor-trans-debugsource-1.0.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-doctor-trans.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: bd7cd40d00c75ff6a1cccb87d7ceb3a05db7adf4a32f67fe2bd8e4e674de562c
name: python-doctor-trans-help
arch: aarch64
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for doctor-trans
url: https://pypi.org/project/doctor-trans/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-doctor-trans-1.0.1-1.src.rpm
location_href: Packages/python-doctor-trans-help-1.0.1-1.aarch64.rpm
checksum_type: sha256
description:
  Doctor Trans is a powerful Python package for translating large datasets in a DataFrame format. It process multiple columns simultaneously, translating text data from one language to another while preserving data integrity. The package outputs the translated DataFrame, making it perfect for large-scale multilingual data processing in business and research.


  - **Automatic Language Detection**: Automatically detects the source language if not specified.
  - **Multiple Language Support**: Supports translation to and from any language available in Google Translate.
  - **Error Handling and Logging**: Provides detailed logging to track translation status and handle errors effectively.


  To use Doctor Trans, ensure the following packages are installed:
  ```bash
  pip install pandas requests openpyxl
  ```
  If Microsoft Visual C++ 14.0 is not installed, you can download it here:
  https://visualstudio.microsoft.com/visual-cpp-build-tools/

  ```python
  import pandas as pd
  from doctor_trans import trans


  data = {
      'Name': ['Hola', 'Bonjour', 'Ciao'],
      'Description': ['Buenos días', 'Bonne journée', 'Buona giornata']
  }
  df = pd.DataFrame(data)


  df = trans(df, input_lang='auto', output_lang='en')

  df.to_excel("translated_file.xlsx", index=False)
  ```


  - **df:** The DataFrame containing text data to translate.
  - **input_lang:** (optional) The source language code. Default is 'auto' for automatic detection.
  - **output_lang:** (optional) The target language code. Default is 'en' for English.


  Make multilingual data processing effortless with Doctor Trans. If you find this package helpful, please refer to your developer friends! 🙂


pkgId: 77c22e74425690bb33ff1b642a49f74cb274318760f273213003b68ae0073034
name: python-document-to-podcast-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for document-to-podcast
url: https://pypi.org/project/document-to-podcast/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-document-to-podcast-1.0.1-1.src.rpm
location_href: Packages/python-document-to-podcast-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  The fastest way to get started. Click the button below to launch the project directly in GitHub Codespaces:
  [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://github.com/codespaces/new?hide_repo_select=true&ref=main&repo=888426876&skip_quickstart=true&machine=standardLinux32gb)
  Once the Codespaces environment launches, inside the terminal, start the Streamlit demo by running:
     ```bash
     python -m streamlit run demo/app.py
     ```

  1. **Clone the Repository**
     Inside the Codespaces terminal, run:
     ```bash
     git clone https://github.com/mozilla-ai/document-to-podcast.git
     cd document-to-podcast
     ```
  2. **Install Dependencies**
     Inside the terminal, run:
     ```bash
     pip install -e .
  3. **Run the Demo**
     Inside the terminal, start the Streamlit demo by running:
     ```bash
     python -m streamlit run demo/app.py
     ```
  ***NOTE***: The first time you run the demo app it might take a while to generate the script or the audio because it will download the models to the machine which are a few GBs in size.

  <img src="./images/document-to-podcast-diagram.png" width="1200" />
  1. **Document Upload**
     Start by uploading a document in a supported format (e.g., PDF, .txt, or .docx).
  2. **Document Pre-Processing**
     The uploaded document is processed to extract and clean the text. This involves:
     - Extracting readable text from the document.
     - Removing noise such as URLs, email addresses, and special characters to ensure the text is clean and structured.
  3. **Script Generation**
     The cleaned text is passed to a language model to generate a podcast transcript in the form of a conversation between two speakers.
     - **Model Loading**: The system selects and loads a pre-trained LLM optimized for running locally, using the llama_cpp library. This enables the model to run efficiently on CPUs, making them more accessible and suitable for local setups.
     - **Customizable Prompt**: A user-defined "system prompt" guides the LLM in shaping the conversation, specifying tone, content, speaker interaction, and format.
     - **Output Transcript**: The model generates a podcast script in structured format, with each speaker's dialogue clearly labeled.
       Example output:
       ```json
       {
           "Speaker 1": "Welcome to the podcast on AI advancements.",
           "Speaker 2": "Thank you! So what's new this week for the latest AI trends?",
           "Speaker 1": "Where should I start.. Lots has been happening!",
       }
       ```
     This step ensures that the podcast script is engaging, relevant, and ready for audio conversion.
  4. **Audio Generation**
    - The generated transcript is converted into audio using a Text-to-Speech (TTS) model.
    -	Each speaker is assigned a distinct voice.
  	- The final output is saved as an audio file in formats like MP3 or WAV.

  The architecture of this codebase focuses on modularity and adaptability, meaning it shouldn't be too difficult to swap frameworks to use your own suite of models. We have selected fully open source models that are very memory efficient and can run on a laptop CPU with less than 10GB RAM requirements.

  We are using the [llama.cpp](https://github.com/ggerganov/llama.cpp) library, which supports open source models optimized for local inference and minimal hardware requirements. The default text-to-text model in this repo is the open source [OLMoE-7B-Instruct](https://huggingface.co/allenai/OLMoE-1B-7B-0924-Instruct) from [AllenAI](https://allenai.org/).
  For the complete list of models supported out-of-the-box, visit this [link](https://github.com/ggerganov/llama.cpp?tab=readme-ov-file#text-only).

  We support models from the [OuteAI](https://github.com/edwko/OuteTTS) and [Parler_tts](https://github.com/huggingface/parler-tts) packages. The default text-to-speech model in this repo is [OuteTTS-0.2-500M](https://huggingface.co/OuteAI/OuteTTS-0.2-500M). Note that the `0.1-350M` version has a `CC-By-4.0` (permissive) license, whereas the newer / better `0.2-500M` version has a `CC-By-NC-4.0` (non-commercial) license.
  For a complete list of models visit [Oute HF](https://huggingface.co/collections/OuteAI) (only the GGUF versions) and [Parler HF](https://huggingface.co/collections/parler-tts).
  **Important note:** In order to keep the package dependencies as lightweight as possible, only the Oute interface is installed by default. If you want to use the parler models, please also follow the instructions at https://github.com/huggingface/parler-tts.

  - **System requirements**:
    - OS: Windows, macOS, or Linux
    - Python 3.10>, <3.12
    - Minimum RAM: 10 GB
    - Disk space: 32 GB minimum
  - **Dependencies**:
    - Dependencies listed in `pyproject.toml`

  > When starting up the codespace, I get the message `Oh no, it looks like you are offline!`
  If you are on Firefox and have Enhanced Tracking Protection `On`, try turning it `Off` for the codespace webpage.
  > During the installation of the package, it fails with `ERROR: Failed building wheel for llama-cpp-python`
  You are probably missing the `GNU Make` package. A quick way to solve it is run on your terminal `sudo apt install build-essential`

  This project is licensed under the Apache 2.0 License. See the [LICENSE](LICENSE) file for details.


pkgId: e087bc70e095b66068d3bb99d8bcc70c138581c09ec658d6bb614fbe9efda7ac
name: python-docuscospacy-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for docuscospacy
url: https://github.com/browndw/docuscospacy
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-docuscospacy-0.3.1-1.src.rpm
location_href: Packages/python-docuscospacy-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  |pypi| |pypi_downloads| |rtd| |zenodo|
  The *docuscospacy* package contains a set of functions to facilitate the processing of tagged corpora using:
  * `en_docusco_spacy <https://huggingface.co/browndw/en_docusco_spacy>`_ -- a spaCy model trained on the `CLAWS7 <https://ucrel.lancs.ac.uk/claws7tags.html>`_ tagset and `DocuScope <https://docuscospacy.readthedocs.io/en/latest/docuscope.html>`_
  The current version of the package runs in `polars <https://docs.pola.rs/api/python/stable/reference/index.html>`_
  The package can also convert a corpus to and from:
  * `tmtoolkit <https://tmtoolkit.readthedocs.io/en/latest/>`_ --  a set of tools for text mining and topic modeling
  The documentation for docuscospacy is available on `docuscospacy.readthedocs.org <https://docuscospacy.readthedocs.org>`_ and the GitHub code repository is on
  `github.com/browndw/docuscospacy <https://github.com/browndw/docuscospacy>`_.


pkgId: 76b3ce8ab8243e19cbbccb5c9b24033c9f0fd669fac8c9dc48d71a3da04801d8
name: python-dodopayments-help
arch: noarch
version: 0.11.0
epoch: 0
release: 1
summary: Development documents and examples for dodopayments
url: https://github.com/dodopayments/dodopayments-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dodopayments-0.11.0-1.src.rpm
location_href: Packages/python-dodopayments-help-0.11.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/dodopayments.svg)](https://pypi.org/project/dodopayments/)

  The Dodo Payments Python library provides convenient access to the Dodo Payments REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [docs.dodopayments.com](https://docs.dodopayments.com). The full API of this library can be found in [api.md](https://github.com/dodopayments/dodopayments-python/tree/main/api.md).



  ```sh

  pip install dodopayments
  ```



  The full API of this library can be found in [api.md](https://github.com/dodopayments/dodopayments-python/tree/main/api.md).

  ```python
  from dodopayments import DodoPayments

  client = DodoPayments(
      
      environment="test_mode",
  )

  payment = client.payments.create(
      billing={
          "city": "city",
          "country": "AF",
          "state": "state",
          "street": "street",
          "zipcode": 0,
      },
      customer={
          "email": "email",
          "name": "name",
      },
      product_cart=[
          {
              "product_id": "product_id",
              "quantity": 0,
          }
      ],
  )
  print(payment.payment_id)
  ```

  While you can provide a `bearer_token` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `DOOD_PAYMENTS_API_KEY="My Bearer Token"` to your `.env` file
  so that your Bearer Token is not stored in source control.



  Simply import `AsyncDodoPayments` instead of `DodoPayments` and use `await` with each API call:

  ```python
  import asyncio
  from dodopayments import AsyncDodoPayments

  client = AsyncDodoPayments(
      
      environment="test_mode",
  )


  async def main() -> None:
      payment = await client.payments.create(
          billing={
              "city": "city",
              "country": "AF",
              "state": "state",
              "street": "street",
              "zipcode": 0,
          },
          customer={
              "email": "email",
              "name": "name",
          },
          product_cart=[
              {
                  "product_id": "product_id",
                  "quantity": 0,
              }
          ],
      )
      print(payment.payment_id)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  List methods in the Dodo Payments API are paginated.

  This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:

  ```python
  from dodopayments import DodoPayments

  client = DodoPayments()

  all_payments = []

  for payment in client.payments.list():
      
      all_payments.append(payment)
  print(all_payments)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from dodopayments import AsyncDodoPayments

  client = AsyncDodoPayments()


  async def main() -> None:
      all_payments = []
      
      async for payment in client.payments.list():
          all_payments.append(payment)
      print(all_payments)


  asyncio.run(main())
  ```

  Alternatively, you can use the `.has_next_page()`, `.next_page_info()`, or `.get_next_page()` methods for more granular control working with pages:

  ```python
  first_page = await client.payments.list()
  if first_page.has_next_page():
      print(f"will fetch next page using these details: {first_page.next_page_info()}")
      next_page = await first_page.get_next_page()
      print(f"number of items we just fetched: {len(next_page.items)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.payments.list()
  for payment in first_page.items:
      print(payment.payment_id)


  ```



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `dodopayments.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `dodopayments.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `dodopayments.APIError`.

  ```python
  import dodopayments
  from dodopayments import DodoPayments

  client = DodoPayments()

  try:
      client.payments.create(
          billing={
              "city": "city",
              "country": "AF",
              "state": "state",
              "street": "street",
              "zipcode": 0,
          },
          customer={
              "email": "email",
              "name": "name",
          },
          product_cart=[
              {
                  "product_id": "product_id",
                  "quantity": 0,
              }
          ],
      )
  except dodopayments.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except dodopayments.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except dodopayments.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from dodopayments import DodoPayments


  client = DodoPayments(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).payments.create(
      billing={
          "city": "city",
          "country": "AF",
          "state": "state",
          "street": "street",
          "zipcode": 0,
      },
      customer={
          "email": "email",
          "name": "name",
      },
      product_cart=[
          {
              "product_id": "product_id",
              "quantity": 0,
          }
      ],
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from dodopayments import DodoPayments


  client = DodoPayments(
      
      timeout=20.0,
  )


  client = DodoPayments(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).payments.create(
      billing={
          "city": "city",
          "country": "AF",
          "state": "state",
          "street": "street",
          "zipcode": 0,
      },
      customer={
          "email": "email",
          "name": "name",
      },
      product_cart=[
          {
              "product_id": "product_id",
              "quantity": 0,
          }
      ],
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/dodopayments/dodopayments-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `DODO_PAYMENTS_LOG` to `info`.

  ```shell
  $ export DODO_PAYMENTS_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from dodopayments import DodoPayments

  client = DodoPayments()
  response = client.payments.with_raw_response.create(
      billing={
          "city": "city",
          "country": "AF",
          "state": "state",
          "street": "street",
          "zipcode": 0,
      },
      customer={
          "email": "email",
          "name": "name",
      },
      product_cart=[{
          "product_id": "product_id",
          "quantity": 0,
      }],
  )
  print(response.headers.get('X-My-Header'))

  payment = response.parse()  # get the object that `payments.create()` would have returned
  print(payment.payment_id)
  ```

  These methods return an [`APIResponse`](https://github.com/dodopayments/dodopayments-python/tree/main/src/dodopayments/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/dodopayments/dodopayments-python/tree/main/src/dodopayments/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.payments.with_streaming_response.create(
      billing={
          "city": "city",
          "country": "AF",
          "state": "state",
          "street": "street",
          "zipcode": 0,
      },
      customer={
          "email": "email",
          "name": "name",
      },
      product_cart=[
          {
              "product_id": "product_id",
              "quantity": 0,
          }
      ],
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from dodopayments import DodoPayments, DefaultHttpxClient

  client = DodoPayments(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/dodopayments/dodopayments-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import dodopayments
  print(dodopayments.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/dodopayments/dodopayments-python/tree/main/./CONTRIBUTING.md).


pkgId: ada2d9c16bf7672b75987619df7c3b5e166eab208877cc215a0d4f5cb9f597bb
name: python-dol-help
arch: noarch
version: 0.2.94
epoch: 0
release: 1
summary: Development documents and examples for dol
url: https://github.com/i2mint/dol
rpm_license: mit
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dol-0.2.94-1.src.rpm
location_href: Packages/python-dol-help-0.2.94-1.noarch.rpm
checksum_type: sha256
description:
  Base builtin tools make and transform data object layers (dols).

  The main idea comes in many names such as
  [Data Access Object (DAO)](https://en.wikipedia.org/wiki/Data_access_object),
  [Repository Pattern](https://www.cosmicpython.com/book/chapter_02_repository.html),
  [Hexagonal architecture, or ports and adapters architecture](https://en.wikipedia.org/wiki/Hexagonal_architecture_(software))
  for data.
  But simply put, what `dol` provides is tools to make your interface with data be domain-oriented, simple, and isolated from the underlying data infrastucture. This makes the business logic code simple and stable, enables you to develop and test it without the need of any data infrastructure, and allows you to change this infrastructure independently.

  The package is light-weight: Pure python; no third-party dependencies.

  To install:	```pip install dol```

  [Documentation here](https://i2mint.github.io/dol/)



  Say you have a source backend that has pickles of some lists-of-lists-of-strings,
  using the `.pkl` extension, and you want to copy this data to a target backend,
  but saving them as gzipped csvs with the `csv.gz` extension.

  We'll first work with dictionaries instead of files here, so we can test more easily,
  and safely.

  ```python
  import pickle

  src_backend = {
      'file_1.pkl': pickle.dumps([['A', 'B', 'C'], ['one', 'two', 'three']]),
      'file_2.pkl': pickle.dumps([['apple', 'pie'], ['one', 'two'], ['hot', 'cold']]),
  }
  targ_backend = dict()
  ```

  Here's how you can do it with `dol` tools

  ```python
  from dol import ValueCodecs, KeyCodecs, Pipe


  src_wrap = Pipe(KeyCodecs.suffixed('.pkl'), ValueCodecs.pickle())




  targ_wrap = Pipe(
      KeyCodecs.suffixed('.csv.gz'),
      ValueCodecs.csv() + ValueCodecs.str_to_bytes() + ValueCodecs.gzip()
  )


  src = src_wrap(src_backend)
  targ = targ_wrap(targ_backend)


  print(f"Before: {list(targ_backend)=}")
  targ.update(src)
  print(f"After: {list(targ_backend)=}")
  ```

  From the point of view of src and targ, you see the same thing.

  ```python
  assert list(src) == list(targ) == ['file_1', 'file_2']
  assert (
      src['file_1']
      == targ['file_1']
      == [['A', 'B', 'C'], ['one', 'two', 'three']]
  )
  ```

  But the backend of targ is different:

  ```python
  src_backend['file_1.pkl']

  targ_backend['file_1.csv.gz']

  ```

  Now that you've tested your setup with dictionaries, you're ready to move on to real,
  persisted storage. If you wanted to do this with local files, you'd:

  ```python
  from dol import Files
  src = Files('PATH_TO_LOCAL_SOURCE_FOLDER')
  targ = Files('PATH_TO_LOCAL_TARGET_FOLDER)
  ```

  But you could do this with AWS S3 using tools from
  [s3dol](https://github.com/i2mint/s3dol), or Azure using tools from
  [azuredol](https://github.com/i2mint/azuredol), or mongoDB with
  [mongodol](https://github.com/i2mint/mongodol),
  github with [hubcap](https://github.com/thorwhalen/hubcap), and so on...

  All of these extensions provide adapters from various data sources/targets to the
  dict-like interface (called "Mapping" in python typing).
  What `dol` provides are base tools to make a path from these to the interface
  that makes sense for the domain, or business logic in front of you,
  so that you can purify your code from implementation details, and therefore be
  create more robust and flexible code as far as data operations are concerned.




  Note: This project started as [`py2store`](https://github.com/i2mint/py2store).
  `dol` is the core of py2store has now been factored out
  and many of the specialized data object layers moved to separate packages.
  `py2store` is acting more as an aggregator package -- a shoping mall where you can quickly access many (but not all)
  functionalities that use `dol`.

  It's advised to use `dol` (and/or its specialized spin-off packages) directly when the core functionality is all you need.




  Storage CRUD how and where you want it.

  List, read, write, and delete data in a structured data source/target,
  as if manipulating simple python builtins (dicts, lists), or through the interface **you** want to interact with,
  with configuration or physical particularities out of the way.
  Also, being able to change these particularities without having to change the business-logic code.

  If you're not a "read from top to bottom" kinda person, here are some tips:
  [Quick peek](#quick-peek) will show you a simple example of how it looks and feels.
  [Use cases](#use-cases) will give you an idea of how py2store can be useful to you, if at all.

  The section with the best bang for the buck is probably
  [remove (much of the) data access entropy](#remove-data-access-entropy).
  It will give you simple (but real) examples of how to use `py2store` tooling
  to bend your interface with data to your will.

  [How it works](#a-few-words-about-design) will give you a sense of how it works.
  [More examples](https://github.com/i2mint/py2store#more-examples)
  will give you a taste of how you can adapt the three main aspects of
  storage (persistence, serialization, and indexing) to your needs.

  Install it (e.g. `pip install py2store`).



  Think of type of storage you want to use and just go ahead, like you're using a dict.
  Here's an example for local storage (you must you string keys only here).

  ```pydocstring
  >>> from py2store import QuickStore
  >>>
  >>> store = QuickStore()  # will print what (tmp) rootdir it is choosing
  >>> # Write something and then read it out again
  >>> store['foo'] = 'baz'
  >>> 'foo' in store  # do you have the key 'foo' in your store?
  True
  >>> store['foo']  # what is the value for 'foo'?
  'baz'
  >>>
  >>> # Okay, it behaves like a dict, but go have a look in your file system,
  >>> # and see that there is now a file in the rootdir, named 'foo'!
  >>>
  >>> # Write something more complicated
  >>> store['hello/world'] = [1, 'flew', {'over': 'a', "cuckoo's": map}]
  >>> stored_val = store['hello/world']
  >>> stored_val == [1, 'flew', {'over': 'a', "cuckoo's": map}]  # was it retrieved correctly?
  True
  >>>
  >>> # how many items do you have now?
  >>> assert len(store) >= 2  # can't be sure there were no elements before, so can't assert == 2
  >>>
  >>> # delete the stuff you've written
  >>> del store['foo']
  >>> del store['hello/world']
  ```

  `QuickStore` will by default store things in local files, using pickle as the serializer.
  If a root directory is not specified,
  it will use a tmp directory it will create (the first time you try to store something)
  It will create any directories that need to be created to satisfy any/key/that/contains/slashes.
  Of course, everything is configurable.



  `py2store` provides tools to create the dict-like interface to data you need.
  If you want to just use existing interfaces, build on it, or find examples of how to make such
  interfaces, check out the ever-growing list of `py2store`-using projects:

  - [mongodol](https://github.com/i2mint/mongodol): For MongoDB
  - [hear](https://github.com/otosense/hear): Read/write audio data flexibly.
  - [tabled](https://github.com/i2mint/tabled): Data as `pandas.DataFrame` from various sources
  - [msword](https://pypi.org/project/msword/): Simple mapping view to docx (Word Doc) elements
  - [sshdol](https://github.com/i2mint/sshdol): Remote (ssh) files access
  - [haggle](https://github.com/otosense/haggle): Easily search, download, and use kaggle datasets.
  - [pyckup](https://github.com/i2mint/pyckup): Grab data simply and define protocols for others to do the same.
  - [hubcap](https://pypi.org/project/hubcap/): Dict-like interface to github.
  - [graze](https://github.com/thorwhalen/graze): Cache the internet.
  - [grub](https://github.com/thorwhalen/grub): A ridiculously simple search engine maker.

  Just for fun projects:
  - [cult](https://github.com/thorwhalen/cult): Religious texts search engine. 18mn application of `grub`.
  - [laugh](https://github.com/thorwhalen/laugh): A (py2store-based) joke finder.







  How many times did someone share some data with you in the form of a zip of some nested folders
  whose structure and naming choices are fascinatingly obscure? And how much time do you then spend to write code
  to interface with that freak of nature? Well, one of the intents of py2store is to make that easier to do.
  You still need to understand the structure of the data store and how to deserialize these datas into python
  objects you can manipulate. But with the proper tool, you shouldn't have to do much more than that.



  Ever have to switch where you persist things (say from file system to S3), or change the way key into your data,
  or the way that data is serialized? If you use py2store tools to separate the different storage concerns,
  it'll be quite easy to change, since change will be localized. And if you're dealing with code that was already
  written, with concerns all mixed up, py2store should still be able to help since you'll be able to
  more easily give the new system a facade that makes it look like the old one.

  All of this can also be applied to data bases as well, in-so-far as the CRUD operations you're using
  are covered by the base methods.



  Shinny new storage mechanisms (DBs etc.) are born constantly, and some folks start using them, and we are eventually lead to use them
  as well if we need to work with those folks' systems. And though we'd love to learn the wonderful new
  capabilities the new kid on the block has, sometimes we just don't have time for that.

  Wouldn't it be nice if someone wrote an adapter to the new system that had an interface we were familiar with?
  Talking to SQL as if it were mongo (or visa versa). Talking to S3 as if it were a file system.
  Now it's not a long term solution: If we're really going to be using the new system intensively, we
  should learn it. But when you just got to get stuff done, having a familiar facade to something new
  is a life saver.

  py2store would like to make it easier for you roll out an adapter to be able to talk
  to the new system in the way **you** are familiar with.



  You have a new project or need to write a new app. You'll need to store stuff and read stuff back.
  Stuff: Different kinds of resources that your app will need to function. Some people enjoy thinking
  of how to optimize that aspect. I don't. I'll leave it to the experts to do so when the time comes.
  Often though, the time is later, if ever. Few proof of concepts and MVPs ever make it to prod.

  So instead, I'd like to just get on with the business logic and write my program.
  So what I need is an easy way to get some minimal storage functionality.
  But when the time comes to optimize, I shouldn't have to change my code, but instead just change the way my
  DAO does things. What I need is py2store.




  Data comes from many different sources, organization, and formats.

  Data is needed in many different contexts, which comes with its own natural data organization and formats.

  In between both: A entropic mess of ad-hoc connections and annoying time-consuming and error prone boilerplate.

  `py2store` (and it's now many extensions) is there to mitigate this.

  The design gods say SOC, DRY, SOLID* and such. That's good design, yes. But it can take more work to achieve these principles.
  We'd like to make it _easier_ to do it right than do it wrong.

  _(*) Separation (Of) Concerns, Don't Repeat Yourself, https://en.wikipedia.org/wiki/SOLID))_

  We need to determine what are the most common operations we want to do on data, and decide on a common way to express these operations, no matter what the implementation details are.
  - get/read some data
  - set/write some data
  - list/see what data we have
  - filter
  - cache
  ...

  Looking at this, we see that the base operations for complex data systems such as data bases and file systems overlap significantly with the base operations on python (or any programming language) objects.

  So we'll reflect this in our choice of a common "language" for these operations. For examples, once projected to a `py2store` object, iterating over the contents of a data base, or over files, or over the elements of a python (iterable) object should look the same, in code. Achieving this, we achieve SOC, but also set ourselves up for tooling that can assume this consistency, therefore be DRY, and many of the SOLID principles of design.

  Also mentionable: So far, `py2store` core tools are all pure python -- no dependencies on anything else.

  Now, when you want to specialize a store (say talk to data bases, web services, acquire special formats (audio, etc.)), then you'll need to pull in a few helpful packages. But the core tooling is pure.




  By store we mean key-value store. This could be files in a filesystem, objects in s3, or a database. Where and
  how the content is stored should be specified, but StoreInterface offers a dict-like interface to this.

      __getitem__ calls: _id_of_key			                    _obj_of_data
      __setitem__ calls: _id_of_key		        _data_of_obj
      __delitem__ calls: _id_of_key
      __iter__    calls:	            _key_of_id

  ```pydocstring
  >>> from dol import Store
  ```

  A Store can be instantiated with no arguments. By default it will make a dict and wrap that.

  ```pydocstring
  >>> # Default store: no key or value conversion ################################################
  >>> s = Store()
  >>> s['foo'] = 33
  >>> s['bar'] = 65
  >>> assert list(s.items()) == [('foo', 33), ('bar', 65)]
  >>> assert list(s.store.items()) == [('foo', 33), ('bar', 65)]  # see that the store contains the same thing
  ```

  Now let's make stores that have a key and value conversion layer
  input keys will be upper cased, and output keys lower cased
  input values (assumed int) will be converted to ascii string, and visa versa

  ```pydocstring
  >>>
  >>> def test_store(s):
  ...     s['foo'] = 33  # write 33 to 'foo'
  ...     assert 'foo' in s  # __contains__ works
  ...     assert 'no_such_key' not in s  # __nin__ works
  ...     s['bar'] = 65  # write 65 to 'bar'
  ...     assert len(s) == 2  # there are indeed two elements
  ...     assert list(s) == ['foo', 'bar']  # these are the keys
  ...     assert list(s.keys()) == ['foo', 'bar']  # the keys() method works!
  ...     assert list(s.values()) == [33, 65]  # the values() method works!
  ...     assert list(s.items()) == [('foo', 33), ('bar', 65)]  # these are the items
  ...     assert list(s.store.items()) == [('FOO', '!'), ('BAR', 'A')]  # but note the internal representation
  ...     assert s.get('foo') == 33  # the get method works
  ...     assert s.get('no_such_key', 'something') == 'something'  # return a default value
  ...     del(s['foo'])  # you can delete an item given its key
  ...     assert len(s) == 1  # see, only one item left!
  ...     assert list(s.items()) == [('bar', 65)]  # here it is
  >>>
  ```

  We can introduce this conversion layer in several ways.

  Here are few...


  ```pydocstring
  >>> # by subclassing ###############################################################################
  >>> class MyStore(Store):
  ...     def _id_of_key(self, k):
  ...         return k.upper()
  ...     def _key_of_id(self, _id):
  ...         return _id.lower()
  ...     def _data_of_obj(self, obj):
  ...         return chr(obj)
  ...     def _obj_of_data(self, data):
  ...         return ord(data)
  >>> s = MyStore(store=dict())  # note that you don't need to specify dict(), since it's the default
  >>> test_store(s)
  >>>
  ```



  ```pydocstring
  >>> # by assigning functions to converters ##########################################################
  >>> class MyStore(Store):
  ...     def __init__(self, store, _id_of_key, _key_of_id, _data_of_obj, _obj_of_data):
  ...         super().__init__(store)
  ...         self._id_of_key = _id_of_key
  ...         self._key_of_id = _key_of_id
  ...         self._data_of_obj = _data_of_obj
  ...         self._obj_of_data = _obj_of_data
  ...
  >>> s = MyStore(dict(),
  ...             _id_of_key=lambda k: k.upper(),
  ...             _key_of_id=lambda _id: _id.lower(),
  ...             _data_of_obj=lambda obj: chr(obj),
  ...             _obj_of_data=lambda data: ord(data))
  >>> test_store(s)
  >>>
  ```



  ```pydocstring
  >>> # using a Mixin class #############################################################################
  >>> class Mixin:
  ...     def _id_of_key(self, k):
  ...         return k.upper()
  ...     def _key_of_id(self, _id):
  ...         return _id.lower()
  ...     def _data_of_obj(self, obj):
  ...         return chr(obj)
  ...     def _obj_of_data(self, data):
  ...         return ord(data)
  ...
  >>> class MyStore(Mixin, Store):  # note that the Mixin must come before Store in the mro
  ...     pass
  ...
  >>> s = MyStore()  # no dict()? No, because default anyway
  >>> test_store(s)
  ```



  ```pydocstring
  >>> # adding wrapper methods to an already made Store instance #########################################
  >>> s = Store(dict())
  >>> s._id_of_key=lambda k: k.upper()
  >>> s._key_of_id=lambda _id: _id.lower()
  >>> s._data_of_obj=lambda obj: chr(obj)
  >>> s._obj_of_data=lambda data: ord(data)
  >>> test_store(s)
  ```


  - because it's short
  - because it's cute
  - because it reminds one of "russian dolls" (one way to think of wrappers)
  - because we can come up with an acronym the contains "Data Object" in it.


pkgId: 71c30ff12ef1a5de0a83af941adaf9d5d9e71559ff9800eae944f7209e2fb890
name: python-domaintools-api-test-upload-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for domaintools-api-test-upload
url: https://github.com/domaintools/python_api
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-domaintools-api-test-upload-2.2.0-1.src.rpm
location_href: Packages/python-domaintools-api-test-upload-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/domaintools_api.svg)](http://badge.fury.io/py/domaintools_api)
  [![CI Status](https://github.com/domaintools/python_api/workflows/Tests/badge.svg)](https://github.com/domaintools/python_api/actions)
  [![Coverage Status](https://coveralls.io/repos/github/DomainTools/python_api/badge.svg?branch=main)](https://coveralls.io/github/DomainTools/python_api?branch=main)
  [![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://pypi.python.org/pypi/domaintools_api/)
  DomainTools Official Python API
  ![domaintools Example](https://github.com/DomainTools/python_api/raw/main/artwork/example.gif)
  The DomainTools Python API Wrapper provides an interface to work with our cybersecurity and related data tools provided by our Iris Investigate™, Iris Enrich™, and Iris Detect™ products. It is actively maintained and may be downloaded via <a href="https://github.com/DomainTools/python_api">GitHub</a> or <a href="https://pypi.org/project/domaintools-api/">PyPI</a>. See the included README file, the examples folder, and API documentation (https://app.swaggerhub.com/apis-docs/DomainToolsLLC/DomainTools_APIs/1.0#) for more info.

rpm_license:
  The MIT License (MIT)  Copyright (c) 2016 DomainTools  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: 9e28d775a31dd352f4eafb9ce25316b71a9ff177281f03844e48ebda90a679d0
name: python-domible-help
arch: noarch
version: 0.1.14
epoch: 0
release: 1
summary: Development documents and examples for domible
url: https://joeldodson.github.io/domible
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-domible-0.1.14-1.src.rpm
location_href: Packages/python-domible-help-0.1.14-1.noarch.rpm
checksum_type: sha256
description:
  Domible is a set of Python classes used to generate HTML documents and elements of arbitrary complexity.

  The basic idea behind domible is fairly simple, HTML elements are represented with Python classes.
  When an element object is evaluated, it renders the text of the HTML element.
  Objects can contain other element objects which will also evaluate to text when the containing object is evaluated.

  Through this process of composition and recursive rendering,
  domible can be used to programmatically create HTML elements
  of arbitrary complexity directly from your Python code.

  Go to the
  [Domible Documentation](https://joeldodson.github.io/domible)
  for details and examples.


pkgId: 3324c5d6bcd1dc7260ca5f2a722273aa0afea77880a32cf2dd591729d11c9cc0
name: python-domolibrary-help
arch: noarch
version: 4.2.105
epoch: 0
release: 1
summary: Development documents and examples for domolibrary
url: https://github.com/jaewilson07/domo_library
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-domolibrary-4.2.105-1.src.rpm
location_href: Packages/python-domolibrary-help-4.2.105-1.noarch.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->



  use_snake_case for everything except class names is_bool - prefix any
  boolean parameters with is_bool





  domolibrary.classes.DomoUser upsert_user



  user_routes.SearchUser_NoResults()



  **domolibrary** is a Python package that provides a OOP (class-based)
  and a functional approach to interacting with Domo’s API framework.

  All accessed APIs are documented under DataCrew’s
  <a href ="https://documenter.getpostman.com/view/5049119/UyxbppB2" target="_blank">Domo
  Documentation</a> page.

  This library was created by
  <a href ="https://datacrew.circle.so" target = "_blank">DataCrew</a>
  contributor Jae Wilson.



  The DataCrew team is hard at work expanding the list of available
  `classes` and `routes`. We have a ton of work completed, it’s just a
  matter of migrating and documenting the code into this library.

  ``` sh
  pip install domolibrary
  ```





  For each task, consider the appropriate
  [`DomoAuth`](https://jaewilson07.github.io/domo_library/client/domoauth.html#domoauth)
  mechanism. In most cases
  [`DomoFullAuth`](https://jaewilson07.github.io/domo_library/client/domoauth.html#domofullauth)
  or
  [`DomoTokenAuth`](https://jaewilson07.github.io/domo_library/client/domoauth.html#domotokenauth)
  will be appropriate as this library predominately accesses private APIs.

  Any Public routes or methods will be labeled appropriately in which case
  you should use
  [`DomoDeveloperAuth`](https://jaewilson07.github.io/domo_library/client/domoauth.html#domodeveloperauth).
  Public routes are APIs enumerated and documented under
  <a href = "https://developer.domo.com/" target="_blank">Developer.Domo.com</a>.

  Typically each project will begin with configuring an auth object. If
  you are accessing multiple Domo instances, you’ll probably need multiple
  auth objects.

  ``` python

  import os
  import domolibrary.client.DomoAuth as dmda

  token_auth = dmda.DomoTokenAuth(
      domo_instance=os.environ['DOMO_INSTANCE'],
      domo_access_token=os.environ["DOMO_ACCESS_TOKEN"],
  )
  ```



  In this project domo entities,
  [`DomoActivityLog`](https://jaewilson07.github.io/domo_library/classes/domoactivitylog.html#domoactivitylog),
  [`DomoDataset`](https://jaewilson07.github.io/domo_library/classes/domodataset.html#domodataset)
  are all prefixed ‘Domo’ and can be found in the `classes` folder. Each
  class method will call one or more `routes`. Each route will interact
  with one and only one API.

  Although most methods will be standard methods that will be called after
  creating an instance of the class, some methods will be classmethods
  which return an instance of the class.

  In the example below,
  [`DomoDataset.get_from_id`](https://jaewilson07.github.io/domo_library/classes/domodataset.html#domodataset.get_from_id)
  is a classmethod.

  Note: DomoLibrary uses the asynchronous `aiohttp` requests library to
  offer users the ability to write concurrently executing code.

  ``` python





  ```

  Once instantiated, you can call methods to interact with that object.
  You typically won’t have to pass auth creds again because they are saved
  to the object.

  In the example below we are retrieving the
  [`DomoDataset_Schema`](https://jaewilson07.github.io/domo_library/classes/domodataset_schema.html#domodataset_schema)
  which consists of subclass
  [`DomoDataset_Schema_Column`](https://jaewilson07.github.io/domo_library/classes/domodataset_schema.html#domodataset_schema_column)
  using the
  [`DomoDataset_Schema.get`](https://jaewilson07.github.io/domo_library/classes/domodataset_schema.html#domodataset_schema.get)
  method.

  We take the approach of where possible converting dictionaries from Domo
  APIs into classes because it provides greater predictability when users
  are creating integrations between platforms (ex. Domo to Trello).

  ``` python

  ```

  Typically all information about an entity is saved in the object

  ``` python

  ```



  Although classes add a pretty wrapper for interacting with Domo APIs,
  users can opt to interact directly with APIs by way of `routes`.

  All route functions will exclusively call one API and will always return
  a
  [`ResponseGetData`](https://jaewilson07.github.io/domo_library/client/responsegetdata.html#responsegetdata)
  object OR raise an `Exception` if appropriate.

  For example we can implement similar functionality as the Option 1
  example by calling the
  [`get_dataset_by_id`](https://jaewilson07.github.io/domo_library/routes/dataset.html#get_dataset_by_id)
  function.

  ``` python
  import domolibrary.routes.dataset as dataset_routes

  ds_res = await dataset_routes.get_dataset_by_id(
      auth=token_auth, dataset_id=os.environ["DOJO_DATASET_ID"]
  )
  ds_res
  ```

      warning this token has not been validated by who_am_i, run get_auth_token first

      ResponseGetData(status=200, response={'id': '04c1574e-c8be-4721-9846-c6ffa491144b', 'displayType': 'domo-jupyterdata', 'dataProviderType': 'domo-jupyterdata', 'type': 'Jupyter', 'name': 'domo_kbs', 'owner': {'id': '1893952720', 'name': 'Jae Wilson1', 'type': 'USER', 'group': False}, 'status': 'SUCCESS', 'created': 1668379680000, 'lastTouched': 1711222468000, 'lastUpdated': 1668385822045, 'rowCount': 1185, 'columnCount': 7, 'cardInfo': {'cardCount': 2, 'cardViewCount': 0}, 'properties': {'formulas': {'formulas': {'calculation_ca9d4b1c-f73a-4f76-9f94-d3c4ca6871c5': {'templateId': 2664, 'id': 'calculation_ca9d4b1c-f73a-4f76-9f94-d3c4ca6871c5', 'name': 'rowcount', 'formula': 'sum(1)', 'status': 'VALID', 'dataType': 'LONG', 'persistedOnDataSource': True, 'isAggregatable': True, 'bignumber': False, 'variable': False}, 'calculation_38846559-d190-4ab1-809b-bcd361db5670': {'templateId': 2665, 'id': 'calculation_38846559-d190-4ab1-809b-bcd361db5670', 'name': 'max_views', 'formula': 'max(views)', 'status': 'VALID', 'dataType': 'LONG', 'persistedOnDataSource': True, 'isAggregatable': True, 'bignumber': False, 'columnPositions': [{'columnName': 'views', 'columnPosition': 4}], 'variable': False}}}}, 'state': 'SUCCESS', 'validConfiguration': True, 'validAccount': True, 'streamId': 825, 'transportType': 'API', 'adc': True, 'adcExternal': False, 'adcSource': 'DIRECT', 'cloudId': 'domo', 'cloudName': 'Domo', 'permissions': 'READ_WRITE_DELETE_SHARE_ADMIN', 'hidden': False, 'tags': '["Mar-23-2024 13:34","developer_documentation","hackercore"]', 'scheduleActive': True, 'cardCount': 2, 'cryoStatus': 'ADRENALINE', 'cloudEngine': 'domo'}, is_success=True, parent_class=None)

  [`ResponseGetData`](https://jaewilson07.github.io/domo_library/client/responsegetdata.html#responsegetdata)
  will always include a boolean `is_success`, the API `status`, and raw
  API `response`.

  Typically the route methods will not alter the response unless the API
  does not include a descriptive response (ex,
  `routes.dataset.set_dataset_tags` does not return a response so we
  artificially alter the response in the function.)

  ``` python
  [
      (prop, type(getattr(ds_res, prop)))
      for prop in dir(ds_res)
      if not prop.startswith("_")
  ]
  ```

      [('auth', domolibrary.client.DomoAuth.DomoTokenAuth),
       ('is_success', bool),
       ('parent_class', NoneType),
       ('response', dict),
       ('set_response', method),
       ('status', int),
       ('traceback_details', domolibrary.client.Logger.TracebackDetails)]

  ``` python
  ds_res.response
  ```

      {'id': '04c1574e-c8be-4721-9846-c6ffa491144b',
       'displayType': 'domo-jupyterdata',
       'dataProviderType': 'domo-jupyterdata',
       'type': 'Jupyter',
       'name': 'domo_kbs',
       'owner': {'id': '1893952720',
        'name': 'Jae Wilson1',
        'type': 'USER',
        'group': False},
       'status': 'SUCCESS',
       'created': 1668379680000,
       'lastTouched': 1711222468000,
       'lastUpdated': 1668385822045,
       'rowCount': 1185,
       'columnCount': 7,
       'cardInfo': {'cardCount': 2, 'cardViewCount': 0},
       'properties': {'formulas': {'formulas': {'calculation_ca9d4b1c-f73a-4f76-9f94-d3c4ca6871c5': {'templateId': 2664,
           'id': 'calculation_ca9d4b1c-f73a-4f76-9f94-d3c4ca6871c5',
           'name': 'rowcount',
           'formula': 'sum(1)',
           'status': 'VALID',
           'dataType': 'LONG',
           'persistedOnDataSource': True,
           'isAggregatable': True,
           'bignumber': False,
           'variable': False},
          'calculation_38846559-d190-4ab1-809b-bcd361db5670': {'templateId': 2665,
           'id': 'calculation_38846559-d190-4ab1-809b-bcd361db5670',
           'name': 'max_views',
           'formula': 'max(views)',
           'status': 'VALID',
           'dataType': 'LONG',
           'persistedOnDataSource': True,
           'isAggregatable': True,
           'bignumber': False,
           'columnPositions': [{'columnName': 'views', 'columnPosition': 4}],
           'variable': False}}}},
       'state': 'SUCCESS',
       'validConfiguration': True,
       'validAccount': True,
       'streamId': 825,
       'transportType': 'API',
       'adc': True,
       'adcExternal': False,
       'adcSource': 'DIRECT',
       'cloudId': 'domo',
       'cloudName': 'Domo',
       'permissions': 'READ_WRITE_DELETE_SHARE_ADMIN',
       'hidden': False,
       'tags': '["Mar-23-2024 13:34","developer_documentation","hackercore"]',
       'scheduleActive': True,
       'cardCount': 2,
       'cryoStatus': 'ADRENALINE',
       'cloudEngine': 'domo'}



  A hidden advantage of using the DomoLibrary is that paginated API
  requests are baked into the route’s definition.

  Consider
  [`query_dataset_private`](https://jaewilson07.github.io/domo_library/routes/dataset.html#query_dataset_private)
  from the `routes.dataset`.

  Inside this function we are using
  [`looper`](https://jaewilson07.github.io/domo_library/client/get_data.html#looper)
  from `client.get_data` to paginate over the API response.



  - utils/upload_data is using a general try/except
  - bootstrap route raising a general exception
  - integrations/role_hierarchy raising general exception
  - integrations/domoJupyter raising general exception
  - DomoUser general Exception


pkgId: 6c17d0a52d1975c115d8dc483bdbf94c1ce4272f458cf24ce6d9baf3fb2aed36
name: python-dorkbot-help
arch: noarch
version: 0.5.2
epoch: 0
release: 1
summary: Development documents and examples for dorkbot
url: http://dorkbot.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dorkbot-0.5.2-1.src.rpm
location_href: Packages/python-dorkbot-help-0.5.2-1.noarch.rpm
checksum_type: sha256
description:
  Scan Google (or other) search results for vulnerabilities.
  dorkbot is a modular command-line tool for performing vulnerability scans against sets of webpages returned by Google search queries or other supported sources. It is broken up into two sets of modules:
  * *Indexers* - modules that return a list of targets
  * *Scanners* - modules that perform a vulnerability scan against each target
  Targets are stored in a database as they are indexed. Once scanned, a standard JSON report is produced containing any vulnerabilities found. Indexing and scanning processes can be run separately or combined in a single command (up to one of each).


pkgId: 84cf73636fa61d085ec4fce43cc8ca50e9b947992f5045ad466ab71deb343149
name: python-dot.py-help
arch: noarch
version: 1.5.1
epoch: 0
release: 1
summary: Development documents and examples for dot.py
url: https://github.com/vincentqb/dot.py/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dot.py-1.5.1-1.src.rpm
location_href: Packages/python-dot.py-help-1.5.1-1.noarch.rpm
checksum_type: sha256
description:
  **dot.py** is a minimalist one-file python script for managing dotfiles via symbolic links. Inspired by [bashdot](https://github.com/bashdot/bashdot), it supports multiple profiles and customizable file templates with variables. No external dependencies, just **python 3.6+**.



  1. Install and run with `dot.py` below

     ```sh
     pip install dot.py
     ```

     or download the script directly and run with `~/dot.py` below

     ```sh
     wget https://raw.githubusercontent.com/vincentqb/dot.py/main/dot.py -O ~/dot.py && chmod u+x ~/dot.py
     ```

  1. Create your initial profile. For example, you can create a directory called `default`.

     ```sh
     mkdir default
     ```

  1. Add any files you would like linked into your home when this profile is linked.

     ```sh
     mv ~/.bashrc default/bashrc
     ```

  1. Link the profile. When you link, dot.py prepends a dot, in front of the original file name, to the linked file. Below, `default/bashrc` will be linked to `~/.bashrc`.

     ```sh
     dot.py link default
     ```

  1. You can safely re-run to link newly added files. Store this profile in a cloud drive or source control. Repeat for additional profiles.



  Values which need to be set in a file when dot.py is run can be placed in a template.

  1. Append `.template` to any files which should be rendered. For example, assume you have a file `default/bashrc.template` containing:

     ```sh
     export SECRET_KEY=$ENV_SECRET_KEY
     ```

  1. The rendered files will be created in the same directory, and have `.template` replaced with `.rendered`. In the example, you can run the following to set the value `ENV_SECRET_KEY` when linking the default profile.

     ```sh
     env ENV_SECRET_KEY=test1234 dot.py link default
     ```

  1. The rendered file will be linked into the home with the `.rendered` suffix removed and a dot prepended. In the example, this will result in the rendered file `default/bashrc.rendered` being created and linked to `~/.bashrc` with the below contents.

     ```sh
     export SECRET_KEY=test1234
     ```

  1. Be sure to include `**/*.rendered` in `.gitignore` if you put your dotfiles into a git repository.



  For linting, building and testing, see the [workflow](https://github.com/vincentqb/dot.py/blob/main/.github/workflows/python-app.yml).

  ![Test](https://github.com/vincentqb/dot.py/actions/workflows/python-app.yml/badge.svg)


pkgId: 7a63076c5346f9388073405de5e6aaaa247a31de5cf4e6b241f7e0ef6f43ad93
name: python-dotbot-help
arch: noarch
version: 1.20.4
epoch: 0
release: 1
summary: Development documents and examples for dotbot
url: https://github.com/anishathalye/dotbot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dotbot-1.20.4-1.src.rpm
location_href: Packages/python-dotbot-help-1.20.4-1.noarch.rpm
checksum_type: sha256
description:
  Dotbot is a tool that bootstraps your dotfiles (it's a [Dot]files
  [bo]o[t]strapper, get it?). It does *less* than you think, because version
  control systems do more than you think.
  Dotbot is designed to be lightweight and self-contained, with no external
  dependencies and no installation required. Dotbot can also be a drop-in
  replacement for any other tool you were using to manage your dotfiles, and
  Dotbot is VCS-agnostic -- it doesn't make any attempt to manage your dotfiles.
  See [this blog
  post](https://www.anishathalye.com/2014/08/03/managing-your-dotfiles/) or more
  resources on the [tutorials
  page](https://github.com/anishathalye/dotbot/wiki/Tutorials) for more detailed
  explanations of how to organize your dotfiles.


  Great! You can automate the creation of your dotfiles by using the
  user-contributed [init-dotfiles][init-dotfiles] script. If you'd rather use a
  template repository, check out [dotfiles_template][dotfiles-template]. Or, if
  you're just looking for [some inspiration][inspiration], we've got you covered.

  The following will help you get set up using Dotbot in just a few steps.
  If you're using **Git**, you can add Dotbot as a submodule:
  ```bash
  cd ~/.dotfiles # replace with the path to your dotfiles
  git init # initialize repository if needed
  git submodule add https://github.com/anishathalye/dotbot
  git config -f .gitmodules submodule.dotbot.ignore dirty # ignore dirty commits in the submodule
  cp dotbot/tools/git-submodule/install .
  touch install.conf.yaml
  ```
  If you're using **Mercurial**, you can add Dotbot as a subrepo:
  ```bash
  cd ~/.dotfiles # replace with the path to your dotfiles
  hg init # initialize repository if needed
  echo "dotbot = [git]https://github.com/anishathalye/dotbot" > .hgsub
  hg add .hgsub
  git clone https://github.com/anishathalye/dotbot
  cp dotbot/tools/hg-subrepo/install .
  touch install.conf.yaml
  ```
  If you are using PowerShell instead of a POSIX shell, you can use the provided
  `install.ps1` script instead of `install`. On Windows, Dotbot only supports
  Python 3.8+, and it requires that your account is [allowed to create symbolic
  links][windows-symlinks].
  To get started, you just need to fill in the `install.conf.yaml` and Dotbot
  will take care of the rest. To help you get started we have [an
  example](#full-example) config file as well as [configuration
  documentation](#configuration) for the accepted parameters.
  Note: The `install` script is merely a shim that checks out the appropriate
  version of Dotbot and calls the full Dotbot installer. By default, the script
  assumes that the configuration is located in `install.conf.yaml` the Dotbot
  submodule is located in `dotbot`. You can change either of these parameters by
  editing the variables in the `install` script appropriately.
  Setting up Dotbot as a submodule or subrepo locks it on the current version.
  You can upgrade Dotbot at any point. If using a submodule, run `git submodule
  update --remote dotbot`, substituting `dotbot` with the path to the Dotbot
  submodule; be sure to commit your changes before running `./install`, otherwise
  the old version of Dotbot will be checked out by the install script. If using a
  subrepo, run `git fetch && git checkout origin/master` in the Dotbot directory.
  If you prefer, you can install Dotbot from [PyPI] and call it as a command-line
  program:
  ```bash
  pip install dotbot
  touch install.conf.yaml
  ```
  In this case, rather than running `./install`, you can invoke Dotbot with
  `dotbot -c <path to configuration file>`.

  Here's an example of a complete configuration.
  The conventional name for the configuration file is `install.conf.yaml`.
  ```yaml
  - defaults:
      link:
        relink: true
  - clean: ['~']
  - link:
      ~/.tmux.conf: tmux.conf
      ~/.vim: vim
      ~/.vimrc: vimrc
  - create:
      - ~/downloads
      - ~/.vim/undo-history
  - shell:
    - [git submodule update --init --recursive, Installing submodules]
  ```
  The configuration file is typically written in YAML, but it can also be written
  in JSON (which is a [subset of YAML][json2yaml]). JSON configuration files are
  conventionally named `install.conf.json`.

  Dotbot uses YAML or JSON-formatted configuration files to let you specify how
  to set up your dotfiles. Currently, Dotbot knows how to [link](#link) files and
  folders, [create](#create) folders, execute [shell](#shell) commands, and
  [clean](#clean) directories of broken symbolic links. Dotbot also supports user
  [plugins](#plugins) for custom commands.
  **Ideally, bootstrap configurations should be idempotent. That is, the
  installer should be able to be run multiple times without causing any
  problems.** This makes a lot of things easier to do (in particular, syncing
  updates between machines becomes really easy).
  Dotbot configuration files are arrays of tasks, where each task
  is a dictionary that contains a command name mapping to data for that command.
  Tasks are run in the order in which they are specified. Commands within a task
  do not have a defined ordering.
  When writing nested constructs, keep in mind that YAML is whitespace-sensitive.
  Following the formatting used in the examples is a good idea. If a YAML
  configuration file is not behaving as you expect, try inspecting the
  [equivalent JSON][json2yaml] and check that it is correct.

  Most Dotbot commands support both a simplified and extended syntax, and they
  can also be configured via setting [defaults](#defaults).

  Link commands specify how files and directories should be symbolically linked.
  If desired, items can be specified to be forcibly linked, overwriting existing
  files if necessary. Environment variables in paths are automatically expanded.

  Link commands are specified as a dictionary mapping targets to source
  locations. Source locations are specified relative to the base directory (that
  is specified when running the installer). If linking directories, *do not*
  include a trailing slash.
  Link commands support an optional extended configuration. In this type of
  configuration, instead of specifying source locations directly, targets are
  mapped to extended configuration dictionaries.
  | Parameter | Explanation |
  | --- | --- |
  | `path` | The source for the symlink, the same as in the shortcut syntax (default: null, automatic (see below)) |
  | `create` | When true, create parent directories to the link as needed. (default: false) |
  | `relink` | Removes the old target if it's a symlink (default: false) |
  | `force` | Force removes the old target, file or folder, and forces a new link (default: false) |
  | `relative` | Use a relative path to the source when creating the symlink (default: false, absolute links) |
  | `canonicalize` | Resolve any symbolic links encountered in the source to symlink to the canonical path (default: true, real paths) |
  | `if` | Execute this in your `$SHELL` and only link if it is successful. |
  | `ignore-missing` | Do not fail if the source is missing and create the link anyway (default: false) |
  | `glob` | Treat `path` as a glob pattern, expanding patterns referenced below, linking all *files* matched. (default: false) |
  | `exclude` | Array of glob patterns to remove from glob matches. Uses same syntax as `path`. Ignored if `glob` is `false`. (default: empty, keep all matches) |
  | `prefix` | Prepend prefix prefix to basename of each file when linked, when `glob` is `true`. (default: '') |
  When `glob: True`, Dotbot uses [glob.glob](https://docs.python.org/3/library/glob.html#glob.glob) to resolve glob paths, expanding Unix shell-style wildcards, which are **not** the same as regular expressions; Only the following are expanded:
  | Pattern  | Meaning                            |
  |:---------|:-----------------------------------|
  | `*`      | matches anything                   |
  | `**`     | matches any **file**, recursively  |
  | `?`      | matches any single character       |
  | `[seq]`  | matches any character in `seq`     |
  | `[!seq]` | matches any character not in `seq` |
  However, due to the design of `glob.glob`, using a glob pattern such as `config/*`, will **not** match items that begin with `.`. To specifically capture items that being with `.`, you will need to include the `.` in the pattern, like this: `config/.*`.
  When using glob with the `exclude:` option, the paths in the exclude paths should be relative to the base directory, same as the glob pattern itself. For example, if a glob pattern `vim/*` matches directories `vim/autoload`, `vim/ftdetect`, `vim/ftplugin`, and `vim/spell`, and you want to ignore the spell directory, then you should use `exclude: ["vim/spell"]` (not just `"spell"`).

  ```yaml
  - link:
      ~/.config/terminator:
        create: true
        path: config/terminator
      ~/.vim: vim
      ~/.vimrc:
        relink: true
        path: vimrc
      ~/.zshrc:
        force: true
        path: zshrc
      ~/.hammerspoon:
        if: '[ `uname` = Darwin ]'
        path: hammerspoon
      ~/.config/:
        path: dotconf/config/**
      ~/:
        glob: true
        path: dotconf/*
        prefix: '.'
  ```
  If the source location is omitted or set to `null`, Dotbot will use the
  basename of the destination, with a leading `.` stripped if present. This makes
  the following two config files equivalent.
  Explicit sources:
  ```yaml
  - link:
      ~/bin/ack: ack
      ~/.vim: vim
      ~/.vimrc:
        relink: true
        path: vimrc
      ~/.zshrc:
        force: true
        path: zshrc
      ~/.config/:
        glob: true
        path: config/*
        relink: true
        exclude: [ config/Code ]
      ~/.config/Code/User/:
        create: true
        glob: true
        path: config/Code/User/*
        relink: true
  ```
  Implicit sources:
  ```yaml
  - link:
      ~/bin/ack:
      ~/.vim:
      ~/.vimrc:
        relink: true
      ~/.zshrc:
        force: true
      ~/.config/:
        glob: true
        path: config/*
        relink: true
        exclude: [ config/Code ]
      ~/.config/Code/User/:
        create: true
        glob: true
        path: config/Code/User/*
        relink: true
  ```

  Create commands specify empty directories to be created.  This can be useful
  for scaffolding out folders or parent folder structure required for various
  apps, plugins, shell commands, etc.

  Create commands are specified as an array of directories to be created. If you
  want to use the optional extended configuration, create commands are specified
  as dictionaries. For convenience, it's permissible to leave the options blank
  (null) in the dictionary syntax.
  | Parameter | Explanation |
  | --- | --- |
  | `mode` | The file mode to use for creating the leaf directory (default: 0777) |
  The `mode` parameter is treated in the same way as in Python's
  [os.mkdir](https://docs.python.org/3/library/os.html#mkdir-modebits). Its
  behavior is platform-dependent. On Unix systems, the current umask value is
  first masked out.

  ```yaml
  - create:
      - ~/downloads
      - ~/.vim/undo-history
  - create:
      ~/.ssh:
        mode: 0700
      ~/projects:
  ```

  Shell commands specify shell commands to be run. Shell commands are run in the
  base directory (that is specified when running the installer).

  Shell commands can be specified in several different ways. The simplest way is
  just to specify a command as a string containing the command to be run.
  Another way is to specify a two element array where the first element is the
  shell command and the second is an optional human-readable description.
  Shell commands support an extended syntax as well, which provides more
  fine-grained control.
  | Parameter | Explanation |
  | --- | --- |
  | `command` | The command to be run |
  | `description` | A human-readable message describing the command (default: null) |
  | `quiet` | Show only the description but not the command in log output (default: false) |
  | `stdin` | Allow a command to read from standard input (default: false) |
  | `stdout` | Show a command's output from stdout (default: false) |
  | `stderr` | Show a command's error output from stderr (default: false) |
  Note that `quiet` controls whether the command (a string) is printed in log
  output, it does not control whether the output from running the command is
  printed (that is controlled by `stdout` / `stderr`). When a command's `stdin` /
  `stdout` / `stderr` is not enabled (which is the default), it's connected to
  `/dev/null`, disabling input and hiding output.

  ```yaml
  - shell:
    - chsh -s $(which zsh)
    - [chsh -s $(which zsh), Making zsh the default shell]
    -
      command: read var && echo Your variable is $var
      stdin: true
      stdout: true
      description: Reading and printing variable
      quiet: true
    -
      command: read fail
      stderr: true
  ```

  Clean commands specify directories that should be checked for dead symbolic
  links. These dead links are removed automatically. Only dead links that point
  to somewhere within the dotfiles directory are removed unless the `force`
  option is set to `true`.

  Clean commands are specified as an array of directories to be cleaned.
  Clean commands also support an extended configuration syntax.
  | Parameter | Explanation |
  | --- | --- |
  | `force` | Remove dead links even if they don't point to a file inside the dotfiles directory (default: false) |
  | `recursive` | Traverse the directory recursively looking for dead links (default: false) |
  Note: using the `recursive` option for `~` is not recommended because it will
  be slow.

  ```yaml
  - clean: ['~']
  - clean:
      ~/:
        force: true
      ~/.config:
        recursive: true
  ```

  Default options for plugins can be specified so that options don't have to be
  repeated many times. This can be very useful to use with the link command, for
  example.
  Defaults apply to all commands that come after setting the defaults. Defaults
  can be set multiple times; each change replaces the defaults with a new set of
  options.

  Defaults are specified as a dictionary mapping action names to settings, which
  are dictionaries from option names to values.

  ```yaml
  - defaults:
      link:
        create: true
        relink: true
  ```

  Dotbot also supports custom directives implemented by plugins. Plugins are
  implemented as subclasses of `dotbot.Plugin`, so they must implement
  `can_handle()` and `handle()`. The `can_handle()` method should return `True`
  if the plugin can handle an action with the given name. The `handle()` method
  should do something and return whether or not it completed successfully.
  All built-in Dotbot directives are written as plugins that are loaded by
  default, so those can be used as a reference when writing custom plugins.
  Plugins are loaded using the `--plugin` and `--plugin-dir` options, using
  either absolute paths or paths relative to the base directory. It is
  recommended that these options are added directly to the `install` script.
  See [here][plugins] for a current list of plugins.

  Dotbot takes a number of command-line arguments; you can run Dotbot with
  `--help`, e.g. by running `./install --help`, to see the full list of options.
  Here, we highlight a couple that are particularly interesting.

  You can call `./install --only [list of directives]`, such as `./install --only
  link`, and Dotbot will only run those sections of the config file.

  You can call `./install --except [list of directives]`, such as `./install
  --except shell`, and Dotbot will run all the sections of the config file except
  the ones listed.

  Check out the [Dotbot wiki][wiki] for more information, tips and tricks,
  user-contributed plugins, and more.

  Do you have a feature request, bug report, or patch? Great! See
  [CONTRIBUTING.md][contributing] for information on what you can do about that.

  Copyright (c) Anish Athalye. Released under the MIT License. See
  [LICENSE.md][license] for details.
  [PyPI]: https://pypi.org/project/dotbot/
  [init-dotfiles]: https://github.com/Vaelatern/init-dotfiles
  [dotfiles-template]: https://github.com/anishathalye/dotfiles_template
  [inspiration]: https://github.com/anishathalye/dotbot/wiki/Users
  [windows-symlinks]: https://learn.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/create-symbolic-links
  [json2yaml]: https://www.json2yaml.com/
  [plugins]: https://github.com/anishathalye/dotbot/wiki/Plugins
  [wiki]: https://github.com/anishathalye/dotbot/wiki
  [contributing]: CONTRIBUTING.md
  [license]: LICENSE.md


pkgId: e8cf6506880b368e0264a40f6cd1748f24152f72c5ee4d15f59585aa2323b8af
name: python-dotdrop-help
arch: noarch
version: 1.15.0
epoch: 0
release: 1
summary: Development documents and examples for dotdrop
url: https://github.com/deadc0de6/dotdrop
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dotdrop-1.15.0-1.src.rpm
location_href: Packages/python-dotdrop-help-1.15.0-1.noarch.rpm
checksum_type: sha256
description:
  **Table of Contents**
  * [Installation](#installation)
  * [Getting started](#getting-started)
  * [Documentation](#documentation)
  * [Thank you](#thank-you)

  See the [installation instructions](https://dotdrop.readthedocs.io/en/latest/installation/).
  Dotdrop is available on:
  * [PyPI](https://pypi.org/project/dotdrop/)
  * [Homebrew](https://formulae.brew.sh/formula/dotdrop)
  * [AUR (stable)](https://aur.archlinux.org/packages/dotdrop/)
  * [AUR (git version)](https://aur.archlinux.org/packages/dotdrop-git/)
  * [Snapcraft](https://snapcraft.io/dotdrop)
  * [Pacstall](https://github.com/pacstall/pacstall-programs/blob/master/packages/dotdrop/dotdrop.pacscript)

  [Create a new repository](https://dotdrop.readthedocs.io/en/latest/getting-started/#repository-setup)
  to store your dotfiles with dotdrop. *Init* or *clone* that new repository,
  [install dotdrop](https://dotdrop.readthedocs.io/en/latest/installation/) and
  generate a default config file [generate config file](https://dotdrop.readthedocs.io/en/latest/usage/#generate-a-default-config)
  Then import any dotfiles (files or directories) you want to manage with dotdrop.
  You can either use the default profile (which resolves to the *hostname* of the host
  you are running dotdrop on) or provide it explicitly using the switch `-p`/`--profile`.
  Import dotfiles on host *home*:
  ```bash
  $ dotdrop import ~/.vimrc ~/.xinitrc ~/.config/polybar
  ```
  Dotdrop does two things:
  * Copy the dotfiles to the *dotpath* directory
    (defined in `config.yaml`, defaults to *dotfiles*)
  * Create the associated entries in the `config.yaml` file
    (in the `dotfiles` and `profiles` entries)
  Your config file will look like something similar to this:
  ```yaml
  config:
    backup: true
    banner: true
    create: true
    dotpath: dotfiles
    ignoreempty: false
    keepdot: false
    longkey: false
    showdiff: false
    workdir: ~/.config/dotdrop
  dotfiles:
    d_polybar:
      dst: ~/.config/polybar
      src: config/polybar
    f_vimrc:
      dst: ~/.vimrc
      src: vimrc
    f_xinitrc:
      dst: ~/.xinitrc
      src: xinitrc
  profiles:
    home:
      dotfiles:
      - f_vimrc
      - f_xinitrc
      - d_polybar
  ```
  For a description of the different fields and their use,
  see the [config doc](https://dotdrop.readthedocs.io/en/latest/config/config-config/).
  Commit and push your changes with git.
  Then go to another host where your dotfiles need to be managed as well,
  clone the previously set up repository,
  and compare the local dotfiles with the ones stored in dotdrop:
  ```bash
  $ dotdrop compare --profile=home
  ```
  Now you might want to adapt the `config.yaml` file to your liking on
  that second host. Let's say, for example, that you only want `d_polybar` and
  `f_xinitrc` to be deployed on that second host. You would then change your config
  to something like this (assuming that the second host's hostname is *office*):
  ```yaml
  …
  profiles:
    home:
      dotfiles:
      - f_vimrc
      - f_xinitrc
      - d_polybar
    office:
      dotfiles:
      - f_xinitrc
      - d_polybar
  ```
  Then adapt any dotfile using the [templating](https://dotdrop.readthedocs.io/en/latest/template/templating/)
  feature (if needed). For example, you might want different fonts sizes in Polybar for each host.
  Edit `<dotpath>/config/polybar/config`:
  ```bash
  …
  {%@@ if profile == "home" @@%}
  font0 = sans:size=10;0
  {%@@ elif profile == "office" @@%}
  font0 = sans:size=14;0
  {%@@ endif @@%}
  font1 = "Material Design Icons:style=Regular:size=14;0"
  font2 = "unifont:size=6;0"
  …
  ```
  You also want to have the correct interface set on the wireless network in
  the Polybar config.
  Add a [variable](https://dotdrop.readthedocs.io/en/latest/config/config-variables/)
  to the config file (In the below example, *home* gets the default `wlan0` value for
  the variable `wifi` while *office* gets `wlp2s0`):
  ```yaml
  …
  variables:
    wifi: "wlan0"
  …
  profiles:
    home:
      dotfiles:
      - f_vimrc
      - f_xinitrc
      - d_polybar
    office:
      dotfiles:
      - f_xinitrc
      - d_polybar
      variables:
        wifi: "wlp2s0"
  ```
  Then you can adapt the Polybar config file so that the
  variable `wifi` gets correctly replaced during installation:
  ```bash
  [module/wireless-network]
  type = internal/network
  interface = {{@@ wifi @@}}
  ```
  Also, the home computer is running [awesomeWM](https://awesomewm.org/),
  and the office computer [bspwm](https://github.com/baskerville/bspwm).
  The `~/.xinitrc` file will therefore be different while still sharing some lines.
  Edit `<dotpath>/xinitrc`:
  ```bash


  userresources=$HOME/.Xresources
  if [ -f "$userresources" ]; then
        xrdb -merge "$userresources" &
  fi

  {%@@ if profile == "home" @@%}
  exec awesome
  {%@@ elif profile == "office" @@%}
  exec bspwm
  {%@@ endif @@%}
  ```
  Finally you want everything installed with the *office* profile
  to be logged; you thus add an action to the config file:
  ```yaml
  …
  actions:
    loginstall: "echo {{@@ _dotfile_abs_src @@}} installed to {{@@ _dotfile_abs_dst @@}} >> {0}"
  …
  profiles:
    home:
      dotfiles:
      - f_vimrc
      - f_xinitrc
      - d_polybar
    office:
      dotfiles:
      - f_xinitrc
      - d_polybar
      variables:
        wifi: "wlp2s0"
      actions:
        - loginstall "/tmp/dotdrop-installation.log"
  ```
  When done, you can install your dotfiles using:
  ```bash
  $ dotdrop install
  ```
  If you are unsure, you can always run `dotdrop compare` to see
  how your local dotfiles would be updated by dotdrop before running
  `install` or you could run install with `--dry`.
  That's it, a single repository with all your dotfiles for your different hosts.
  For more, see the [docs](https://dotdrop.readthedocs.io):
  * [Create actions](https://dotdrop.readthedocs.io/en/latest/config/config-actions/)
  * [Use transformations](https://dotdrop.readthedocs.io/en/latest/config/config-transformations/)
  * [Use variables](https://dotdrop.readthedocs.io/en/latest/config/config-variables/)
  * [Symlink dotfiles](https://dotdrop.readthedocs.io/en/latest/howto/symlink-dotfiles/)
  * [and more](https://dotdrop.readthedocs.io/en/latest/howto/howto/)

  Dotdrop's documentation is hosted on [Read the Docs](https://dotdrop.readthedocs.io/en/latest/).

  If you like dotdrop, [buy me a coffee](https://ko-fi.com/deadc0de6).

  If you are having trouble installing or using dotdrop,
  [open an issue](https://github.com/deadc0de6/dotdrop/issues).
  If you want to contribute, feel free to do a PR (please follow PEP8).
  Have a look at the
  [contribution guidelines](https://github.com/deadc0de6/dotdrop/blob/master/CONTRIBUTING.md).

  This project is licensed under the terms of the GPLv3 license.


pkgId: 9473c4a85717c3b96d8cd5ca77c6c9aa6090c4ff98e35749c09edfea5289f659
name: python-douban2notion-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for douban2notion
url: https://github.com/malinkang/weread2notion-pro
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-douban2notion-0.0.8-1.src.rpm
location_href: Packages/python-douban2notion-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  本项目通过Github Action每天定时同步豆瓣电影和读书到Notion。

  * 豆瓣电影预览效果：https://douban-movie.malinkang.com/
  * 豆瓣图书预览效果：https://douban-book.malinkang.com/




  > [!IMPORTANT]
  > 关注公众号回复豆瓣获取教程，后续有更新也会第一时间在公众号里同步。

  ![扫码_搜索联合传播样式-标准色版](https://github.com/malinkang/weread2notion/assets/3365208/191900c6-958e-4f9b-908d-a40a54889b5e)



  > [!IMPORTANT]
  > 欢迎加入群讨论。可以讨论使用中遇到的任何问题，也可以讨论Notion使用，后续我也会在群中分享更多Notion自动化工具。微信群失效的话可以添加我的微信malinkang，我拉你入群。

  | 微信群 | QQ群 |
  | --- | --- |
  | <div align="center"><img src="https://github.com/malinkang/Podcast2Notion/assets/3365208/f38804e6-fe05-4754-9188-122a08e43fec" ></div> | <div align="center"><img src="https://images.malinkang.com/2024/04/b225b17d60670e4a6ff3459bbde80d28.jpg" width="50%"></div> |




  如果你觉得本项目帮助了你，请作者喝一杯咖啡，你的支持是作者最大的动力。本项目会持续更新。

  | 支付宝支付 | 微信支付 |
  | --- | --- |
  | <div align="center"><img src="https://images.malinkang.com/2024/03/7fd0feb1145f19fab3821ff1d4631f85.jpg" width="50%"></div> | <div align="center"><img src="https://images.malinkang.com/2024/03/d34f577490a32d4440c8a22f57af41da.jpg" width="50%"></div> |


  * [WeRead2Notion-Pro](https://github.com/malinkang/weread2notion-pro)
  * [WeRead2Notion](https://github.com/malinkang/weread2notion)
  * [Podcast2Notion](https://github.com/malinkang/podcast2notion)
  * [Douban2Notion](https://github.com/malinkang/douban2notion)
  * [Keep2Notion](https://github.com/malinkang/keep2notion)


pkgId: 608fc043cc1e64b9e0a87c182c4e55dbc8eee3ec2a5fc1222624ce01e5b676aa
name: python-download-boss-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for download-boss
url: https://github.com/kristof9851/download_boss
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-download-boss-0.0.7-1.src.rpm
location_href: Packages/python-download-boss-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  ![Python CI Build](https://github.com/kristof9851/download_boss/actions/workflows/python-ci.yml/badge.svg)
  ![PyPI Downloads](https://img.shields.io/pypi/dm/download_boss?label=PyPI%20Downloads&color=rgb(50%2C%20165%2C%20233)
  )

  *Python download library*



  ```bash
  pip install download_boss
  ```

  &nbsp;




  Simple request
  ```python
  from requests import Request
  from download_boss.RequestEnvelope import RequestEnvelope
  from download_boss.HttpClient import HttpClient

  request = RequestEnvelope(
      Request(method='POST', url='https://httpbin.org/anything/hello', json={"hello": "world"},
      {'verify': False, 'timeout': 10})
  )
  response = HttpClient().download(request)
  print(response.text)

  ```

  Retry based on HTTP status codes
  ```python
  from requests import Request
  from download_boss.RequestEnvelope import RequestEnvelope
  from download_boss.HttpClient import HttpClient
  from download_boss.error.ClientRetriable import ClientRetriable

  request = RequestEnvelope(
      Request(method='GET', url='https://httpbin.org/anything/hello')
  )
  client = HttpClient(throwRetriableStatusCodeRanges=[401, range(500,599)])

  while True:
      try:
          response = client.download(request)
          print(response.text)
          break
      except ClientRetriable:
          continue

  ```

  Kerberos authentication:
  ```python
  from requests import Request
  from requests_kerberos import HTTPKerberosAuth, OPTIONAL
  from download_boss.RequestEnvelope import RequestEnvelope
  from download_boss.HttpClient import HttpClient

  request = RequestEnvelope(
      Request(method='POST', url='https://httpbin.org/anything/kerb', auth=HTTPKerberosAuth(mutual_authentication=OPTIONAL))
  )
  response = HttpClient().download(request)
  ```



  Retry automatically some HTTP status codes
  ```python
  from requests import Request
  from download_boss.RequestEnvelope import RequestEnvelope
  from download_boss.HttpClient import HttpClient
  from download_boss.RetryWrapper import RetryWrapper
  from download_boss.error.RetriesExhausted import RetriesExhausted

  request = RequestEnvelope(
      Request(method='GET', url='https://httpbin.org/status/500')
  )
  client = HttpClient(throwRetriableStatusCodeRanges=[401, range(500,599)])
  client = RetryWrapper(client, count=1, catchRetriableStatusCodeRanges=[range(500,599)])

  try:
      response = client.download(request)
  except RetriesExhausted:
      print("Retries exhausted!")

  """
  2024-12-03 11:51:10,085 [ INFO] HttpClient.py :: download() - Requesting: GET https://httpbin.org/status/500
  2024-12-03 11:51:10,485 [ INFO] RetryWrapper.py :: download() - Retrying... GET https://httpbin.org/status/500
  2024-12-03 11:52:10,485 [ INFO] HttpClient.py :: download() - Requesting: GET https://httpbin.org/status/500
  Retries exhausted!
  """
  ```



  Delay download calls by 2-5 seconds

  ```python
  from requests import Request
  from download_boss.RequestEnvelope import RequestEnvelope
  from download_boss.HttpClient import HttpClient
  from download_boss.RetryWrapper import RetryWrapper
  from download_boss.DelayWrapper import DelayWrapper
  from download_boss.error.RetriesExhausted import RetriesExhausted

  client = HttpClient(throwRetriableStatusCodeRanges=[401, range(500,599)])
  client = RetryWrapper(client, count=1, catchRetriableStatusCodeRanges=[range(500,599)])
  client = DelayWrapper(client, length=2, maxLength=5)

  requests = [
      RequestEnvelope( Request(method='GET', url='https://httpbin.org/anything/one') ),
      RequestEnvelope( Request(method='GET', url='https://httpbin.org/anything/two') ),
      RequestEnvelope( Request(method='GET', url='https://httpbin.org/anything/three') )
  ]

  for r in requests:
      response = client.download(r)

  """
  2024-12-03 12:00:28,804 [ INFO] DelayWrapper.py :: download() - Delaying by 3s ... GET https://httpbin.org/anything/one
  2024-12-03 12:00:31,805 [ INFO] HttpClient.py :: download() - Requesting: GET https://httpbin.org/anything/one
  2024-12-03 12:00:32,206 [ INFO] DelayWrapper.py :: download() - Delaying by 2s ... GET https://httpbin.org/anything/two
  2024-12-03 12:00:34,208 [ INFO] HttpClient.py :: download() - Requesting: GET https://httpbin.org/anything/two
  2024-12-03 12:00:34,827 [ INFO] DelayWrapper.py :: download() - Delaying by 5s ... GET https://httpbin.org/anything/three
  2024-12-03 12:00:39,830 [ INFO] HttpClient.py :: download() - Requesting: GET https://httpbin.org/anything/three
  """

  ```


  ```python
  from os.path import join, dirname
  from requests import Request
  from download_boss.RequestEnvelope import RequestEnvelope
  from download_boss.HttpClient import HttpClient
  from download_boss.RetryWrapper import RetryWrapper
  from download_boss.DelayWrapper import DelayWrapper
  from download_boss.FileCacheWrapper import FileCacheWrapper

  cacheFolderPath = join(dirname(__file__), "cache")
  cacheLength = 60*60*24 # 1 day

  client = HttpClient(throwRetriableStatusCodeRanges=[401, range(500,599)])
  client = RetryWrapper(client, count=1, catchRetriableStatusCodeRanges=[range(500,599)])
  client = DelayWrapper(client, length=2, maxLength=5)
  client = FileCacheWrapper(client, cacheFolderPath, cacheLength)

  requests = [
      RequestEnvelope( Request(method='GET', url='https://httpbin.org/anything/one') ),
      RequestEnvelope( Request(method='GET', url='https://httpbin.org/anything/one') ),
      RequestEnvelope( Request(method='GET', url='https://httpbin.org/anything/one') )
  ]

  for r in requests:
      response = client.download(r)

  """
  2024-12-03 13:26:24,921 [ INFO] FileCacheWrapper.py :: _getCache() - Cache miss: GET https://httpbin.org/anything/one
  2024-12-03 13:26:24,921 [ INFO] DelayWrapper.py :: download() - Delaying by 3s ... GET https://httpbin.org/anything/one
  2024-12-03 13:26:27,923 [ INFO] HttpClient.py :: download() - Requesting: GET https://httpbin.org/anything/one
  2024-12-03 13:26:27,956 [DEBUG] connectionpool.py :: _new_conn() - Starting new HTTPS connection (1): httpbin.org:443
  2024-12-03 13:26:29,256 [DEBUG] connectionpool.py :: _make_request() - https://httpbin.org:443 "GET /anything/one HTTP/11" 200 370
  2024-12-03 13:26:29,257 [DEBUG] FileCacheWrapper.py :: _getCache() - Cache found: GET https://httpbin.org/anything/one
  2024-12-03 13:26:29,263 [DEBUG] FileCacheWrapper.py :: _getCache() - Cache found: GET https://httpbin.org/anything/one
  """
  ```

  &nbsp;





  Install pip/python.

  Clone the project.

  Create virtual env:
  ```bash

  pip install --upgrade virtualenv
  cd <PROJECT_ROOT>


  python -m venv venv


  .\venv\Scripts\activate


  chmod +x venv/bin/activate
  source venv/bin/activate
  ```

  Install project dependencies:
  ```bash
  pip install -r requirements.txt
  ```

  Install module locally as editable
  ```bash
  pip install -e .
  ```

  &nbsp;



  ```bash

  .\wtests.bat


  ./tests.sh
  ```

  &nbsp;



  Git add/commit/push to GitHub. The GitHub action will automatically publish the new version to PyPi.

  &nbsp;



  Install dependencies

  ```bash
  pip install --upgrade setuptools wheel build twine
  ```

  Build the package (wheel and sdist)
  ```bash
  python -m build
  ```

  Ensure `.pypirc` in user folder is correct, then upload
  ```bash
  python -m twine upload dist/*
  ```


pkgId: a04ca5175f6bfb6ffadd343c12675522a0feaffd96d2869488088a3f425e4f9d
name: python-downstream-help
arch: noarch
version: 1.4.2
epoch: 0
release: 1
summary: Development documents and examples for downstream
url: https://pypi.org/project/downstream/
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-downstream-1.4.2-1.src.rpm
location_href: Packages/python-downstream-help-1.4.2-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/mmore500/downstream/actions/workflows/python-ci.yaml/badge.svg?branch=python)](https://github.com/mmore500/downstream/actions/workflows/python-ci.yaml?query=branch:python)
  [![GitHub stars](https://img.shields.io/github/stars/mmore500/downstream.svg?style=flat-square&logo=github&label=Stars&logoColor=white)](https://github.com/mmore500/downstream)
  [
  ![PyPi](https://img.shields.io/pypi/v/downstream.svg)
  ](https://pypi.python.org/pypi/downstream)
  [![DOI](https://zenodo.org/badge/776865597.svg)](https://zenodo.org/doi/10.5281/zenodo.10866541)

  downstream provides efficient, constant-space implementations of stream curation algorithms.

  -   Free software: MIT license

  <!---
  -   Documentation: <https://downstream.readthedocs.io>.
  -->



  To install from PyPi with pip, run

  `python3 -m pip install downstream[jit]`

  To install the latest develoment code directly from GitHub, run

  `python3 -m pip install "git+https://github.com/mmore500/downstream.git@v0.4.4#egg=downstream[jit]"`




  If downstream contributes to a scientific publication, please cite it as

  > Matthew Andres Moreno. (2024). mmore500/downstream. Zenodo. https://zenodo.org/doi/10.5281/zenodo.10866541

  ```bibtex
  @software{moreno2024downstream,
    author = {Matthew Andres Moreno},
    title = {mmore500/downstream},
    month = mar,
    year = 2024,
    publisher = {Zenodo},
    doi = {10.5281/zenodo.10866541},
    url = {https://zenodo.org/doi/10.5281/zenodo.10866541}
  }
  ```

  And don't forget to leave a [star on GitHub](https://github.com/mmore500/downstream/stargazers)!


pkgId: 6568c27cf608a0827092c2287d7387f8849cc866c2efa8808d5be1e882142390
name: python-dpr-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for dpr
url: https://github.com/samuelstjean/dpr
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dpr-0.2.2-1.src.rpm
location_href: Packages/python-dpr-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  An example and assorted implementation from the manuscript **Reducing variability in along-tract analysis with diffusion profile realignment**.
  Have a look at the [example](example.ipynb) on how to use the package and run it on a small example dataset.

  To install the package, just run
  ~~~
  pip install dpr
  ~~~

  The documentation is available at https://dpr.readthedocs.io.



  There is also a shiny new version written in matlab, with an assorted example, available in the [matlab](matlab) folder.
  Feel free to check out and edit the functions as needed for your own usage.



  There is also a command line version for easy usage, here in an example for the AFD metric on the left arcuate fasciculus.
  The text file is already ordered in increasing order for each subject, which have the same distance between every point and are already zero padded accordingly.

  We also supply the **--exploredti** option to remove the header column, **--do_graph** to save a png file with the results.

  We finally resample everything to 75 points with **--points 75**.

  The **-f** option overwrites the output files and the **-v** option prints useful informative messages throughout (and are optional).

  ~~~bash
  dpr datasets/af_left_AFD.txt datasets/af_left_AFD_realigned.txt --exploredti --do_graph -f -v --points 75
  ~~~

  The output ```datasets/af_left_AFD_realigned.txt``` is a text file where each line is a subject and each column is a different point of the along tract analysis.

  We also get a png file ```datasets/af_left_AFD_realigned.png``` with the before/after realignment process.

  ![](datasets/af_left_AFD_realigned.png)

  Note how the zero padding present in the original data is decreasing the metrics as less and less subjects are present.
  The realigned metric is instead using padding with Nans, remember to consider/keep track of it in subsequent analysis as needed.



  We can also draw the p-values (computed separately) over the bundle using the script ```dpr_make_fancy_graph```.
  This requires the original coordinates, the truncated version between rois and the coordinates to the representative streamline.

  ~~~bash
  dpr_make_fancy_graph datasets/af_left_pval_unaligned.txt datasets/af_left_coordinates.txt datasets/af_left_truncated_coordinates.txt datasets/af_left_average_coordinates.txt 0,2 pvals_unaligned.png --title 'p-values before realignment' -f
  dpr_make_fancy_graph datasets/af_left_pval_realigned.txt datasets/af_left_coordinates.txt datasets/af_left_truncated_coordinates.txt datasets/af_left_average_coordinates.txt 0,2 pvals_realigned.png -f
  ~~~

  And this is the results

  ![](datasets/pvals_unaligned.png)
  ![](datasets/pvals_realigned.png)



  The main reference is

  ~~~
  Samuel St-Jean, Maxime Chamberland, Max A. Viergever, Alexander Leemans,
  Reducing variability in along-tract analysis with diffusion profile realignment,
  NeuroImage, 2019. ISSN 1053-811
  ~~~

  The data is also available at https://zenodo.org/record/2483169.

  The open access manuscript is also available at https://www.sciencedirect.com/science/article/pii/S1053811919305014.

  To refer to a specific version of the code, everything is also archived over at https://zenodo.org/record/3248894.


pkgId: ede64ba253843c896f0c35d0764f2e17171afdb9454c28f7d65783c59d4d14e2
name: python-dragonfly-core-help
arch: noarch
version: 1.57.18
epoch: 0
release: 1
summary: Development documents and examples for dragonfly-core
url: https://github.com/ladybug-tools/dragonfly-core
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dragonfly-core-1.57.18-1.src.rpm
location_href: Packages/python-dragonfly-core-help-1.57.18-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/ladybug-tools/dragonfly-core.svg?branch=master)](https://travis-ci.com/ladybug-tools/dragonfly-core)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/dragonfly-core/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/dragonfly-core)

  [![Python 3.10](https://img.shields.io/badge/python-3.10-orange.svg)](https://www.python.org/downloads/release/python-3100/) [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  ![Screenshot](https://github.com/chriswmackey/Dragonfly/blob/master/dragonfly.png)

  Dragonfly is a collection of Python libraries to create representations of buildings
  following [dragonfly-schema](https://github.com/ladybug-tools/dragonfly-schema/wiki).
  It abstracts the capabilities of [honeybee-core](https://github.com/ladybug-tools/honeybee-core/)
  to make it easier to construct and edit large models.

  This repository is the core repository that provides dragonfly's common functionalities.
  To extend these functionalities you should install available Dragonfly extensions or write
  your own.

  Here are a number of frequently used extensions for Dragonfly:
  - [dragonfly-energy](https://github.com/ladybug-tools/dragonfly-energy): Adds Energy simulation to Dragonfly.



  `pip install -U dragonfly-core`

  To check if Dragonfly command line interface is installed correctly use `dragonfly viz` and you
  should get a `viiiiiiiiiiiiizzzzzzzzz!` back in response!




  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/dragonfly-core.git



  git clone https://github.com/ladybug-tools/dragonfly-core.git
  ```
  2. Install dependencies:
  ```console
  cd dragonfly-core
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytests tests/
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./dragonfly
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: 281cfedbb9798e3e8d3e27265f8b9ea1a7de11d833f49f47824020a67bdd049d
name: python-dragonfly-energy-help
arch: noarch
version: 1.30.6
epoch: 0
release: 1
summary: Development documents and examples for dragonfly-energy
url: https://github.com/ladybug-tools/dragonfly-energy
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dragonfly-energy-1.30.6-1.src.rpm
location_href: Packages/python-dragonfly-energy-help-1.30.6-1.noarch.rpm
checksum_type: sha256
description:
  ![Dragonfly](https://www.ladybug.tools/assets/img/dragonfly.png)

  [![Build Status](https://github.com/ladybug-tools/dragonfly-energy/workflows/CI/badge.svg)](https://github.com/ladybug-tools/dragonfly-energy/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/dragonfly-energy/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/dragonfly-energy)

  [![Python 3.10](https://img.shields.io/badge/python-3.10-orange.svg)](https://www.python.org/downloads/release/python-3100/) [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Dragonfly extension for energy simulation, including integration with the
  [EnergyPlus](https://github.com/NREL/EnergyPlus) simulation engine, the
  [OpenStudio](https://github.com/NREL/OpenStudio) SDK, and the
  [URBANopt](https://docs.urbanopt.net/) SDK.



  `pip install dragonfly-energy`

  To check if Dragonfly command line interface is installed correctly
  use `dragonfly-energy --help`.



  ```python
  import dragonfly_energy
  ```




  Since the building geometry in dragonfly is fundamentally 2D, creating a model of
  a building and assigning energy model properties can be done with a few lines of
  code. Here is an example:

  ```python
  from dragonfly.model import Model
  from dragonfly.building import Building
  from dragonfly.story import Story
  from dragonfly.room2d import Room2D
  from dragonfly.windowparameter import SimpleWindowRatio
  from honeybee_energy.lib.programtypes import office_program


  pts_1 = (Point3D(0, 0, 3), Point3D(0, 10, 3), Point3D(10, 10, 3), Point3D(10, 0, 3))
  pts_2 = (Point3D(10, 0, 3), Point3D(10, 10, 3), Point3D(20, 10, 3), Point3D(20, 0, 3))
  pts_3 = (Point3D(0, 10, 3), Point3D(0, 20, 3), Point3D(10, 20, 3), Point3D(10, 10, 3))
  pts_4 = (Point3D(10, 10, 3), Point3D(10, 20, 3), Point3D(20, 20, 3), Point3D(20, 10, 3))
  room2d_1 = Room2D('Office1', Face3D(pts_1), 3)
  room2d_2 = Room2D('Office2', Face3D(pts_2), 3)
  room2d_3 = Room2D('Office3', Face3D(pts_3), 3)
  room2d_4 = Room2D('Office4', Face3D(pts_4), 3)
  story = Story('OfficeFloor', [room2d_1, room2d_2, room2d_3, room2d_4])
  story.solve_room_2d_adjacency(0.01)
  story.set_outdoor_window_parameters(SimpleWindowRatio(0.4))
  story.multiplier = 4
  building = Building('OfficeBuilding', [story])


  for room in story.room_2ds:
      room.properties.energy.program_type = office_program
      room.properties.energy.add_default_ideal_air()


  model = Model('NewDevelopment', [building])
  ```

  Once a Dragonfly Model has been created, it can be converted to a honeybee Model,
  which can then be converted to IDF format like so:

  ```python

  model = Model('NewDevelopment', [building])


  hb_models = model.to_honeybee('Building', use_multiplier=False, tolerance=0.01)
  idfs = [hb_model.to.idf(hb_model) for hb_model in hb_models]
  ```

  The dragonfly model can also be serialized to a geoJSON to be simulated with URBANopt.

  ```python
  from ladybug.location import Location


  model = Model('NewDevelopment', [building])


  location = Location('Boston', 'MA', 'USA', 42.366151, -71.019357)
  sim_folder = './tests/urbanopt_model'
  geojson, hb_model_jsons, hb_models = model.to.urbanopt(model, location, folder=sim_folder)
  ```



  1. Clone this repo locally
  ```
  git clone git@github.com:ladybug-tools/dragonfly-energy



  git clone https://github.com/ladybug-tools/dragonfly-energy
  ```
  2. Install dependencies:
  ```
  cd dragonfly-energy
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```
  python -m pytest tests/
  ```

  4. Generate Documentation:
  ```
  sphinx-apidoc -f -e -d 4 -o ./docs ./dragonfly_energy
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: 0e8d557b8894b9e45d966307c29a43851a4c83fbd419f8b6285504d045b15dce
name: python-dragonfly-radiance-help
arch: noarch
version: 0.3.216
epoch: 0
release: 1
summary: Development documents and examples for dragonfly-radiance
url: https://github.com/ladybug-tools/dragonfly-radiance
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dragonfly-radiance-0.3.216-1.src.rpm
location_href: Packages/python-dragonfly-radiance-help-0.3.216-1.noarch.rpm
checksum_type: sha256
description:
  ![Dragonfly](https://www.ladybug.tools/assets/img/dragonfly.png)

  [![Build Status](https://github.com/ladybug-tools/dragonfly-radiance/actions/workflows/ci.yaml/badge.svg)](https://github.com/ladybug-tools/dragonfly-radiance/actions)

  [![Python 3.10](https://img.shields.io/badge/python-3.10-orange.svg)](https://www.python.org/downloads/release/python-3100/) [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Dragonfly extension for Radiance simulation.



  `pip install dragonfly-radiance`

  To check if the command line interface is installed correctly
  use `dragonfly-radiance --help`.



  ```python
  import dragonfly_radiance
  ```





  1. Clone this repo locally
  ```
  git clone git@github.com:ladybug-tools/dragonfly-radiance



  git clone https://github.com/ladybug-tools/dragonfly-radiance
  ```
  2. Install dependencies:
  ```
  cd dragonfly-radiance
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```
  python -m pytest tests/
  ```

  4. Generate Documentation:
  ```
  sphinx-apidoc -f -e -d 4 -o ./docs ./dragonfly_radiance
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: e04ff164b602091d72a59497cc65841b84af106afb53793a234e9bf9334cd1e9
name: python-dragonfly-uwg-help
arch: noarch
version: 0.5.631
epoch: 0
release: 1
summary: Development documents and examples for dragonfly-uwg
url: https://github.com/ladybug-tools/dragonfly-uwg
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dragonfly-uwg-0.5.631-1.src.rpm
location_href: Packages/python-dragonfly-uwg-help-0.5.631-1.noarch.rpm
checksum_type: sha256
description:
  ![Dragonfly](https://www.ladybug.tools/assets/img/dragonfly.png)

  [![Build Status](https://github.com/ladybug-tools/dragonfly-uwg/workflows/CI/badge.svg)](https://github.com/ladybug-tools/dragonfly-uwg/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/dragonfly-uwg/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/dragonfly-uwg)

  [![Python 3.10](https://img.shields.io/badge/python-3.10-orange.svg)](https://www.python.org/downloads/release/python-3100/) ![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)(https://www.python.org/downloads/release/python-360/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Dragonfly extension for urban heat island modeling.

  Dragonfly-uwg uses the [Urban Weather Generator (uwg)](https://github.com/ladybug-tools/uwg)
  to morph EPW files to account for the [urban heat island effect](https://en.wikipedia.org/wiki/Urban_heat_island).



  `pip install -U dragonfly-uwg`



  ```console
  import dragonfly_uwg
  ```





  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/dragonfly-uwg



  git clone https://github.com/ladybug-tools/dragonfly-uwg
  ```
  2. Install dependencies:
  ```
  cd dragonfly-uwg
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytest tests/
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./dragonfly_uwg
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: 72e46ebc1da62a8d527a333db2b3cccdc107be58402dd8011218f6bc796fd31c
name: python-drbutil-help
arch: noarch
version: 0.0.14
epoch: 0
release: 1
summary: Development documents and examples for drbutil
url: https://github.com/dbukenberger/drbutil
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-drbutil-0.0.14-1.src.rpm
location_href: Packages/python-drbutil-help-0.0.14-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/drbutil.svg)](https://badge.fury.io/py/drbutil)

  A tiny collection of geometry processing routines frequently used in my prototyping code.

  Pure Python, low overhead and minimal dependencies.



  The only **actually required** library is [NumPy](https://github.com/numpy/numpy).

  **Optionally**,
  * [matplotlib](https://github.com/matplotlib/matplotlib) shows 2D results,
  * [Mayavi](https://github.com/enthought/mayavi) visualizes 3D results and
  * [tqdm](https://github.com/tqdm/tqdm) realizes progress bars in the shell.


  Install from [PyPI](https://pypi.org/project/drbutil/) with `pip install drbutil` or
  clone the repo and run the `buildAndInstall.bat/.sh` script.

  Then you can import everything in your project with `import drbutil` or `from drbutil import *`, respectively.


pkgId: 470915c9abf908a95b8eecfcbe7fe60871fd000e9a5af4821b5b15165e1ad8df
name: python-drf-aggregation-help
arch: noarch
version: 2.1.1
epoch: 0
release: 1
summary: Development documents and examples for drf-aggregation
url: https://github.com/kit-oz/drf-aggregation
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-drf-aggregation-2.1.1-1.src.rpm
location_href: Packages/python-drf-aggregation-help-2.1.1-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov badge](https://codecov.io/gh/kit-oz/drf-aggregation/branch/main/graph/badge.svg?token=X1RWDJI9NG)](https://codecov.io/gh/kit-oz/drf-aggregation)
  [![PyPI version](https://badge.fury.io/py/drf-aggregation.svg)](https://badge.fury.io/py/drf-aggregation)
  [![Python Versions](https://img.shields.io/pypi/pyversions/drf-aggregation.svg)](https://pypi.org/project/drf-aggregation/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  A Django Rest Framework (DRF) mixin for performing complex data aggregations with ease.



  - Perform multiple aggregations simultaneously
  - Calculate percentiles and percentages (requires additional setup)
  - Group data by multiple fields
  - Generate time series data (PostgreSQL, MySQL)
  - Flexible result limiting and pagination
  - Custom aggregation types support



  ```bash
  pip install drf-aggregation
  ```





  First, add the `AggregationMixin` to your viewset:

  ```python
  from drf_aggregation import AggregationMixin
  from rest_framework.viewsets import GenericViewSet

  class TicketViewSet(AggregationMixin, GenericViewSet):
      queryset = Ticket.objects.all()
      serializer_class = TicketSerializer
  ```

  Then, register the viewset with your router:

  ```python
  urlpatterns = [
      path("aggregation/ticket", TicketViewSet.as_view({"post": "aggregation"})),
  ]
  ```

  Once set up, you can make requests like the following:

  ```http
  POST /aggregation/ticket
  Content-Type: application/json
  {
      "group_by": "service",
      "limit": 5,
      "order_by": "-total_tasks",
      "aggregations": {
          "total_tasks": {
              "type": "count"
          },
          "average_execution_time": {
              "type": "average",
              "field": "execution_time"
          }
      }
  }
  ```



  You can also use the aggregation function directly:

  ```python
  from drf_aggregation import get_aggregations

  result = get_aggregations(
      queryset=Ticket.objects.all(),
      aggregations={
          "total_tasks": {
              "type": "count"
          }
      }
  )
  ```



  - **aggregations**: A dictionary specifying the aggregations to perform.
    - **key**: The name under which the aggregation result will be returned.
    - **value**: A dictionary with aggregation settings.
      - **type**: The type of aggregation (e.g., count, sum).
      - **index_by_group**: Index for sorting by a specific field.
      - **field**: Required for sum, average, minimum, maximum, percentile.
      - **percentile**: A value from 0 to 1, required for percentile calculations.
      - **additional_filter**: Uses filter parser from [drf-complex-filter](https://github.com/kit-oz/drf-complex-filter), required for percent.

  - **group_by**: List of fields to group the results by.
  - **order_by**: List of fields to sort the results.
  - **limit**: Number of groups to return or a dictionary with settings:
    - **limit**: Number of groups to return.
    - **offset**: Offset for the start of returned groups.
    - **by_group**: Field to limit the result by, defaults to the first grouping field.
    - **by_aggregation**: Aggregation to limit the result by, defaults to the first declared aggregation.
    - **show_other**: Return remaining records as an additional group.
    - **other_label**: Label for the additional group.



  - `IntegerField`
  - `FloatField`
  - `DateField` (min/max only)
  - `DateTimeField` (min/max only)
  - `DurationField`



  By default, the following aggregations are enabled: `count`, `distinct`, `sum`, `average`, `minimum`, `maximum`.

  To enable additional aggregations like percent and percentile, modify your `settings.py`:

  ```python

  DRF_AGGREGATION_SETTINGS = {
      "AGGREGATION_CLASSES": [
          "drf_aggregation.aggregations.common.CommonAggregations",
          
          "drf_aggregation.aggregations.percent.PercentAggregation",
          
          "drf_aggregation.aggregations.percentile.PercentileAggregation",
      ],
  }
  ```



  Create a class with static methods for custom aggregation types:

  ```python
  class MyAggregations:
      @staticmethod
      def my_aggregation(aggregation, queryset):
          name = aggregation.get("name")
          return {f"{name}": models.Count("id")}


  DRF_AGGREGATION_SETTINGS = {
      "AGGREGATION_CLASSES": [
          "drf_aggregation.aggregations.common.CommonAggregations",
          "path.to.MyAggregations",
      ],
  }

  result = get_aggregations(
      queryset=Ticket.objects.all(),
      aggregations={
          "value": {
              "type": "my_aggregation"
          }
      }
  )
  ```





  Group results by a list of fields:

  ```python
  result = get_aggregations(
      queryset=Ticket.objects.all(),
      aggregations={
          "total_tasks": {
              "type": "count"
          }
      },
      group_by=["field1", "field2"]
  )
  ```



  Sort results by specified fields:

  ```python
  result = get_aggregations(
      queryset=Ticket.objects.all(),
      aggregations={
          "total_tasks": {
              "type": "count"
          }
      },
      group_by="field1",
      order_by="field1"
  )
  ```

  Use aggregations as sorting keys:

  ```python
  result = get_aggregations(
      queryset=Ticket.objects.all(),
      aggregations={
          "total_tasks": {
              "type": "count"
          }
      },
      group_by="field1",
      order_by="-total_tasks"
  )
  ```



  Limit the number of displayed groups:

  ```python
  result = get_aggregations(
      queryset=Ticket.objects.all(),
      aggregations={
          "total_tasks": {
              "type": "count"
          }
      },
      group_by="field1",
      order_by="-total_tasks",
      limit=2
  )
  ```

  Display remaining groups as an additional category:

  ```python
  result = get_aggregations(
      queryset=Ticket.objects.all(),
      aggregations={
          "total_tasks": {
              "type": "count"
          }
      },
      group_by="field1",
      order_by="-total_tasks",
      limit={
          "limit": 2,
          "show_other": true
      }
  )
  ```



  **Note**: Time series aggregations are not supported on SQLite.

  To perform time series aggregations, annotate your queryset with a truncated date field:

  ```python
  truncate_rules = { "created_at": "day" }
  queryset = truncate_date(Ticket.objects.all(), truncate_rules)

  result = get_aggregations(
      queryset=queryset,
      aggregations={
          "total_tasks": {
              "type": "count"
          }
      },
      group_by="created_at__trunc__day"
  )
  ```

  Using `AggregationMixin`, pass `truncate_rules` in the request body:

  ```http
  POST /aggregation/ticket
  Content-Type: application/json
  {
      "truncate_rules": { "created_at": "day" },
      "group_by": "created_at__trunc__day",
      "aggregations": {
          "total_tasks": {
              "type": "count"
          }
      }
  }
  ```

  Available truncation periods: `year`, `quarter`, `month`, `week`, `day`, `hour`, `minute`, `second`

  For more details on date truncation, see the [Django documentation](https://docs.djangoproject.com/en/3.1/ref/models/database-functions/#trunc).



  Contributions are welcome! Please feel free to submit a Pull Request.



  This project is licensed under the MIT License.

rpm_license:
  MIT License  Copyright (c) 2020 Nikita Balobanov  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: 9f264943ccf62bc1b5265a9b8a4c8d4239eb92859e63585baea51541b26f6220
name: python-drf-complex-filter-help
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Development documents and examples for drf-complex-filter
url: https://github.com/kit-oz/drf-complex-filter
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-drf-complex-filter-2.0.1-1.src.rpm
location_href: Packages/python-drf-complex-filter-help-2.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/kit-oz/drf-complex-filter/branch/main/graph/badge.svg?token=B6Z1LWBXOP)](https://codecov.io/gh/kit-oz/drf-complex-filter)
  [![PyPI version](https://badge.fury.io/py/drf-complex-filter.svg)](https://badge.fury.io/py/drf-complex-filter)
  [![Python Versions](https://img.shields.io/pypi/pyversions/drf-complex-filter.svg)](https://pypi.org/project/drf-complex-filter/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  A powerful and flexible declarative filter for Django ORM that enables complex query construction through a simple JSON-based API. Perfect for building advanced filtering capabilities in your Django REST Framework applications.



  - **Advanced Filtering**: Complex AND/OR operations with nested conditions
  - **Declarative Syntax**: Simple JSON-based query structure
  - **Dynamic Values**: Support for computed values and server-side calculations
  - **Related Model Queries**: Efficient subquery handling for related models
  - **Extensible**: Easy to add custom operators and value functions
  - **Type Safe**: Built-in operator validation
  - **DRF Integration**: Seamless integration with Django REST Framework



  ```bash
  pip install drf-complex-filter
  ```



  1. Add `ComplexQueryFilter` to your ViewSet:

  ```python
  from drf_complex_filter.filters import ComplexQueryFilter

  class UserViewSet(ModelViewSet):
      queryset = User.objects.all()
      serializer_class = UserSerializer
      filter_backends = [ComplexQueryFilter]
  ```

  2. Make API requests with complex filters:

  ```bash

  GET /users?filters={"type":"operator","data":{"attribute":"first_name","operator":"=","value":"John"}}


  GET /users?filters={"type":"and","data":[
      {"type":"operator","data":{"attribute":"age","operator":">","value":18}},
      {"type":"operator","data":{"attribute":"is_active","operator":"=","value":true}}
  ]}
  ```




  ```python
  {
      "type": "operator",
      "data": {
          "attribute": "field_name",
          "operator": "=",
          "value": "value_to_compare"
      }
  }
  ```


  ```python
  {
      "type": "and",
      "data": [
          
      ]
  }
  ```


  ```python
  {
      "type": "or",
      "data": [
          
      ]
  }
  ```



  | Operator | Description | Symbol |
  |----------|-------------|---------|
  | Is | Equality | = |
  | Is not | Inequality | != |
  | Contains | Case-insensitive contains | * |
  | Not contains | Case-insensitive not contains | ! |
  | Greater | Greater than | > |
  | Greater or equal | Greater than or equal | >= |
  | Less | Less than | < |
  | Less or equal | Less than or equal | <= |
  | In | Value in list | in |
  | Not in | Value not in list | not_in |
  | Current user | Current authenticated user | me |
  | Not current user | Not current authenticated user | not_me |





  1. Create your operator class:
  ```python
  class CustomOperators:
      def get_operators(self):
          return {
              "custom_op": lambda f, v, r, m: Q(**{f"{f}__custom": v}),
          }
  ```

  2. Register in settings:
  ```python
  COMPLEX_FILTER_SETTINGS = {
      "COMPARISON_CLASSES": [
          "drf_complex_filter.comparisons.CommonComparison",
          "path.to.CustomOperators",
      ],
  }
  ```



  1. Create value functions:
  ```python
  class CustomFunctions:
      def get_functions(self):
          return {
              "current_time": lambda request, model: timezone.now(),
          }
  ```

  2. Register in settings:
  ```python
  COMPLEX_FILTER_SETTINGS = {
      "VALUE_FUNCTIONS": [
          "drf_complex_filter.functions.DateFunctions",
          "path.to.CustomFunctions",
      ],
  }
  ```

  3. Use in filters:
  ```python
  {
      "type": "operator",
      "data": {
          "attribute": "created_at",
          "operator": ">",
          "value": {
              "func": "current_time",
              "kwargs": {}
          }
      }
  }
  ```



  Use `ModelName___` prefix for efficient subqueries:
  ```python
  {
      "type": "operator",
      "data": {
          "attribute": "Profile___is_verified",
          "operator": "=",
          "value": true
      }
  }
  ```



  - Python >= 3.6
  - Django >= 3.0.0
  - Django REST Framework



  Contributions are welcome! Please feel free to submit a Pull Request.



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

rpm_license:
  MIT License  Copyright (c) 2020 Nikita Balobanov  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: c2de86464b071e05363e0d9e2341268e0d28cf326f1dbc8391bd0db7c522796f
name: python-drfexts-help
arch: noarch
version: 3.13.1
epoch: 0
release: 1
summary: Development documents and examples for drfexts
url: https://github.com/aiden520/drfexts
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-drfexts-3.13.1-1.src.rpm
location_href: Packages/python-drfexts-help-3.13.1-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub license](https://img.shields.io/github/license/aiden520/drfexts)](https://github.com/aiden520/drfexts/blob/master/LICENSE)
  [![pypi-version](https://img.shields.io/pypi/v/drfexts.svg)](https://pypi.python.org/pypi/drfexts)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/drfexts)
  [![PyPI - Django Version](https://img.shields.io/badge/django-%3E%3D3.0-44B78B)](https://www.djangoproject.com/)
  [![PyPI - DRF Version](https://img.shields.io/badge/djangorestframework-%3E%3D3.0-red)](https://www.django-rest-framework.org)
  [![Build Status](https://app.travis-ci.com/aiden520/drfexts.svg?branch=master)](https://app.travis-ci.com/aiden520/drfexts)
  [![Black code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  **Extensions for Django REST Framework**


pkgId: 328e78c840f05ef1b40ed38931dced2d527f6234f58595ace68b669bf41fb393
name: python-dria-help
arch: noarch
version: 0.0.100
epoch: 0
release: 1
summary: Development documents and examples for dria
url: https://github.com/firstbatchxyz/dria-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dria-0.0.100-1.src.rpm
location_href: Packages/python-dria-help-0.0.100-1.noarch.rpm
checksum_type: sha256
description:
  Dria SDK is a powerful toolkit for building AI datasets and training pipelines. It provides a flexible framework for generating synthetic conversations, managing data formats, and working with various AI models.




  [Docs](docs.dria.co)


pkgId: 79bf079c2c63c7dd970f732e96f79508056672d6bd2385e87c9bba54d014f4bd
name: python-driftpy-help
arch: noarch
version: 0.7.98
epoch: 0
release: 1
summary: Development documents and examples for driftpy
url: https://github.com/drift-labs/driftpy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-driftpy-0.7.98-1.src.rpm
location_href: Packages/python-driftpy-help-0.7.98-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
      <img src="docs/img/drift.png" width="30%" height="30%">
  </div>

  DriftPy is the Python client for the [Drift](https://www.drift.trade/) protocol.
  It allows you to trade and fetch data from Drift using Python.

  **[Read the full SDK documentation here!](https://drift-labs.github.io/v2-teacher/)**



  ```
  pip install driftpy
  ```

  Note: requires Python >= 3.10.




  - `examples/` folder includes more examples of how to use the SDK including how to provide liquidity/become an lp, stake in the insurance fund, etc.




  If you are using QuickNode free plan, you *must* use `AccountSubscriptionConfig("demo")`, and you can only subscribe to 1 perp market and 1 spot market at a time.

  Non-QuickNode free RPCs (including the public mainnet-beta url) can use `cached` as well.

  Example setup for `AccountSubscriptionConfig("demo")`:

  ```python
      
      

      perp_markets = [0, 1]
      spot_market_oracle_infos, perp_market_oracle_infos, spot_market_indexes = get_markets_and_oracles(perp_markets = perp_markets)

      oracle_infos = spot_market_oracle_infos + perp_market_oracle_infos

      drift_client = DriftClient(
          connection,
          wallet,
          "mainnet",
          perp_market_indexes = perp_markets,
          spot_market_indexes = spot_market_indexes,
          oracle_infos = oracle_infos,
          account_subscription = AccountSubscriptionConfig("demo"),
      )
      await drift_client.subscribe()
  ```
  If you intend to use `AccountSubscriptionConfig("demo)`, you *must* call `get_markets_and_oracles` to get the information you need.

  `get_markets_and_oracles` will return all the necessary `OracleInfo`s and `market_indexes` in order to use the SDK.





  `bash setup.sh`


  Ensure correct python version (using pyenv is recommended):
  ```bash
  pyenv install 3.10.11
  pyenv global 3.10.11
  poetry env use $(pyenv which python)
  ```

  Install dependencies:
  ```bash
  poetry install
  ```

  To run tests, first ensure you have set up the RPC url, then run `pytest`:
  ```bash
  export MAINNET_RPC_ENDPOINT="<YOUR_RPC_URL>"
  export DEVNET_RPC_ENDPOINT="https://api.devnet.solana.com" # or your own RPC

  poetry run pytest -v -s -x tests/ci/*.py
  poetry run pytest -v -s tests/math/*.py
  ```


pkgId: f360ed5a6eebee3ceba80de509a499938f08630e2ff576fe158608a984ef7d42
name: python-drlogger-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for drlogger
url: https://pypi.org/project/drlogger/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-drlogger-2.0.0-1.src.rpm
location_href: Packages/python-drlogger-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">DrLogger</h1>
  <p align="center">A python package for logging</p>

  > :warning:	NOT production ready, don't use in production


pkgId: a5c347aeb1ce22f30955a5adf99177036e130698ea887e51fbb584348f393d1d
name: python-dropletdvaporationsimulation-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for dropletdvaporationsimulation
url: https://github.com/guillaume-bailly/DropletEvaporationSimulation
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dropletdvaporationsimulation-1.1.2-1.src.rpm
location_href: Packages/python-dropletdvaporationsimulation-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Coverage Status](https://coveralls.io/repos/github/guillaume-bailly/DropletEvaporationSimulation/badge.svg?branch=main)](https://coveralls.io/github/guillaume-bailly/DropletEvaporationSimulation?branch=main)
  [![Documentation Status](https://readthedocs.org/projects/dropletevaporationsimulation/badge/?version=latest)](https://dropletevaporationsimulation.readthedocs.io/en/latest/)
  ![Test Status](https://github.com/guillaume-bailly/DropletEvaporationSimulation/actions/workflows/tests.yml/badge.svg)
  ![PyPI](https://img.shields.io/pypi/v/DropletEvaporationSimulation)



  This project simulates the evaporation and dynamics of an n-Decane droplet in a heated airflow, using both the D² Law and Infinite Liquid Conductivity models. It visualizes droplet diameter, temperature, velocity, and axial position over time.

  It can be used to compute the minimal axial length of a combustion chamber to ensure full envaporation of the droplet.

  Droplet properties can be modified in src/constants.py to simulate the vaporization of desired fuel.



  - **D² Law Model** and **Infinite Liquid Conductivity Model** simulations
  - Plots for droplet diameter, temperature, axial velocity and position
  - Adjustable parameters and configurations for droplet properties and environmental conditions



  ```bash
  git clone https://github.com/guillaume-bailly/DropletEvaporationSimulation.git
  cd DropletEvaporationSimulation
  pip install -r requirements.txt
  ```



  https://dropletevaporationsimulation.readthedocs.io/en/latest/


pkgId: a742572d7af7231ac94ade7f6cd18ec529e7f807686011d52ed3b063e3b1ad06
name: python-dropletevaporationsimulation-help
arch: noarch
version: 1.1.5
epoch: 0
release: 1
summary: Development documents and examples for dropletevaporationsimulation
url: https://github.com/guillaume-bailly/DropletEvaporationSimulation
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dropletevaporationsimulation-1.1.5-1.src.rpm
location_href: Packages/python-dropletevaporationsimulation-help-1.1.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Coverage Status](https://coveralls.io/repos/github/guillaume-bailly/DropletEvaporationSimulation/badge.svg?branch=main)](https://coveralls.io/github/guillaume-bailly/DropletEvaporationSimulation?branch=main)
  [![Documentation Status](https://readthedocs.org/projects/dropletevaporationsimulation/badge/?version=latest)](https://dropletevaporationsimulation.readthedocs.io/en/latest/)
  ![Test Status](https://github.com/guillaume-bailly/DropletEvaporationSimulation/actions/workflows/tests.yml/badge.svg)
  ![PyPI](https://img.shields.io/pypi/v/dropletevaporationsimulation)



  This project simulates the evaporation and dynamics of an n-Decane droplet in a heated airflow, using both the D² Law and Infinite Liquid Conductivity models. It visualizes droplet diameter, temperature, velocity, and axial position over time.

  It can be used to compute the minimal axial length of a combustion chamber to ensure full envaporation of the droplet.

  Droplet properties can be modified in src/constants.py to simulate the vaporization of desired fuel.



  - **D² Law Model** and **Infinite Liquid Conductivity Model** simulations
  - Plots for droplet diameter, temperature, axial velocity and position
  - Adjustable parameters and configurations for droplet properties and environmental conditions



  ```bash
  git clone https://github.com/guillaume-bailly/DropletEvaporationSimulation.git
  cd DropletEvaporationSimulation
  pip install -r requirements.txt
  ```



  https://dropletevaporationsimulation.readthedocs.io/en/latest/


pkgId: 9f5d811809edde02e9b0824af6af9d8d87555a78731e0b2b24b54c21a388de84
name: python-ds-caselaw-marklogic-api-client-help
arch: noarch
version: 28.2.0
epoch: 0
release: 1
summary: Development documents and examples for ds-caselaw-marklogic-api-client
url: https://github.com/nationalarchives/ds-caselaw-custom-api-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ds-caselaw-marklogic-api-client-28.2.0-1.src.rpm
location_href: Packages/python-ds-caselaw-marklogic-api-client-help-28.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This repository is part of the [Find Case Law](https://caselaw.nationalarchives.gov.uk/) project at [The National Archives](https://www.nationalarchives.gov.uk/). For more information on the project, check [the documentation](https://github.com/nationalarchives/ds-find-caselaw-docs).



  [![PyPI](https://img.shields.io/pypi/v/ds-caselaw-marklogic-api-client)](https://pypi.org/project/ds-caselaw-marklogic-api-client/) ![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/pypi/ds-caselaw-marklogic-api-client)

  This is an API Client for connecting to Marklogic for The National Archive's Caselaw site.

  This package is published on PyPI: https://pypi.org/project/ds-caselaw-marklogic-api-client/



  You can find documentation of the client class and available methods [here](https://nationalarchives.github.io/ds-caselaw-custom-api-client).



  To run the test suite:

  ```bash
  poetry install
  poetry run pytest
  ```

  There are also some smoketests in `smoketests.py` which run against a MarkLogic database but do not run in CI currently.

  To run them locally you can set the environment variables as detailed in the file in a `.env` file or just hardcode them in, as long as you don't commit those changes to the repo.

  And then run

  ```bash
  poetry run pytest smoketest.py
  ```

  To start with when running this, we have been choosing to point to the staging MarkLogic to have more confidence that the setup is a good representation of production as opposed to a local MarkLogic instance but that can work too.

  Eventually we will make it so that we run these tests in CI and probably point to a dedicated testing MarkLogic instance so we don't get conflicts with people using staging for manual testing.



  When making a change, update the [changelog](CHANGELOG.md) using the
  [Keep a Changelog 1.0.0](https://keepachangelog.com/en/1.0.0/) format. Pull
  requests should not be merged before any relevant updates are made.



  When making a new release, update the [changelog](CHANGELOG.md) in the release
  pull request.

  The package will **only** be released to PyPI if the branch is tagged. A merge
  to main alone will **not** trigger a release to PyPI.

  To create a release:

  0. Update the version number in `pyproject.toml`
  1. Create a branch `release/v{major}.{minor}.{patch}`
  2. Update `CHANGELOG.md` for the release
  3. Commit and push
  4. Open a PR from that branch to main
  5. Get approval on the PR
  6. Merge the PR to main and push
  7. Tag the merge commit on `main` with `v{major}.{minor}.{patch}` and push the tag
  8. Create a release in [Github releases](https://github.com/nationalarchives/ds-caselaw-custom-api-client/releases)
     using the created tag

  If the release fails to push to PyPI, you can delete the tag with `git pull`, `git push --delete origin v1.2.3` and try again.


pkgId: c57a24a5cc329d8180083c053b5624959e7e412893bf5ebe2bdd0ee46f915b00
name: python-dsd-codered-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for dsd-codered
url: https://pypi.org/project/dsd-codered/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dsd-codered-0.1.0-1.src.rpm
location_href: Packages/python-dsd-codered-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  To deploy your project to CodeRed, you'll need to take some steps through the CodeRed web site. But once you set up an initial project there, django-simple-deploy can make all the necessary changes to your project for a successful deployment.

  Deployment to CodeRed requires the following:
  - You must be using Git to track your project.
  - You need to be tracking your dependencies with a `requirements.txt` file, or be using Poetry or Pipenv.
  - You'll need a [CodeRed account](https://app.codered.cloud/login/), and an [API token](https://www.codered.cloud/docs/cli/quickstart/).
  - You need to create a Django project in the CodeRed admin interface:
    - Choose Django, and set the database to Postgres.

  First, install `dsd-codered` and add `simple_deploy` to `INSTALLED_APPS` in *settings.py*:
  ```sh
  $ pip install dsd-codered cr

  $ git commit -am "Added simple_deploy to INSTALLED_APPS."
  ```
  When you install `dsd-codered`, it will install `django-simple-deploy` as a dependency. `cr` is CodeRed's [CLI tool](https://www.codered.cloud/docs/cli/); if you already have it installed system-wide, you don't need to install it to your project.
  Now run the `deploy` command:
  ```sh
  $ python manage.py deploy
  ```
  This is the `deploy` command from `django-simple-deploy`, which makes all the changes you need to run your project on CodeRed.
  At this point, you should review the changes that were made to your project. Running `git status` will show you which files were modified, and which files were created for a successful deployment. If you want to continue with the deployment process, commit these changes. Then set an environment variable with your CodeRed API token, and run the `cr deploy` command:
  ```sh
  $ git add .
  $ git commit -m "Configured for deployment to CodeRed."
  $ export CR_TOKEN=<api-token>
  $ cr deploy <codered-app-name>
  ```
  Here, `<codered-app-name>` is the name you chose when you created a new project in the CodeRed admin interface. The last line of output will show you the URL for your deployed project. You can also find this URL in your CodeRed admin interace.
  You can find a record of the deployment process in `simple_deploy_logs`. It contains most of the output you saw when running `deploy`.


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





  1. Outlier_IQR(df, columns)
     Identifies and handles outliers in the specified columns using the Interquartile Range (IQR) method.
     Parameters:

      - df: DataFrame — The input data in which outliers will be detected.
      - columns: list — List of column names in which outliers need to be identified.

  2. Outlier_Winsorizer(df, column, capping_method='iqr')
     Applies Winsorization to cap outliers in the specified column using either IQR or other capping methods.
     Parameters:

      - df: DataFrame — The input data to apply Winsorization.
      - column: str — The name of the column to apply the Winsorization to.
      - capping_method: str, default 'iqr' — Method used to define the outlier thresholds (options: 'iqr' , std, 'quantiles' or 'mad').

  3. Outlier_Clip(df, columns)
     Clips extreme values to a predefined threshold in the specified columns, effectively handling outliers.
     Parameters:

      - df: DataFrame — The input data to clip outliers from.
      - columns: list — List of columns in which to clip the outliers.

  4. MissingVal_Repl(df, columns, type='mean')
     Replaces missing values in the specified columns using a chosen method.
     Parameters:

      - df: DataFrame — The input data in which missing values will be replaced.
      - columns: list — List of column names where missing values need to be replaced.
      - type: str, default 'mean' — The method used for replacement ('mean', 'median', or mode)

  5. MissingVal_Imputer(df,columns,strategy='mean')
     The MissingVal_Imputer function is designed to handle missing values in specified columns of a pandas DataFrame using different imputation strategies. It replaces missing values (NaN) with appropriate values based on the chosen strategy.
     Parameters:

      - df (pandas.DataFrame): The input DataFrame where missing values need to be imputed.
      - columns (list): A list of column names where missing value imputation is to be applied.
      - strategy (str, default='mean'):The strategy for imputing missing values. Supported values:
        'mean': Replaces missing values with the mean of the column.
        'median': Replaces missing values with the median of the column.
        'mode': Replaces missing values with the most frequent value in the column (converted to 'most_frequent' internally).

  6. MissingVal_Fillna(df)
     Identifies and returns all rows in the DataFrame that contain missing values with mean for numeric columns and mode (with index[0]) for object.
     Parameters:

      - df: DataFrame — The input data to check for missing values.



  7. outlierColumns(df)
     Returns a list of columns that contain outliers based on IQR.
     Parameters:

      - df: DataFrame — The input data to check for outliers.

  8. outlierCount(df, columns)
     Counts the number of outliers in the specified columns.
     Parameters:

      - df: DataFrame — The input data to count outliers in.
      - columns: list — List of columns to check for outliers.

  9. highFrequency(df, perc=0.5)
     Identifies and returns columns where more than the given percentage (default 70%) of values are identical, typically used to detect low-variance or high-frequency columns.
     Parameters:
      - df: DataFrame — The input data to identify high-frequency columns.
      - perc: float, default 0.5 — The percentage threshold for identifying high-frequency columns.



  10. Encoding(df, method='label')
      Encodes categorical columns into numeric labels for compatibility with machine learning algorithms.
      Parameters:

      -   df: A Pandas DataFrame containing the dataset.
      -   method: 'label' for label encoding OR 'onehot' for OneHotEncoding

  11. Scaler(df, method='minmax')
      Scales numerical data for better performance during machine learning model training.
      Parameters:

      -   df: A Pandas DataFrame containing numeric data.
      -   method: Specifies the scaling technique to use. Options are:
          'minmax' (default): Rescales data to a range of 0 to 1.
          'standard': Standardizes data to have a mean of 0 and a standard deviation of 1.
          'robust': Scales data using the median and interquartile range, making it robust to outliers.



  General code fixes



  Redundant Code removed



  General code fixes



  12. Outlier_MMM(df, columns, type='median')
      This function is designed to identify and handle outliers in the specified columns of a given DataFrame. It uses the Interquartile Range (IQR) method to determine outliers and replaces the outliers with a user-defined statistic (mean, median, or mode).

      Parameters:
      df (DataFrame): The input pandas DataFrame that contains the data to be processed.
      columns (list of str): A list of column names in the DataFrame where outlier handling should be applied.
      type (str, optional): The statistic used to replace the outliers. It can be one of 'mean', 'median', or 'mode'. The default is 'median'.

  13. LowVarianceCols(df)
      This function detects columns in a DataFrame with very low variance (i.e., columns where the values are almost constant or do not vary much). Columns with zero variance are identified as low-variance columns. Returns a list of column names that have low variance (IQR = 0)

      Parameters:
      df (DataFrame): The input pandas DataFrame for which low variance columns need to be identified.
      Method:


pkgId: e5e03bf36b9c4bcd6c071508fb7c741e512d18969ddb058ed2ecabc3f988d140
name: python-dsms-sdk-help
arch: noarch
version: 2.0.4
epoch: 0
release: 1
summary: Development documents and examples for dsms-sdk
url: https://github.com/MI-FraunhoferIWM/dsms-python-sdk
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dsms-sdk-2.0.4-1.src.rpm
location_href: Packages/python-dsms-sdk-help-2.0.4-1.noarch.rpm
checksum_type: sha256
description:
  Python SDK core-package for interacting with the Dataspace Management System (DSMS)





  ```{python}
  pip install dsms-sdk
  ```



  ```{bash}
  git clone git@github.com:MI-FraunhoferIWM/dsms-python-sdk.git
  cd dsms-python-sdk
  pip install -e .
  ```



  The SDK provides a general Python interface to a remote DSMS deployment, allowing users to access, store and link data in a DSMS instance easily and safely. The package provides the following main capabilities:

  - Managing Knowledge-Items (KItems), which are data instances of an explicitly defined semantic class type (KType)
   - Creating, updating and deleting meta data and properties, e.g. date, operator, material response data for a conducted tensile test
   - Administrating authorship, contact information and supplementary information upon making changes or adding KItems
   - Semantic annotation of KItems
  - Conduct simple free-text searches within the DSMS instance including filters (e.g. limiting the search for certain materials) as well as a more experts-aware SPARQL interface
  - Linking KItems to other KItems
  - Linking Apps to KItems, triggererd, for example, during a file upload
  - Performing simple file upload and download using attachments to KItems
  - Export of a knowledge (sub) graph as common serializations (.ttl, .json)




  Please have a look at our documentation on _readthedocs_:
  https://dsms-python-sdk.readthedocs.io



  Please have a look at our tutorials on _readthedocs_:
  * [1. Introduction](https://dsms-python-sdk.readthedocs.io/en/latest/dsms_sdk/tutorials/1_introduction.html)
  * [2. Creation](https://dsms-python-sdk.readthedocs.io/en/latest/dsms_sdk/tutorials/2_creation.html)
  * [3. Updation](https://dsms-python-sdk.readthedocs.io/en/latest/dsms_sdk/tutorials/3_updation.html)
  * [4. Deletion](https://dsms-python-sdk.readthedocs.io/en/latest/dsms_sdk/tutorials/4_deletion.html)
  * [5. Search](https://dsms-python-sdk.readthedocs.io/en/latest/dsms_sdk/tutorials/5_search.html)
  * [6. Apps](https://dsms-python-sdk.readthedocs.io/en/latest/dsms_sdk/tutorials/6_apps.html)

  Or try our Jupyter Notebooks:
  * [1. Introduction](examples/tutorials/1_introduction.ipynb)
  * [2. Creation](examples/tutorials/2_creation.ipynb)
  * [3. Updation](examples/tutorials/3_updation.ipynb)
  * [4. Deletion](examples/tutorials/4_deletion.ipynb)
  * [5. Search](examples/tutorials/5_search.ipynb)
  * [6. Apps](examples/tutorials/6_apps.ipynb)



  [Matthias Büschelberger](mailto:matthias.bueschelberger@iwm.fraunhofer.de) (Fraunhofer Institute for Mechanics of Materials IWM)

  [Yoav Nahshon](mailto:yoav.nahshon@iwm.fraunhofer.de) (Fraunhofer Institute for Mechanics of Materials IWM)

  [Pablo De Andres](mailto:pablo.de.andres@iwm.fraunhofer.de) (Fraunhofer Institute for Mechanics of Materials IWM)

  [Priyabrat Mishra](mailto:priyabrat.mishra@iwm.fraunhofer.de) (Fraunhofer Institute for Mechanics of Materials IWM)



  This project is licensed under the BSD 3-Clause. See the LICENSE file for more information.




  Copyright (c) 2014-2024, Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. acting on behalf of its Fraunhofer IWM.

  Contact: [Matthias Büschelberger](mailto:matthias.bueschelberger@iwm.fraunhofer.de)


pkgId: 51f06144e7eaf227723b51dee0eb9994cb60d8fc66547ab2a65a06d7def4864c
name: python-dsrag-help
arch: noarch
version: 0.4.5
epoch: 0
release: 1
summary: Development documents and examples for dsrag
url: https://github.com/D-Star-AI/dsRAG
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dsrag-0.4.5-1.src.rpm
location_href: Packages/python-dsrag-help-0.4.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Discord](https://img.shields.io/discord/1234629280755875881.svg?label=Discord&logo=discord&color=7289DA)](https://discord.gg/NTUVX9DmQ3)

  **Note:** If you’re using (or planning to use) dsRAG in production, please fill out this short [form](https://forms.gle/RQ5qFVReonSHDcCu5) telling us about your use case. This helps us prioritize new features. In return I’ll give you my personal email address, which you can use for priority email support.


  dsRAG is a retrieval engine for unstructured data. It is especially good at handling challenging queries over dense text, like financial reports, legal documents, and academic papers. dsRAG achieves substantially higher accuracy than vanilla RAG baselines on complex open-book question answering tasks. On one especially challenging benchmark, [FinanceBench](https://arxiv.org/abs/2311.11944), dsRAG gets accurate answers 83% of the time, compared to the vanilla RAG baseline which only gets 19% of questions correct.

  There are three key methods used to improve performance over vanilla RAG systems:
  1. Semantic sectioning
  2. AutoContext
  3. Relevant Segment Extraction (RSE)


  Semantic sectioning uses an LLM to break a document into sections. It works by annotating the document with line numbers and then prompting an LLM to identify the starting and ending lines for each “semantically cohesive section.” These sections should be anywhere from a few paragraphs to a few pages long. The sections then get broken into smaller chunks if needed. The LLM is also prompted to generate descriptive titles for each section. These section titles get used in the contextual chunk headers created by AutoContext, which provides additional context to the ranking models (embeddings and reranker), enabling better retrieval.


  AutoContext creates contextual chunk headers that contain document-level and section-level context, and prepends those chunk headers to the chunks prior to embedding them. This gives the embeddings a much more accurate and complete representation of the content and meaning of the text. In our testing, this feature leads to a dramatic improvement in retrieval quality. In addition to increasing the rate at which the correct information is retrieved, AutoContext also substantially reduces the rate at which irrelevant results show up in the search results. This reduces the rate at which the LLM misinterprets a piece of text in downstream chat and generation applications.


  Relevant Segment Extraction (RSE) is a query-time post-processing step that takes clusters of relevant chunks and intelligently combines them into longer sections of text that we call segments. These segments provide better context to the LLM than any individual chunk can. For simple factual questions, the answer is usually contained in a single chunk; but for more complex questions, the answer usually spans a longer section of text. The goal of RSE is to intelligently identify the section(s) of text that provide the most relevant information, without being constrained to fixed length chunks.

  For example, suppose you have a bunch of SEC filings in a knowledge base and you ask “What were Apple’s key financial results in the most recent fiscal year?” RSE will identify the most relevant segment as the entire “Consolidated Statement of Operations” section, which will be 5-10 chunks long. Whereas if you ask “Who is Apple’s CEO?” the most relevant segment will be identified as a single chunk that mentions “Tim Cook, CEO.”


  We've evaluated dsRAG on a couple of end-to-end RAG benchmarks.


  First, we have [FinanceBench](https://arxiv.org/abs/2311.11944). This benchmark uses a corpus of a few hundred 10-Ks and 10-Qs. The queries are challenging, and often require combining multiple pieces of information. Ground truth answers are provided. Answers are graded manually on a pass/fail basis. Minor allowances for rounding errors are allowed, but other than that the answer must exactly match the ground truth answer to be considered correct.

  The baseline retrieval pipeline, which uses standard chunking and top-k retrieval, achieves a score of **19%** according to the paper. dsRAG, using default parameters and AutoQuery for query generation, achieves a score of **83%**.


  We couldn't find any other suitable end-to-end RAG benchmarks, so we decided to create our own, called [KITE](https://github.com/D-Star-AI/KITE) (Knowledge-Intensive Task Evaluation).

  KITE currently consists of 4 datasets and a total of 50 questions.
  - **AI Papers** - ~100 academic papers about AI and RAG, downloaded from arXiv in PDF form.
  - **BVP Cloud 10-Ks** - 10-Ks for all companies in the Bessemer Cloud Index (~70 of them), in PDF form.
  - **Sourcegraph Company Handbook** - ~800 markdown files, with their original directory structure, downloaded from Sourcegraph's publicly accessible company handbook GitHub [page](https://github.com/sourcegraph/handbook/tree/main/content).
  - **Supreme Court Opinions** - All Supreme Court opinions from Term Year 2022 (delivered from January '23 to June '23), downloaded from the official Supreme Court [website](https://www.supremecourt.gov/opinions/slipopinion/22) in PDF form.

  Ground truth answers are included with each sample. Most samples also include grading rubrics. Grading is done on a scale of 0-10 for each question, with a strong LLM doing the grading.

  We tested four configurations:
  - Top-k retrieval (baseline)
  - Relevant segment extraction (RSE)
  - Top-k retrieval with contextual chunk headers (CCH)
  - CCH+RSE (dsRAG default config, minus semantic sectioning)

  Testing RSE and CCH on their own, in addition to testing them together, lets us see the individual contributions of those two features.

  Cohere English embeddings and the Cohere 3 English reranker were used for all configurations. LLM responses were generated with GPT-4o, and grading was also done with GPT-4o.

  |                         | Top-k    | RSE    | CCH+Top-k    | CCH+RSE    |
  |-------------------------|----------|--------|--------------|------------|
  | AI Papers               | 4.5      | 7.9    | 4.7          | 7.9        |
  | BVP Cloud               | 2.6      | 4.4    | 6.3          | 7.8        |
  | Sourcegraph             | 5.7      | 6.6    | 5.8          | 9.4        |
  | Supreme Court Opinions  | 6.1      | 8.0    | 7.4          | 8.5        |
  | **Average**             | 4.72     | 6.73   | 6.04         | 8.42       |

  Using CCH and RSE together leads to a dramatic improvement in performance, from 4.72 -> 8.42. Looking at the RSE and CCH+Top-k results, we can see that using each of those features individually leads to a large improvement over the baseline, with RSE appearing to be slightly more important than CCH.

  To put these results in perspective, we also tested the CCH+RSE configuration with a smaller model, GPT-4o Mini. As expected, this led to a decrease in performance compared to using GPT-4o, but the difference was surprisingly small (7.95 vs. 8.42). Using CCH+RSE with GPT-4o Mini dramatically outperforms the baseline RAG pipeline even though the baseline uses a 17x more expensive LLM. This suggests that the LLM plays a much smaller role in end-to-end RAG system accuracy than the retrieval pipeline does.

  |                         | CCH+RSE (GPT-4o) | CCH+RSE (GPT-4o Mini) |
  |-------------------------|------------------|-----------------------|
  | AI Papers               | 7.9              | 7.0                   |
  | BVP Cloud               | 7.8              | 7.9                   |
  | Sourcegraph             | 9.4              | 8.5                   |
  | Supreme Court Opinions  | 8.5              | 8.4                   |
  | **Average**             | 8.42             | 7.95                  |

  Note: we did not use semantic sectioning for any of the configurations tested here. We'll evaluate that one separately once we finish some of the improvements we're working on for it. We also did not use AutoQuery, as the KITE questions are all suitable for direct use as search queries.




  To install the python package, run
  ```console
  pip install dsrag
  ```


  By default, dsRAG uses OpenAI for embeddings and AutoContext, and Cohere for reranking, so to run the code below you'll need to make sure you have API keys for those providers set as environmental variables with the following names: `OPENAI_API_KEY` and `CO_API_KEY`. **If you want to run dsRAG with different models, take a look at the "Basic customization" section below.**

  You can create a new KnowledgeBase directly from a file using the `create_kb_from_file` helper function:
  ```python
  from dsrag.create_kb import create_kb_from_file

  file_path = "dsRAG/tests/data/levels_of_agi.pdf"
  kb_id = "levels_of_agi"
  kb = create_kb_from_file(kb_id, file_path)
  ```
  KnowledgeBase objects persist to disk automatically, so you don't need to explicitly save it at this point.

  Now you can load the KnowledgeBase by its `kb_id` (only necessary if you run this from a separate script) and query it using the `query` method:
  ```python
  from dsrag.knowledge_base import KnowledgeBase

  kb = KnowledgeBase("levels_of_agi")
  search_queries = ["What are the levels of AGI?", "What is the highest level of AGI?"]
  results = kb.query(search_queries)
  for segment in results:
      print(segment)
  ```


  Now let's look at an example of how we can customize the configuration of a KnowledgeBase. In this case, we'll customize it so that it only uses OpenAI (useful if you don't have API keys for Anthropic and Cohere). To do so, we need to pass in a subclass of `LLM` and a subclass of `Reranker`. We'll use `gpt-4o-mini` for the LLM (this is what gets used for document and section summarization in AutoContext) and since OpenAI doesn't offer a reranker, we'll use the `NoReranker` class for that.
  ```python
  from dsrag.llm import OpenAIChatAPI
  from dsrag.reranker import NoReranker

  llm = OpenAIChatAPI(model='gpt-4o-mini')
  reranker = NoReranker()

  kb = KnowledgeBase(kb_id="levels_of_agi", reranker=reranker, auto_context_model=llm)
  ```

  Now we can add documents to this KnowledgeBase using the `add_document` method. Note that the `add_document` method takes in raw text, not files, so we'll have to extract the text from our file first. There are some utility functions for doing this in the `document_parsing.py` file.
  ```python
  from dsrag.document_parsing import extract_text_from_pdf

  file_path = "dsRAG/tests/data/levels_of_agi.pdf"
  text = extract_text_from_pdf(file_path)
  kb.add_document(doc_id=file_path, text=text)
  ```




  A KnowledgeBase object takes in documents (in the form of raw text) and does chunking and embedding on them, along with a few other preprocessing operations. Then at query time you feed in queries and it returns the most relevant segments of text.

  KnowledgeBase objects are persistent by default. The full configuration needed to reconstruct the object gets saved as a JSON file upon creation and updating.


  There are five key components that define the configuration of a KnowledgeBase, each of which are customizable:
  1. VectorDB
  2. ChunkDB
  3. Embedding
  4. Reranker
  5. LLM
  6. FileSystem

  There are defaults for each of these components, as well as alternative options included in the repo. You can also define fully custom components by subclassing the base classes and passing in an instance of that subclass to the KnowledgeBase constructor.


  The VectorDB component stores the embedding vectors, as well as a small amount of metadata.

  The currently available options are:
  - `BasicVectorDB`
  - `WeaviateVectorDB`
  - `ChromaDB`
  - `QdrantVectorDB`
  - `MilvusDB`


  The ChunkDB stores the content of text chunks in a nested dictionary format, keyed on `doc_id` and `chunk_index`. This is used by RSE to retrieve the full text associated with specific chunks.

  The currently available options are:
  - `BasicChunkDB`
  - `SQLiteDB`


  The Embedding component defines the embedding model.

  The currently available options are:
  - `OpenAIEmbedding`
  - `CohereEmbedding`
  - `VoyageAIEmbedding`
  - `OllamaEmbedding`


  The Reranker components define the reranker. This is used after the vector database search (and before RSE) to provide a more accurate ranking of chunks.

  The currently available options are:
  - `CohereReranker`
  - `VoyageReranker`


  This defines the LLM to be used for document title generation, document summarization, and section summarization in AutoContext.

  The currently available options are:
  - `OpenAIChatAPI`
  - `AnthropicChatAPI`
  - `OllamaChatAPI`


  This defines the file system to be used for saving PDF images.

  For backwards compatibility, if an existing `KnowledgeBase` is loaded in, a `LocalFileSystem` will be created by default using the `storage_directory`. This is also the behavior if no `FileSystem` is defined when creating a new `KnowledgeBase`.

  The currently available options are:
  - `LocalFileSystem`
  - `S3FileSystem`

  Usage:
  For the `LocalFileSystem`, only a `base_path` needs to be passed in. This defines where the files will be stored on the system
  For the `S3FileSystem`, the following parameters are needed:
  - `base_path`
  - `bucket_name`
  - `region_name`
  - `access_key`
  - `access_secret`

  The `base_path` is used when downloading files from S3. The files have to be stored locally in order to be used in the retrieval system.


  Since there are a lot of configuration parameters available, they're organized into a few config dictionaries. There are four config dictionaries that can be passed in to `add_document` (`auto_context_config`, `file_parsing_config`, `semantic_sectioning_config`, and `chunking_config`) and one that can be passed in to `query` (`rse_params`).

  Default values will be used for any parameters not provided in these dictionaries, so if you just want to alter one or two parameters there's no need to send in the full dictionary.

  auto_context_config
  - use_generated_title: bool - whether to use an LLM-generated title if no title is provided (default is True)
  - document_title_guidance: str - guidance for generating the document title
  - get_document_summary: bool - whether to get a document summary (default is True)
  - document_summarization_guidance: str
  - get_section_summaries: bool - whether to get section summaries (default is False)
  - section_summarization_guidance: str

  file_parsing_config
  - use_vlm: bool - whether to use VLM (vision language model) for parsing the file (default is False)
  - vlm_config: a dictionary with configuration parameters for VLM (ignored if use_vlm is False)
      - provider: the VLM provider to use - only "vertex_ai" is supported at the moment
      - model: the VLM model to use
      - project_id: the GCP project ID (required if provider is "vertex_ai")
      - location: the GCP location (required if provider is "vertex_ai")
      - save_path: the path to save intermediate files created during VLM processing
      - exclude_elements: a list of element types to exclude from the parsed text. Default is ["Header", "Footer"].

  semantic_sectioning_config
  - llm_provider: the LLM provider to use for semantic sectioning - only "openai" and "anthropic" are supported at the moment
  - model: the LLM model to use for semantic sectioning
  - use_semantic_sectioning: if False, semantic sectioning will be skipped (default is True)

  chunking_config
  - chunk_size: the maximum number of characters to include in each chunk
  - min_length_for_chunking: the minimum length of text to allow chunking (measured in number of characters); if the text is shorter than this, it will be added as a single chunk. If semantic sectioning is used, this parameter will be applied to each section. Setting this to a higher value than the chunk_size can help avoid unnecessary chunking of short documents or sections.

  rse_params
  - max_length: maximum length of a segment, measured in number of chunks
  - overall_max_length: maximum length of all segments combined, measured in number of chunks
  - minimum_value: minimum value of a segment, measured in relevance value
  - irrelevant_chunk_penalty: float between 0 and 1
  - overall_max_length_extension: the maximum length of all segments combined will be increased by this amount for each additional query beyond the first
  - decay_rate
  - top_k_for_document_selection: the number of documents to consider
  - chunk_length_adjustment: bool, if True (default) then scale the chunk relevance values by their length before calculating segment relevance values


  Certain vector DBs support metadata filtering when running a query (currently only ChromaDB). This allows you to have more control over what document(s) get searched. A common use case for this would be asking questions over a single document in a knowledge base, in which case you would supply the `doc_id` as a metadata filter.

  The format of the metadata filtering is an object with the following keys:

   - field: str, # The metadata field to filter by
   - operator: str, # The operator for filtering. Must be one of: 'equals', 'not_equals', 'in', 'not_in', 'greater_than', 'less_than', 'greater_than_equals', 'less_than_equals'
   - value: str | int | float | list # If the value is a list, every item in the list must be of the same type



  ```python

  metadata_filter = {
      "field": "doc_id",
      "operator": "equals",
      "value": "test_id_1"
  }


  metadata_filter = {
      "field": "doc_id",
      "operator": "in",
      "value": ["test_id_1", "test_id_2"]
  }
  ```


  Documents -> semantic sectioning -> chunking -> AutoContext -> embedding -> chunk and vector database upsert


  Queries -> vector database search -> reranking -> RSE -> results


  You can join our [Discord](https://discord.gg/NTUVX9DmQ3) to ask questions, make suggestions, and discuss contributions.

  If you’re using (or planning to use) dsRAG in production, please fill out this short [form](https://forms.gle/RQ5qFVReonSHDcCu5) telling us about your use case. This helps us prioritize new features. In return I’ll give you my personal email address, which you can use for priority email support.


  If you want to run dsRAG in production with minimal effort, reach out to us about our commercial offering, which is a managed private cloud deployment of dsRAG.

  Here are the high-level details of the offering:

  **Private cloud deployment (i.e. in your own AWS, Azure, or GCP account) of dsRAG.**
  - Deployed as a production-ready API with endpoints for adding and deleting documents, viewing upload status, querying, etc.
  - Unlimited number of KnowledgeBases. You can just pass in the kb_id with each API call to specify which one it’s for.
  - Document upload queue with configurable concurrency limits so you don’t have to worry about rate limiting document uploads in your application code.
  - VectorDB and ChunkDB are created and managed as part of the API, so you don’t have to set those up separately.
  - Could also be deployed directly into your customers’ cloud environments if needed.

  **Support**
  - We’ll help you customize the retrieval configuration and components for your use case and make sure everything runs smoothly and performs well.
  - Ongoing support and regular updates as needed.

  If this is something you’d like to learn more about, fill out this short [form](https://forms.gle/Z4n81qdwdpckqsct6) and we’ll reach out ASAP.

rpm_license:
  MIT License  Copyright (c) 2024 D-Star  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: db7ee6426f2deb20e2c90ef92ebe0a9b3d01787967bee7bf9e5a67fa5054e834
name: python-dssatlm-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for dssatlm
url: https://pypi.org/project/dssatlm/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dssatlm-0.1.4-1.src.rpm
location_href: Packages/python-dssatlm-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  This project requires that you set the following API keys:

  * GROQ_API_KEY
  * OPENAI_API_KEY
  * WANDB_API_KEY



  ```
  pip install dssatlm
  ```


  [TO-DO]


  [TO-DO]


  [TO-DO]


  [TO-DO]


pkgId: a53f6029c596ea2307d68062a56d456ecd7537d69f5b1efa2974b5a024fa4c30
name: python-dstack-help
arch: noarch
version: 0.18.31
epoch: 0
release: 1
summary: Development documents and examples for dstack
url: https://dstack.ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dstack-0.18.31-1.src.rpm
location_href: Packages/python-dstack-help-0.18.31-1.noarch.rpm
checksum_type: sha256
description:
  <div style="text-align: center;">
  <h2>
    <a target="_blank" href="https://dstack.ai">
      <img alt="dstack" src="https://raw.githubusercontent.com/dstackai/dstack/master/docs/assets/images/dstack-logo.svg" width="350px"/>
    </a>
  </h2>

  [![Last commit](https://img.shields.io/github/last-commit/dstackai/dstack?style=flat-square)](https://github.com/dstackai/dstack/commits/)
  [![PyPI - License](https://img.shields.io/pypi/l/dstack?style=flat-square&color=blue)](https://github.com/dstackai/dstack/blob/master/LICENSE.md)
  [![Discord](https://dcbadge.vercel.app/api/server/u8SmfwPpMd?style=flat-square)](https://discord.gg/u8SmfwPpMd)

  </div>

  `dstack` is a streamlined alternative to Kubernetes and Slurm, specifically designed for AI. It simplifies container orchestration
  for AI workloads both in the cloud and on-prem, speeding up the development, training, and deployment of AI models.

  `dstack` is easy to use with any cloud provider as well as on-prem servers.



  `dstack` supports `NVIDIA GPU`, `AMD GPU`, and `Google Cloud TPU` out of the box.



  - [2024/10] [dstack 0.18.17: on-prem AMD GPUs, AWS EFA, and more](https://github.com/dstackai/dstack/releases/tag/0.18.17)
  - [2024/08] [dstack 0.18.11: AMD, encryption, and more](https://github.com/dstackai/dstack/releases/tag/0.18.11)
  - [2024/08] [dstack 0.18.10: Control plane UI](https://github.com/dstackai/dstack/releases/tag/0.18.10)
  - [2024/07] [dstack 0.18.7: Fleets, RunPod volumes, dstack apply, and more](https://github.com/dstackai/dstack/releases/tag/0.18.7)
  - [2024/05] [dstack 0.18.4: Google Cloud TPU, and more](https://github.com/dstackai/dstack/releases/tag/0.18.4)
  - [2024/05] [dstack 0.18.2: On-prem clusters, private subnets, and more](https://github.com/dstackai/dstack/releases/tag/0.18.2)



  > Before using `dstack` through CLI or API, set up a `dstack` server. If you already have a running `dstack` server, you only need to [set up the CLI](#set-up-the-cli).



  To use `dstack` with your own cloud accounts, create the `~/.dstack/server/config.yml` file and
  [configure backends](https://dstack.ai/docs/reference/server/config.yml). Alternatively, you can configure backends via the control plane UI after you start the server.

  You can skip backends configuration if you intend to run containers  only on your on-prem servers. Use [SSH fleets](https://dstack.ai/docs/concepts/fleets#ssh-fleets) for that.



  Once the backends are configured, proceed to start the server:

  <div class="termy">

  ```shell
  $ pip install "dstack[all]" -U
  $ dstack server

  Applying ~/.dstack/server/config.yml...

  The admin token is "bbae0f28-d3dd-4820-bf61-8f4bb40815da"
  The server is running at http://127.0.0.1:3000/
  ```

  </div>

  For more details on server configuration options, see the
  [server deployment guide](https://dstack.ai/docs/guides/server-deployment).



  To point the CLI to the `dstack` server, configure it
  with the server address, user token, and project name:

  ```shell
  $ pip install dstack
  $ dstack config --url http://127.0.0.1:3000 \
      --project main \
      --token bbae0f28-d3dd-4820-bf61-8f4bb40815da

  Configuration is updated at ~/.dstack/config.yml
  ```





  `dstack` supports the following configurations:

  * [Dev environments](https://dstack.ai/docs/dev-environments) &mdash; for interactive development using a desktop IDE
  * [Tasks](https://dstack.ai/docs/tasks) &mdash; for scheduling jobs (incl. distributed jobs) or running web apps
  * [Services](https://dstack.ai/docs/services) &mdash; for deployment of models and web apps (with auto-scaling and authorization)
  * [Fleets](https://dstack.ai/docs/fleets) &mdash; for managing cloud and on-prem clusters
  * [Volumes](https://dstack.ai/docs/concepts/volumes) &mdash; for managing persisted volumes
  * [Gateways](https://dstack.ai/docs/concepts/gateways) &mdash; for configuring the ingress traffic and public endpoints

  Configuration can be defined as YAML files within your repo.



  Apply the configuration either via the `dstack apply` CLI command or through a programmatic API.

  `dstack` automatically manages provisioning, job queuing, auto-scaling, networking, volumes, run failures,
  out-of-capacity errors, port-forwarding, and more &mdash; across clouds and on-prem clusters.



  For additional information and examples, see the following links:

  * [Docs](https://dstack.ai/docs)
  * [Examples](https://dstack.ai/examples)
  * [Providers](https://dstack.ai/providers)
  * [Discord](https://discord.gg/u8SmfwPpMd)



  You're very welcome to contribute to `dstack`.
  Learn more about how to contribute to the project at [CONTRIBUTING.md](CONTRIBUTING.md).



  [Mozilla Public License 2.0](LICENSE.md)


pkgId: 42147369837170b30edfd574d2702ee23dc1a92a60c0ec9436761369db9ab2c7
name: python-dt-help
arch: noarch
version: 1.1.72
epoch: 0
release: 1
summary: Development documents and examples for dt
url: https://github.com/dynatrace-oss/api-client-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dt-1.1.72-1.src.rpm
location_href: Packages/python-dt-help-1.1.72-1.noarch.rpm
checksum_type: sha256
description:
  **dt** is a Python client for the [Dynatrace Rest API].
  It focuses on ease of use and nice type hints, perfect to explore the API and create quick scripts

  [Dynatrace Rest API]: https://www.dynatrace.com/support/help/dynatrace-api



  ```bash
  $ pip install dt
  ```



  ```python
  from dynatrace import Dynatrace
  from dynatrace import TOO_MANY_REQUESTS_WAIT
  from dynatrace.environment_v2.tokens_api import SCOPE_METRICS_READ, SCOPE_METRICS_INGEST
  from dynatrace.configuration_v1.credential_vault import PublicCertificateCredentials
  from dynatrace.environment_v2.settings import SettingsObject, SettingsObjectCreate

  from datetime import datetime, timedelta


  dt = Dynatrace("environment_url", "api_token")












  for entity in dt.entities.list('type("HOST")', fields="properties.memoryTotal,properties.monitoringMode"):
      print(entity.entity_id, entity.display_name, entity.properties)


  for metric in dt.metrics.query("builtin:host.cpu.idle", resolution="Inf"):
      print(metric)


  for metric in dt.metrics.query("ext:cloud.aws.billing.estimatedChargesByRegionCurrency"):
      for data in metric.data:
          for timestamp, value in zip(data.timestamps, data.values):
              print(data.dimensions, timestamp, value)


  for ag in dt.activegates.list():
      print(ag)


  for m in dt.metrics.list("builtin:host.*"):
      print(m)


  for plugin in dt.plugins.list():

      
      for endpoint in plugin.endpoints:
          if "test" in endpoint.name:
              endpoint.delete(plugin.id)


  for dashboard in dt.dashboards.list():
      full_dashboard = dashboard.get_full_dashboard()
      print(full_dashboard.id, dashboard.owner, len(full_dashboard.tiles))


  for token in dt.tokens.list(fields="+lastUsedDate,+scopes"):
      if token.last_used_date and token.last_used_date < datetime.now() - timedelta(days=90):
          print(f"Deleting token! {token}, last used date: {token.last_used_date}")


  new_token = dt.tokens.create("metrics_token", scopes=[SCOPE_METRICS_READ, SCOPE_METRICS_INGEST])
  print(new_token.token)


  with open("ca.pem", "r") as f:
      ca_cert = f.read()

  my_cred = PublicCertificateCredentials(
      name="my_cred",
      description="my_cred description",
      scope="EXTENSION",
      owner_access_only=False,
      certificate=ca_cert,
      password="",
      credential_type="PUBLIC_CERTIFICATE",
      certificate_format="PEM"
  )

  r = dt.credentials.post(my_cred)
  print(r.id)


  settings_value = {
      "enabled": True,
      "summary": "DT API TEST 1",
      "queryDefinition": {
          "type": "METRIC_KEY",
          "metricKey": "netapp.ontap.node.fru.state",
          "aggregation": "AVG",
          "entityFilter": {
              "dimensionKey": "dt.entity.netapp_ontap:fru",
              "conditions": [],
          },
          "dimensionFilter": [],
      },
      "modelProperties": {
          "type": "STATIC_THRESHOLD",
          "threshold": 100.0,
          "alertOnNoData": False,
          "alertCondition": "BELOW",
          "violatingSamples": 3,
          "samples": 5,
          "dealertingSamples": 5,
      },
      "eventTemplate": {
          "title": "OnTap {dims:type} {dims:fru_id} is in Error State",
          "description": "OnTap field replaceable unit (FRU) {dims:type} with id {dims:fru_id} on node {dims:node} in cluster {dims:cluster} is in an error state.\n",
          "eventType": "RESOURCE",
          "davisMerge": True,
          "metadata": [],
      },
      "eventEntityDimensionKey": "dt.entity.netapp_ontap:fru",
  }

  settings_object = SettingsObjectCreate(schema_id="builtin:anomaly-detection.metric-events", value=settings_value, scope="environment")
  dt.settings.create_object(validate_only=False, body=settings_object)
  ```





   API                                     |       Level        | Access                                    |
  :----------------------------------------|:------------------:|:------------------------------------------|
   Access Tokens - API tokens              | :heavy_check_mark: | `dt.tokens`                               |
   Access tokens - Tenant tokens           | :heavy_check_mark: | `dt.tenant_tokens`                        |
   ActiveGates                             | :heavy_check_mark: | `dt.activegates`                          |
   ActiveGates - Auto-update configuration | :heavy_check_mark: | `dt.activegates_autoupdate_configuration` |
   ActiveGates - Auto-update jobs          | :heavy_check_mark: | `dt.activegates_autoupdate_jobs`          |
   ActiveGates - Remote configuration      | :heavy_check_mark: | `dt.activegates_remote_configuration`     |
   Audit Logs                              | :heavy_check_mark: | `dt.audit_logs`                           |
   Events                                  |     :warning:      | `dt.events_v2`                            |
   Extensions 2.0                          | :heavy_check_mark: | `dt.extensions_v2`                        |
   Logs                                    |     :warning:      | `dt.logs`                                 |
   Metrics                                 | :heavy_check_mark: | `dt.metrics`                              |
   Monitored entities                      |     :warning:      | `dt.entities`                             |
   Monitored entities - Custom tags        | :heavy_check_mark: | `dt.custom_tags`                          |
   Network zones                           |     :warning:      | `dt.network_zones`                        |
   OneAgents - Remote configuration        | :heavy_check_mark: | `dt.oneagents_remote_configuration`       |
   Problems                                | :heavy_check_mark: | `dt.problems`                             |
   Security problems                       |        :x:         |                                           |
   Service-level objectives                | :heavy_check_mark: | `dt.slos`                                 |
   Settings                                |     :warning:      | `dt.settings`                             |



   API                                   |       Level        | Access                          |
  :--------------------------------------|:------------------:|:--------------------------------|
   Anonymization                         |        :x:         |                                 |
   Cluster time                          | :heavy_check_mark: | `dt.cluster_time`               |
   Cluster version                       |        :x:         |                                 |
   Custom devices                        | :heavy_check_mark: | `dt.custom_devices`             |
   Deployment                            | :heavy_check_mark: | `dt.deployment`                 |
   Events                                |     :warning:      | `dt.events`                     |
   JavaScript tag management             |        :x:         |                                 |
   Log monitoring - Custom devices       |        :x:         |                                 |
   Log monitoring - Hosts                |        :x:         |                                 |
   Log monitoring - Process groups       |        :x:         |                                 |
   Maintenance window                    |        :x:         |                                 |
   OneAgent on a host                    |     :warning:      | `dt.oneagents`                  |
   Problem                               |        :x:         |                                 |
   Synthetic - Locations and nodes       |        :x:         |                                 |
   Synthetic - Monitors                  |     :warning:      | `dt.synthetic_monitors`         |
   Synthetic - Third party               | :heavy_check_mark: | `dt.third_part_synthetic_tests` |
   Threshold                             |        :x:         |                                 |
   Timeseries                            |     :warning:      | `dt.timeseries`                 |
   Tokens                                |        :x:         |                                 |
   Topology & Smartscape - Application   |        :x:         |                                 |
   Topology & Smartscape - Custom device |     :warning:      | `dt.custom_devices`             |
   Topology & Smartscape - Host          |     :warning:      | `dt.smartscape_hosts`           |
   Topology & Smartscape - Process       |        :x:         |                                 |
   Topology & Smartscape - Process group |        :x:         |                                 |
   Topology & Smartscape - Service       |        :x:         |                                 |
   User sessions                         |        :x:         |                                 |



   API                                                 |       Level        | Access                                |
  :----------------------------------------------------|:------------------:|:--------------------------------------|
   Alerting Profiles                                   |     :warning:      | `dt.alerting_profiles`                |
   Anomaly detection - Applications                    |        :x:         |                                       |
   Anomaly detection - AWS                             |        :x:         |                                       |
   Anomaly detection - Database services               |        :x:         |                                       |
   Anomaly detection - Disk events                     |        :x:         |                                       |
   Anomaly detection - Hosts                           |        :x:         |                                       |
   Anomaly detection - Metric events                   |     :warning:      | `dt.anomaly_detection_metric_events`  |
   Anomaly detection - Process groups                  |     :warning:      | `dt.anomaly_detection_process_groups` |
   Anomaly detection - Services                        |        :x:         |                                       |
   Anomaly detection - VMware                          |        :x:         |                                       |
   Automatically applied tags                          |     :warning:      | `dt.auto_tags`                        |
   AWS credentials configuration                       |        :x:         |                                       |
   AWS PrivateLink                                     |        :x:         |                                       |
   Azure credentials configuration                     |        :x:         |                                       |
   Calculated metrics - Log monitoring                 |        :x:         |                                       |
   Calculated metrics - Mobile & custom applications   |        :x:         |                                       |
   Calculated metrics - Services                       |        :x:         |                                       |
   Calculated metrics - Synthetic                      |        :x:         |                                       |
   Calculated metrics - Web applications               |        :x:         |                                       |
   Cloud Foundry credentials configuration             |        :x:         |                                       |
   Conditional naming                                  |        :x:         |                                       |
   Credential vault                                    |        :x:         |                                       |
   Custom tags                                         | :heavy_check_mark: | `dt.custom_tags`                      |
   Dashboards                                          |     :warning:      | `dt.dashboards`                       |
   Data privacy and security                           |        :x:         |                                       |
   Extensions                                          | :heavy_check_mark: | `dt.extensions`                       |
   Frequent issue detection                            |        :x:         |                                       |
   Kubernetes credentials configuration                |        :x:         |                                       |
   Maintenance windows                                 |     :warning:      | `dt.maintenance_windows`              |
   Management zones                                    |     :warning:      | `dt.management_zones`                 |
   Notifications                                       |     :warning:      | `dt.notifications`                    |
   OneAgent - Environment-wide configuration           | :heavy_check_mark: | `dt.oneagents_config_environment`     |
   OneAgent in a host group                            | :heavy_check_mark: | `dt.oneagents_config_hostgroup`       |
   OneAgent on a host                                  | :heavy_check_mark: | `dt.oneagents_config_host`            |
   Plugins                                             |     :warning:      | `dt.plugins`                          |
   Remote environments                                 |        :x:         |                                       |
   Reports                                             |        :x:         |                                       |
   RUM - Allowed beacon origins for CORS               |        :x:         |                                       |
   RUM - Application detection rules                   |        :x:         |                                       |
   RUM - Application detection rules - Host detection  |        :x:         |                                       |
   RUM - Content resources                             |        :x:         |                                       |
   RUM - Geographic regions - custom client IP headers |        :x:         |                                       |
   RUM - Geographic regions - IP address mapping       |        :x:         |                                       |
   RUM - Mobile and custom application configuration   |        :x:         |                                       |
   RUM - Web application configuration                 |        :x:         |                                       |
   Service - Custom services                           |        :x:         |                                       |
   Service - Detection full web request                |        :x:         |                                       |
   Service - Detection full web service                |        :x:         |                                       |
   Service - Detection opaque and external web request |        :x:         |                                       |
   Service - Detection opaque and external web service |        :x:         |                                       |
   Service - Failure detection parameter sets          |        :x:         |                                       |
   Service - Failure detection rules                   |        :x:         |                                       |
   Service - IBM MQ tracing                            |        :x:         |                                       |
   Service - Request attributes                        |        :x:         |                                       |
   Service - Request naming                            |        :x:         |                                       |


pkgId: dcc3405a2e4d6fc6c50c5c018521cb3856a7f673b3179973883e08b14d8d1a3c
name: python-dtPyAppFramework-help
arch: noarch
version: 2.4
epoch: 0
release: 1
summary: Development documents and examples for dtPyAppFramework
url: https://github.com/Digital-Thought/dtPyAppFramework
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dtPyAppFramework-2.4-1.src.rpm
location_href: Packages/python-dtPyAppFramework-help-2.4-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)

  **dtPyAppFramework** is a Python library designed to streamline the development of Python applications by providing common features and abstractions. It promotes good practices, modular design, and ease of use.



  - **Singleton Management:** Simplify the use of singleton classes by automating initialisation with predefined parameters.
  - **Settings and Configuration:** Manage application settings and configurations effortlessly.
  - **Secrets Management:** Securely handle secrets and credentials using local or cloud-based stores like AWS Secrets Manager and Asure KeyVault.
  - **Application Initialisation:** Quickly initialise your Python applications with the `AbstractApp` class, which takes care of common initialisation tasks.
  - **Process Management:** Use the `ProcessManager` for efficient process handling in your applications.



  ```bash
  pip install dtPyAppFramework
  ```



  The **`AbstractApp`** class serves as a base class for creating Python applications. It handles common initialisation tasks and provides a structure for defining command-line arguments and the main application logic.


  To create a simple Python application using dtPyAppFramework:
  ```python
  from dtPyAppFramework.application import AbstractApp
  from dtPyAppFramework import settings

  import logging

  class MyApplication(AbstractApp):

      def define_args(self, arg_parser):
          
          return

      def main(self, args):
          logging.info("Running your code")
          


  MyApplication(description="Simple App", version="1.0", short_name="simple_app",
            full_name="Simple Application", console_app=True).run()
  ```


  Now lets take some time to go over the various features that makes `dtPyAppFramework` such a power library to base your
  Python projects of.


  `dtPyAppFramework` offers flexible logging capabilities, allowing you to configure and manage logs easily. <br>
  In addition it offers some pretty cool logging capabilities straight out of the door which requires no setup from you.


  Easily read and manage configuration settings from configurations files.<br>
  Configuration files can be set for a specific user or for any user of the application.


  Securely store and retrieve sensitive information with encryption and best practices.<br>
  You can store secrets for a specific user or make secrets available to all users of the application.<br>
  In addition, you can use the AWS Secrets Management seamlessly within the application alongside the in-built secrets store.


  Effortlessly parse and manage command line arguments with support for defining options and accessing them in your code.


  Access common resource paths like user storage directories.


  A robust Resource Manager, which is a singleton class named `ResourceManager`.



  This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).



  If you have any questions, bug reports, or feature requests, feel free to [contact us](mailto:dev@digital-thought.org).

rpm_license:
  MIT License  Copyright (c) 2024 Digital-Thought  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: f24188d7d8ef3a20dbccfdd5d0a9df4349c1d281c9633c4f48d262ad0301234f
name: python-dtale-help
arch: noarch
version: 3.16.1
epoch: 0
release: 1
summary: Development documents and examples for dtale
url: https://github.com/man-group/dtale
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dtale-3.16.1-1.src.rpm
location_href: Packages/python-dtale-help-3.16.1-1.noarch.rpm
checksum_type: sha256
description:
  |CircleCI| |PyPI Python Versions| |PyPI| |Conda| |ReadTheDocs| |codecov|
  |Downloads| |Open in VS Code|


pkgId: 6385f61c5900fdd792022d523ca2e6f5bd50dee6abc6b72e2ea9dccb3065ea5d
name: python-dtool-lookup-gui-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for dtool-lookup-gui
url: https://pypi.org/project/dtool-lookup-gui/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dtool-lookup-gui-0.7.0-1.src.rpm
location_href: Packages/python-dtool-lookup-gui-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  dtool-lookup-gui is a graphical user interface for dtool_, the dtool-lookup-server_, the dtool-lookup-server-direct-mongo-plugin_ and the
  dtool-lookup-server-dependency-graph-plugin_ written in Python_ and GTK_.

rpm_license:
  # LICENSE  dtool-lookup-gui makes all its materials publicly available under [open source][osi] licenses.  Documents and data are made available under a CC-BY-SA license. Software are made available under an MIT license.  ## Documents and data  Documentation and graphics in this repository are licensed under a [Creative Commons Attribution-ShareAlike 4.0 International License][cc-by-sa].  ## Software  Software provided are made available under the [OSI][osi]-approved [MIT license][mit-license].  [cc-by-sa]: https://creativecommons.org/licenses/by-sa/4.0/ [mit-license]: https://opensource.org/licenses/mit-license.html [osi]: https://opensource.org


pkgId: a5c591b65edf87930094f872d6a50b39e20c81e77eb0160392e946c8d7d9f3ef
name: python-dub-help
arch: noarch
version: 0.16.0
epoch: 0
release: 1
summary: Development documents and examples for dub
url: https://github.com/dubinc/dub-python.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dub-0.16.0-1.src.rpm
location_href: Packages/python-dub-help-0.16.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <img src="https://github.com/dubinc/dub/assets/28986134/3815d859-afaa-48f9-a9b3-c09964e4d404" alt="Dub.co Python SDK to interact with APIs.">
    <h3>Dub.co Python SDK</h3>
    <a href="https://speakeasyapi.dev/"><img src="https://custom-icon-badges.demolab.com/badge/-Built%20By%20Speakeasy-212015?style=for-the-badge&logoColor=FBE331&logo=speakeasy&labelColor=545454" /></a>
    <a href="https://opensource.org/licenses/MIT">
      <img src="https://img.shields.io/badge/License-MIT-blue.svg" style="width: 100px; height: 28px;" />
    </a>
  </div>

  <br/>

  Learn more about the Dub.co Python SDK in the [official documentation](https://dub.co/docs/sdks/python/overview).

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


  Dub.co API: Dub is link management infrastructure for companies to create marketing campaigns, link sharing features, and referral programs.
  <!-- End Summary [summary] -->

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

  <!-- $toc-max-depth=2 -->
    * [SDK Installation](https://github.com/dubinc/dub-python/blob/master/#sdk-installation)
    * [SDK Example Usage](https://github.com/dubinc/dub-python/blob/master/#sdk-example-usage)
    * [Available Resources and Operations](https://github.com/dubinc/dub-python/blob/master/#available-resources-and-operations)
    * [Error Handling](https://github.com/dubinc/dub-python/blob/master/#error-handling)
    * [Server Selection](https://github.com/dubinc/dub-python/blob/master/#server-selection)
    * [Custom HTTP Client](https://github.com/dubinc/dub-python/blob/master/#custom-http-client)
    * [Authentication](https://github.com/dubinc/dub-python/blob/master/#authentication)
    * [Retries](https://github.com/dubinc/dub-python/blob/master/#retries)
    * [Pagination](https://github.com/dubinc/dub-python/blob/master/#pagination)
    * [Debugging](https://github.com/dubinc/dub-python/blob/master/#debugging)
    * [IDE Support](https://github.com/dubinc/dub-python/blob/master/#ide-support)
  * [Development](https://github.com/dubinc/dub-python/blob/master/#development)
    * [Contributions](https://github.com/dubinc/dub-python/blob/master/#contributions)

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

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


  The SDK can be installed with either *pip* or *poetry* package managers.



  *PIP* is the default package installer for Python, enabling easy installation and management of packages from PyPI via the command line.

  ```bash
  pip install dub
  ```



  *Poetry* is a modern tool that simplifies dependency management and package publishing by using a single `pyproject.toml` file to handle project metadata and dependencies.

  ```bash
  poetry add dub
  ```
  <!-- End SDK Installation [installation] -->

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




  ```python

  from dub import Dub

  with Dub(
      token="DUB_API_KEY",
  ) as dub:

      res = dub.links.create(request={
          "url": "https://google.com",
          "external_id": "123456",
          "tag_ids": [
              "clux0rgak00011...",
          ],
      })

      assert res is not None

      
      print(res)
  ```

  </br>

  The same SDK client can also be used to make asychronous requests by importing asyncio.
  ```python

  import asyncio
  from dub import Dub

  async def main():
      async with Dub(
          token="DUB_API_KEY",
      ) as dub:

          res = await dub.links.create_async(request={
              "url": "https://google.com",
              "external_id": "123456",
              "tag_ids": [
                  "clux0rgak00011...",
              ],
          })

          assert res is not None

          
          print(res)

  asyncio.run(main())
  ```



  ```python

  from dub import Dub

  with Dub(
      token="DUB_API_KEY",
  ) as dub:

      res = dub.links.upsert(request={
          "url": "https://google.com",
          "external_id": "123456",
          "tag_ids": [
              "clux0rgak00011...",
          ],
      })

      assert res is not None

      
      print(res)
  ```

  </br>

  The same SDK client can also be used to make asychronous requests by importing asyncio.
  ```python

  import asyncio
  from dub import Dub

  async def main():
      async with Dub(
          token="DUB_API_KEY",
      ) as dub:

          res = await dub.links.upsert_async(request={
              "url": "https://google.com",
              "external_id": "123456",
              "tag_ids": [
                  "clux0rgak00011...",
              ],
          })

          assert res is not None

          
          print(res)

  asyncio.run(main())
  ```
  <!-- End SDK Example Usage [usage] -->

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


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



  * [retrieve](https://github.com/dubinc/dub-python/blob/master/docs/sdks/analytics/README.md#retrieve) - Retrieve analytics for a link, a domain, or the authenticated workspace.



  * [list](https://github.com/dubinc/dub-python/blob/master/docs/sdks/customers/README.md#list) - Retrieve a list of customers
  * [create](https://github.com/dubinc/dub-python/blob/master/docs/sdks/customers/README.md#create) - Create a customer
  * [get](https://github.com/dubinc/dub-python/blob/master/docs/sdks/customers/README.md#get) - Retrieve a customer
  * [update](https://github.com/dubinc/dub-python/blob/master/docs/sdks/customers/README.md#update) - Update a customer
  * [delete](https://github.com/dubinc/dub-python/blob/master/docs/sdks/customers/README.md#delete) - Delete a customer



  * [create](https://github.com/dubinc/dub-python/blob/master/docs/sdks/domains/README.md#create) - Create a domain
  * [list](https://github.com/dubinc/dub-python/blob/master/docs/sdks/domains/README.md#list) - Retrieve a list of domains
  * [update](https://github.com/dubinc/dub-python/blob/master/docs/sdks/domains/README.md#update) - Update a domain
  * [delete](https://github.com/dubinc/dub-python/blob/master/docs/sdks/domains/README.md#delete) - Delete a domain




  * [create](https://github.com/dubinc/dub-python/blob/master/docs/sdks/embedtokens/README.md#create) - Create a new embed token



  * [list](https://github.com/dubinc/dub-python/blob/master/docs/sdks/events/README.md#list) - Retrieve a list of events



  * [create](https://github.com/dubinc/dub-python/blob/master/docs/sdks/links/README.md#create) - Create a new link
  * [list](https://github.com/dubinc/dub-python/blob/master/docs/sdks/links/README.md#list) - Retrieve a list of links
  * [count](https://github.com/dubinc/dub-python/blob/master/docs/sdks/links/README.md#count) - Retrieve links count
  * [get](https://github.com/dubinc/dub-python/blob/master/docs/sdks/links/README.md#get) - Retrieve a link
  * [update](https://github.com/dubinc/dub-python/blob/master/docs/sdks/links/README.md#update) - Update a link
  * [delete](https://github.com/dubinc/dub-python/blob/master/docs/sdks/links/README.md#delete) - Delete a link
  * [create_many](https://github.com/dubinc/dub-python/blob/master/docs/sdks/links/README.md#create_many) - Bulk create links
  * [update_many](https://github.com/dubinc/dub-python/blob/master/docs/sdks/links/README.md#update_many) - Bulk update links
  * [delete_many](https://github.com/dubinc/dub-python/blob/master/docs/sdks/links/README.md#delete_many) - Bulk delete links
  * [upsert](https://github.com/dubinc/dub-python/blob/master/docs/sdks/links/README.md#upsert) - Upsert a link



  * [get](https://github.com/dubinc/dub-python/blob/master/docs/sdks/metatags/README.md#get) - Retrieve the metatags for a URL



  * [get](https://github.com/dubinc/dub-python/blob/master/docs/sdks/qrcodes/README.md#get) - Retrieve a QR code



  * [create](https://github.com/dubinc/dub-python/blob/master/docs/sdks/tags/README.md#create) - Create a new tag
  * [list](https://github.com/dubinc/dub-python/blob/master/docs/sdks/tags/README.md#list) - Retrieve a list of tags
  * [update](https://github.com/dubinc/dub-python/blob/master/docs/sdks/tags/README.md#update) - Update a tag
  * [delete](https://github.com/dubinc/dub-python/blob/master/docs/sdks/tags/README.md#delete) - Delete a tag



  * [lead](https://github.com/dubinc/dub-python/blob/master/docs/sdks/track/README.md#lead) - Track a lead
  * [sale](https://github.com/dubinc/dub-python/blob/master/docs/sdks/track/README.md#sale) - Track a sale
  * [~~customer~~](https://github.com/dubinc/dub-python/blob/master/docs/sdks/track/README.md#customer) - Track a customer :warning: **Deprecated**



  * [get](https://github.com/dubinc/dub-python/blob/master/docs/sdks/workspaces/README.md#get) - Retrieve a workspace
  * [update](https://github.com/dubinc/dub-python/blob/master/docs/sdks/workspaces/README.md#update) - Update a workspace

  </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 exceptions. You can refer to respective *Errors* tables in SDK docs for more details on possible exception types for each operation. For example, the `create_async` method may raise the following exceptions:

  | Error Type                 | Status Code | Content Type     |
  | -------------------------- | ----------- | ---------------- |
  | errors.BadRequest          | 400         | application/json |
  | errors.Unauthorized        | 401         | application/json |
  | errors.Forbidden           | 403         | application/json |
  | errors.NotFound            | 404         | application/json |
  | errors.Conflict            | 409         | application/json |
  | errors.InviteExpired       | 410         | application/json |
  | errors.UnprocessableEntity | 422         | application/json |
  | errors.RateLimitExceeded   | 429         | application/json |
  | errors.InternalServerError | 500         | application/json |
  | errors.SDKError            | 4XX, 5XX    | \*/\*            |



  ```python
  from dub import Dub
  from dub.models import errors

  with Dub(
      token="DUB_API_KEY",
  ) as dub:
      res = None
      try:

          res = dub.links.create(request={
              "url": "https://google.com",
              "external_id": "123456",
              "tag_ids": [
                  "clux0rgak00011...",
              ],
          })

          assert res is not None

          
          print(res)

      except errors.BadRequest as e:
          
          raise(e)
      except errors.Unauthorized as e:
          
          raise(e)
      except errors.Forbidden as e:
          
          raise(e)
      except errors.NotFound as e:
          
          raise(e)
      except errors.Conflict as e:
          
          raise(e)
      except errors.InviteExpired as e:
          
          raise(e)
      except errors.UnprocessableEntity as e:
          
          raise(e)
      except errors.RateLimitExceeded as e:
          
          raise(e)
      except errors.InternalServerError as e:
          
          raise(e)
      except errors.SDKError as e:
          
          raise(e)
  ```
  <!-- 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
  from dub import Dub

  with Dub(
      server_url="https://api.dub.co",
      token="DUB_API_KEY",
  ) as dub:

      res = dub.links.create(request={
          "url": "https://google.com",
          "external_id": "123456",
          "tag_ids": [
              "clux0rgak00011...",
          ],
      })

      assert res is not None

      
      print(res)

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

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


  The Python SDK makes API calls using the [httpx](https://www.python-httpx.org/) 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 your own HTTP client instance.
  Depending on whether you are using the sync or async version of the SDK, you can pass an instance of `HttpClient` or `AsyncHttpClient` respectively, which are Protocol's ensuring that the client has the necessary methods to make API calls.
  This allows you to wrap the client with your own custom logic, such as adding custom headers, logging, or error handling, or you can just pass an instance of `httpx.Client` or `httpx.AsyncClient` directly.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  from dub import Dub
  import httpx

  http_client = httpx.Client(headers={"x-custom-header": "someValue"})
  s = Dub(client=http_client)
  ```

  or you could wrap the client with your own custom logic:
  ```python
  from dub import Dub
  from dub.httpclient import AsyncHttpClient
  import httpx

  class CustomClient(AsyncHttpClient):
      client: AsyncHttpClient

      def __init__(self, client: AsyncHttpClient):
          self.client = client

      async def send(
          self,
          request: httpx.Request,
          *,
          stream: bool = False,
          auth: Union[
              httpx._types.AuthTypes, httpx._client.UseClientDefault, None
          ] = httpx.USE_CLIENT_DEFAULT,
          follow_redirects: Union[
              bool, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
      ) -> httpx.Response:
          request.headers["Client-Level-Header"] = "added by client"

          return await self.client.send(
              request, stream=stream, auth=auth, follow_redirects=follow_redirects
          )

      def build_request(
          self,
          method: str,
          url: httpx._types.URLTypes,
          *,
          content: Optional[httpx._types.RequestContent] = None,
          data: Optional[httpx._types.RequestData] = None,
          files: Optional[httpx._types.RequestFiles] = None,
          json: Optional[Any] = None,
          params: Optional[httpx._types.QueryParamTypes] = None,
          headers: Optional[httpx._types.HeaderTypes] = None,
          cookies: Optional[httpx._types.CookieTypes] = None,
          timeout: Union[
              httpx._types.TimeoutTypes, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
          extensions: Optional[httpx._types.RequestExtensions] = None,
      ) -> httpx.Request:
          return self.client.build_request(
              method,
              url,
              content=content,
              data=data,
              files=files,
              json=json,
              params=params,
              headers=headers,
              cookies=cookies,
              timeout=timeout,
              extensions=extensions,
          )

  s = Dub(async_client=CustomClient(httpx.AsyncClient()))
  ```
  <!-- End Custom HTTP Client [http-client] -->

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




  This SDK supports the following security scheme globally:

  | Name    | Type | Scheme      |
  | ------- | ---- | ----------- |
  | `token` | http | HTTP Bearer |

  To authenticate with the API the `token` parameter must be set when initializing the SDK client instance. For example:
  ```python
  from dub import Dub

  with Dub(
      token="DUB_API_KEY",
  ) as dub:

      res = dub.links.create(request={
          "url": "https://google.com",
          "external_id": "123456",
          "tag_ids": [
              "clux0rgak00011...",
          ],
      })

      assert res is not None

      
      print(res)

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

  <!-- Start Retries [retries] -->


  Some of the endpoints in this SDK support retries. If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API. However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.

  To change the default retry strategy for a single API call, simply provide a `RetryConfig` object to the call:
  ```python
  from dub import Dub
  from dub.utils import BackoffStrategy, RetryConfig

  with Dub(
      token="DUB_API_KEY",
  ) as dub:

      res = dub.links.create(request={
          "url": "https://google.com",
          "external_id": "123456",
          "tag_ids": [
              "clux0rgak00011...",
          ],
      },
          RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))

      assert res is not None

      
      print(res)

  ```

  If you'd like to override the default retry strategy for all operations that support retries, you can use the `retry_config` optional parameter when initializing the SDK:
  ```python
  from dub import Dub
  from dub.utils import BackoffStrategy, RetryConfig

  with Dub(
      retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
      token="DUB_API_KEY",
  ) as dub:

      res = dub.links.create(request={
          "url": "https://google.com",
          "external_id": "123456",
          "tag_ids": [
              "clux0rgak00011...",
          ],
      })

      assert res is not None

      
      print(res)

  ```
  <!-- End Retries [retries] -->

  <!-- Start Pagination [pagination] -->


  Some of the endpoints in this SDK support pagination. To use pagination, you make your SDK calls as usual, but the
  returned response object will have a `Next` method that can be called to pull down the next group of results. If the
  return value of `Next` is `None`, then there are no more pages to be fetched.

  Here's an example of one such pagination call:
  ```python
  from dub import Dub

  with Dub(
      token="DUB_API_KEY",
  ) as dub:

      res = dub.links.list(request={
          "page": 1,
          "page_size": 50,
      })

      while res is not None:
          

          res = res.next()

  ```
  <!-- End Pagination [pagination] -->

  <!-- Start Debugging [debug] -->


  You can setup your SDK to emit debug logs for SDK requests and responses.

  You can pass your own logger class directly into your SDK.
  ```python
  from dub import Dub
  import logging

  logging.basicConfig(level=logging.DEBUG)
  s = Dub(debug_logger=logging.getLogger("dub"))
  ```
  <!-- End Debugging [debug] -->

  <!-- Start IDE Support [idesupport] -->




  Generally, the SDK will work well with most IDEs out of the box. However, when using PyCharm, you can enjoy much better integration with Pydantic by installing an additional plugin.

  - [PyCharm Pydantic Plugin](https://docs.pydantic.dev/latest/integrations/pycharm/)
  <!-- End IDE Support [idesupport] -->

  <!-- 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: 42b4fadf370e3e5c7455faf789a22265598b35de0608110ac53a1d159d721ec4
name: python-ducflair-duc-help
arch: noarch
version: 1.14.0
epoch: 0
release: 1
summary: Development documents and examples for ducflair-duc
url: https://duc.ducflair.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ducflair-duc-1.14.0-1.src.rpm
location_href: Packages/python-ducflair-duc-help-1.14.0-1.noarch.rpm
checksum_type: sha256
description:
  *The duc format and libraries are constantly evolving, aiming to set new standards in the 2D CAD industry. Be a part of this transformation and help shape the future of design technology!*


pkgId: 51057a90ea46dd0c5f36a25fd1fef87649550ba7d8c355426d4ba3ea8656206b
name: python-duckdb-engine-help
arch: noarch
version: 0.14.0
epoch: 0
release: 1
summary: Development documents and examples for duckdb-engine
url: https://github.com/Mause/duckdb_engine
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-duckdb-engine-0.14.0-1.src.rpm
location_href: Packages/python-duckdb-engine-help-0.14.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/duckdb-engine)](https://pypi.org/project/duckdb-engine/) [![PyPI version](https://badge.fury.io/py/duckdb-engine.svg)](https://badge.fury.io/py/duckdb-engine) [![PyPI Downloads](https://img.shields.io/pypi/dm/duckdb-engine.svg)](https://pypi.org/project/duckdb-engine/) [![codecov](https://codecov.io/gh/Mause/duckdb_engine/graph/badge.svg)](https://codecov.io/gh/Mause/duckdb_engine)

  Basic SQLAlchemy driver for [DuckDB](https://duckdb.org/)

  <!--ts-->
  * [duckdb_engine](#duckdb_engine)
     * [Installation](#installation)
     * [Usage](#usage)
     * [Usage in IPython/Jupyter](#usage-in-ipythonjupyter)
     * [Configuration](#configuration)
     * [How to register a pandas DataFrame](#how-to-register-a-pandas-dataframe)
     * [Things to keep in mind](#things-to-keep-in-mind)
        * [Auto-incrementing ID columns](#auto-incrementing-id-columns)
        * [Pandas read_sql() chunksize](#pandas-read_sql-chunksize)
        * [Unsigned integer support](#unsigned-integer-support)
     * [Alembic Integration](#alembic-integration)
     * [Preloading extensions (experimental)](#preloading-extensions-experimental)
     * [The name](#the-name)

  <!-- Created by https://github.com/ekalinin/github-markdown-toc -->
  <!-- Added by: me, at: Wed 20 Sep 2023 12:44:27 AWST -->

  <!--te-->


  ```sh
  $ pip install duckdb-engine
  ```

  DuckDB Engine also has a conda feedstock available, the instructions for the use of which are available in it's [repository](https://github.com/conda-forge/duckdb-engine-feedstock).



  Once you've installed this package, you should be able to just use it, as SQLAlchemy does a python path search

  ```python
  from sqlalchemy import Column, Integer, Sequence, String, create_engine
  from sqlalchemy.ext.declarative import declarative_base
  from sqlalchemy.orm.session import Session

  Base = declarative_base()


  class FakeModel(Base):  # type: ignore
      __tablename__ = "fake"

      id = Column(Integer, Sequence("fakemodel_id_sequence"), primary_key=True)
      name = Column(String)


  eng = create_engine("duckdb:///:memory:")
  Base.metadata.create_all(eng)
  session = Session(bind=eng)

  session.add(FakeModel(name="Frank"))
  session.commit()

  frank = session.query(FakeModel).one()

  assert frank.name == "Frank"
  ```



  With IPython-SQL and DuckDB-Engine you can query DuckDB natively in your notebook! Check out [DuckDB's documentation](https://duckdb.org/docs/guides/python/jupyter) or
  Alex Monahan's great demo of this on [his blog](https://alex-monahan.github.io/2021/08/22/Python_and_SQL_Better_Together.html#an-example-workflow-with-duckdb).



  You can configure DuckDB by passing `connect_args` to the create_engine function
  ```python
  create_engine(
      'duckdb:///:memory:',
      connect_args={
          'read_only': False,
          'config': {
              'memory_limit': '500mb'
          }
      }
  )
  ```

  The supported configuration parameters are listed in the [DuckDB docs](https://duckdb.org/docs/sql/configuration)



  ```python
  conn = create_engine("duckdb:///:memory:").connect()


  conn.execute("register", ("dataframe_name", pd.DataFrame(...)))


  conn.execute(text("register(:name, :df)"), {"name": "test_df", "df": df})

  conn.execute("select * from dataframe_name")
  ```


  Duckdb's SQL parser is based on the PostgreSQL parser, but not all features in PostgreSQL are supported in duckdb. Because the `duckdb_engine` dialect is derived from the `postgresql` dialect, `SQLAlchemy` may try to use PostgreSQL-only features. Below are some caveats to look out for.


  When defining an Integer column as a primary key, `SQLAlchemy` uses the `SERIAL` datatype for PostgreSQL. Duckdb does not yet support this datatype because it's a non-standard PostgreSQL legacy type, so a workaround is to use the `SQLAlchemy.Sequence()` object to auto-increment the key. For more information on sequences, you can find the [`SQLAlchemy Sequence` documentation here](https://docs.sqlalchemy.org/en/14/core/defaults.html#associating-a-sequence-as-the-server-side-default).

  The following example demonstrates how to create an auto-incrementing ID column for a simple table:

  ```python
  >>> import sqlalchemy
  >>> engine = sqlalchemy.create_engine('duckdb:////path/to/duck.db')
  >>> metadata = sqlalchemy.MetaData(engine)
  >>> user_id_seq = sqlalchemy.Sequence('user_id_seq')
  >>> users_table = sqlalchemy.Table(
  ...     'users',
  ...     metadata,
  ...     sqlalchemy.Column(
  ...         'id',
  ...         sqlalchemy.Integer,
  ...         user_id_seq,
  ...         server_default=user_id_seq.next_value(),
  ...         primary_key=True,
  ...     ),
  ... )
  >>> metadata.create_all(bind=engine)
  ```



  **NOTE**: this is no longer an issue in versions `>=0.5.0` of `duckdb`

  The `pandas.read_sql()` method can read tables from `duckdb_engine` into DataFrames, but the `sqlalchemy.engine.result.ResultProxy` trips up when `fetchmany()` is called. Therefore, for now `chunksize=None` (default) is necessary when reading duckdb tables into DataFrames. For example:

  ```python
  >>> import pandas as pd
  >>> import sqlalchemy
  >>> engine = sqlalchemy.create_engine('duckdb:////path/to/duck.db')
  >>> df = pd.read_sql('users', engine)                ### Works as expected
  >>> df = pd.read_sql('users', engine, chunksize=25)  ### Throws an exception
  ```



  Unsigned integers are supported by DuckDB, and are available in [`duckdb_engine.datatypes`](duckdb_engine/datatypes.py).



  SQLAlchemy's companion library `alembic` can optionally be used to manage database migrations.

  This support can be enabling by adding an Alembic implementation class for the `duckdb` dialect.

  ```python
  from alembic.ddl.impl import DefaultImpl

  class AlembicDuckDBImpl(DefaultImpl):
      """Alembic implementation for DuckDB."""

      __dialect__ = "duckdb"
  ```

  After loading this class with your program, Alembic will no longer raise an error when generating or applying migrations.



  > DuckDB 0.9.0+ includes builtin support for autoinstalling and autoloading of extensions, see [the extension documentation](http://duckdb.org/docs/archive/0.9.0/extensions/overview#autoloadable-extensions) for more information.

  Until the DuckDB python client allows you to natively preload extensions, I've added experimental support via a `connect_args` parameter

  ```python
  from sqlalchemy import create_engine

  create_engine(
      'duckdb:///:memory:',
      connect_args={
          'preload_extensions': ['https'],
          'config': {
              's3_region': 'ap-southeast-1'
          }
      }
  )
  ```



  Yes, I'm aware this package should be named `duckdb-driver` or something, I wasn't thinking when I named it and it's too hard to change the name now


