# packages

pkgId: 0cc1bf34864f04d86f54048a486023f5b3e8e15fd4cf7a2456c28fc3f5b9a213
name: python-daplis
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Data Analysis Package for LInoSpad
url: https://github.com/rngKomorebi/daplis
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daplis-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Package for unpacking and analyzing the binary data from the timestamping mode of the LinoSPAD2 detector.

  ![Tests](https://github.com/rngKomorebi/LinoSPAD2/actions/workflows/tests.yml/badge.svg)
  ![Documentation](https://github.com/rngKomorebi/LinoSPAD2/actions/workflows/documentation.yml/badge.svg)



  This package was written for data analysis for LinoSPAD2, mainly for
  analysis of the timestamp output. The key functions are ones for
  unpacking the binary output of the detector that utilizes the numpy
  Python library for quick unpacking of .dat files to matrices,
  dictionaries, or data frames.

  The "functions" folder holds all functions from unpacking to plotting
  numerous types of graphs (pixel population, histograms of timestamp
  differences, etc.)

  The "params" folder holds masks (used to mask some of the noisiest
  pixels) and calibration data (compensating for TDC nonlinearities and
  offset) for LinoSPAD2 daughterboards.

  The "archive" folder is a collection of scripts for debugging, tests,
  older versions of functions, etc.

  The "examples" folder contains a few jupyter notebooks with examples
  on how to use the main functions, showcasing how to work with the
  most important function parameters.

  Full documentation, including examples and full documentation of
  modules and functions, can be found [here](https://rngkomorebi.github.io/daplis/).

  Some functions (mainly the plotting ones) save plots as pictures in the
  .png format, creating a folder for the output in the same folder that
  holds the data. Others (such as delta_t.py for collecting timestamp differences
  in the given time window) save .csv or .feather files with the processed data for
  easier and faster plotting.

  Additionally, a standalone repo with an application for online plotting
  of the sensor population can be found [here](https://github.com/rngKomorebi/LinoSPAD2-app).



  A fresh, separate virtual environment is highly recommended before installing the package.
  This can be done using pip, see, e.g., [this](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/).
  This can help to avoid any dependency conflicts and ensure smooth operation of the
  package.

  First, check if the virtualenv package is installed. To do this, one can run:
  ```
  pip show virtualenv
  ```
  If the package was not found, it can be installed using:
  ```
  pip install virtualenv
  ```
  To create a new environment, run the following (if 'py -m' does not work,
  try 'python -m', 'python3 -m'):
  ```
  py -m venv PATH/TO/ENVIRONMENT/ENVIRONMENT_NAME
  ```
  To activate the environment (on Windows):
  ```
  PATH/TO/ENVIRONMENT/ENVIRONMENT_NAME/Scripts/activate
  ```
  and on Linux:
  ```
  source PATH/TO/ENVIRONMENT/ENVIRONMENT_NAME/bin/activate
  ```

  Then, package itself can be installed using pip inside the environment:
  ```
  pip install daplis
  ```

  Alternatively, to start using the package, one can download the whole repo. "requirements.txt"
  lists all packages required for this project to run. One can create
  an environment for this project either using conda or pip following the instruction
  above. Once the new environmnt is activated, run the following to install
  the required packages:
  ```
  cd PATH/TO/GITHUB/CODES/daplis
  pip install -r requirements.txt
  ```
  Now, the package can be installed via
  ```
  pip install -e .
  ```
  where '-e' stands for editable: any changes introduced to the package will
  instantly become a part of the package and can be used without the need
  of reinstalling the whole thing. After that, one can import any function
  from the daplis package:
  ```
  from daplis.functions import sensor_plot, delta_t, fits
  ```

  For conda users, the new environment can be installed using the 'requirements'
  text file directly:
  ```
  conda create --name NEW_ENVIRONMENT_NAME --file /PATH/TO/requirements.txt -c conda-forge
  ```
  To install the package, first, switch to the created environment:
  ```
  conda activate NEW_ENVIRONMENT_NAME
  ```
  and run
  ```
  pip install -e .
  ```



  This repo consists of two branches: 'main' serves as the release version
  of the package, tested, proven to be functional, and ready to use, while
  the 'develop' branch serves as the main hub for testing new stuff. To
  contribute, the best way would be to fork the repository and use the 'develop'
  branch for new introductions, submitting the results via pull requests.
  Everyone willing to contribute is kindly asked to follow the
  [PEP 8](https://peps.python.org/pep-0008/) and
  [PEP 257](https://peps.python.org/pep-0257/) conventions.



  This package is available under the MIT license. See LICENSE for more
  information. If you'd like to contact me, the author, feel free to
  write at sergei.kulkov23@gmail.com.


pkgId: 00132c7af58fb9a01b9ad5c0fe4384e9d48cb0e30cf2f6ed5137eb14179830b5
name: python-daplis
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Data Analysis Package for LInoSpad
url: https://github.com/rngKomorebi/daplis
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daplis-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Package for unpacking and analyzing the binary data from the timestamping mode of the LinoSPAD2 detector.

  ![Tests](https://github.com/rngKomorebi/LinoSPAD2/actions/workflows/tests.yml/badge.svg)
  ![Documentation](https://github.com/rngKomorebi/LinoSPAD2/actions/workflows/documentation.yml/badge.svg)



  This package was written for data analysis for LinoSPAD2, mainly for
  analysis of the timestamp output. The key functions are ones for
  unpacking the binary output of the detector that utilizes the numpy
  Python library for quick unpacking of .dat files to matrices,
  dictionaries, or data frames.

  The "functions" folder holds all functions from unpacking to plotting
  numerous types of graphs (pixel population, histograms of timestamp
  differences, etc.)

  The "params" folder holds masks (used to mask some of the noisiest
  pixels) and calibration data (compensating for TDC nonlinearities and
  offset) for LinoSPAD2 daughterboards.

  The "archive" folder is a collection of scripts for debugging, tests,
  older versions of functions, etc.

  The "examples" folder contains a few jupyter notebooks with examples
  on how to use the main functions, showcasing how to work with the
  most important function parameters.

  Full documentation, including examples and full documentation of
  modules and functions, can be found [here](https://rngkomorebi.github.io/daplis/).

  Some functions (mainly the plotting ones) save plots as pictures in the
  .png format, creating a folder for the output in the same folder that
  holds the data. Others (such as delta_t.py for collecting timestamp differences
  in the given time window) save .csv or .feather files with the processed data for
  easier and faster plotting.

  Additionally, a standalone repo with an application for online plotting
  of the sensor population can be found [here](https://github.com/rngKomorebi/LinoSPAD2-app).



  A fresh, separate virtual environment is highly recommended before installing the package.
  This can be done using pip, see, e.g., [this](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/).
  This can help to avoid any dependency conflicts and ensure smooth operation of the
  package.

  First, check if the virtualenv package is installed. To do this, one can run:
  ```
  pip show virtualenv
  ```
  If the package was not found, it can be installed using:
  ```
  pip install virtualenv
  ```
  To create a new environment, run the following:
  ```
  virtualenv PATH/TO/NEW/ENVIRONMENT
  ```
  To activate the environment (on Windows):
  ```
  PATH/TO/NEW/ENVIRONMENTScripts/activate
  ```
  and on Linux:
  ```
  source PATH/TO/NEW/ENVIRONMENTbin/activate
  ```

  Then, package itself can be installed using pip inside the environment:
  ```
  pip install daplis
  ```

  Alternatively, to start using the package, one can download the whole repo. "requirements.txt"
  lists all packages required for this project to run. One can create
  an environment for this project either using conda or pip following the instruction
  above. Once the new environmnt is activated, run the following to install
  the required packages:
  ```
  cd PATH/TO/GITHUB/CODES/daplis
  pip install -r requirements.txt
  ```
  Now, the package can be installed via
  ```
  pip install -e .
  ```
  where '-e' stands for editable: any changes introduced to the package will
  instantly become a part of the package and can be used without the need
  of reinstalling the whole thing. After that, one can import any function
  from the daplis package:
  ```
  from daplis.functions import sensor_plot, delta_t, fits
  ```

  For conda users, the new environment can be installed using the 'requirements'
  text file directly:
  ```
  conda create --name NEW_ENVIRONMENT_NAME --file /PATH/TO/requirements.txt -c conda-forge
  ```
  To install the package, first, switch to the created environment:
  ```
  conda activate NEW_ENVIRONMENT_NAME
  ```
  and run
  ```
  pip install -e .
  ```



  This repo consists of two branches: 'main' serves as the release version
  of the package, tested, proven to be functional, and ready to use, while
  the 'develop' branch serves as the main hub for testing new stuff. To
  contribute, the best way would be to fork the repository and use the 'develop'
  branch for new introductions, submitting the results via pull requests.
  Everyone willing to contribute is kindly asked to follow the
  [PEP 8](https://peps.python.org/pep-0008/) and
  [PEP 257](https://peps.python.org/pep-0257/) conventions.



  This package is available under the MIT license. See LICENSE for more
  information. If you'd like to contact me, the author, feel free to
  write at sergei.kulkov23@gmail.com.


pkgId: 13d5771bd6ce943761b7f455917518248f34decf3e76d1d320b61b4ca599200e
name: python-dapodik
arch: src
version: 0.19.0
epoch: 0
release: 1
summary: SDK python untuk aplikasi dapodik.
url: https://dapodix.github.io/dapodik
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapodik-0.19.0-1.src.rpm
checksum_type: sha256
description:
  [![dapodik - PyPi](https://img.shields.io/pypi/v/dapodik)](https://pypi.org/project/dapodik/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/dapodik)](https://pypi.org/project/dapodik/)
  [![LISENSI](https://img.shields.io/github/license/dapodix/dapodik)](https://github.com/dapodix/dapodik/blob/master/LISENSI)
  [![Donate Saweria](https://img.shields.io/badge/Donasi-Saweria-blue)](https://saweria.co/hexatester)
  [![Tutorial](https://img.shields.io/badge/Tutorial-Penggunaan-informational)](https://github.com/dapodix/dapodik/wiki)
  [![Tests](https://github.com/dapodix/dapodik/workflows/Tests/badge.svg)](https://github.com/dapodix/dapodik/actions?query=workflow%3ATests)
  [![codecov](https://codecov.io/gh/dapodix/dapodik/branch/master/graph/badge.svg)](https://codecov.io/gh/dapodix/dapodik)
  [![Code Style - Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  SDK python untuk aplikasi dapodik.



  Pastikan [python 3.7+](https://www.python.org/ftp/python/3.7.9/python-3.7.9-amd64.exe) terinstall,
  kemudian jalankan perintah di bawah dalam Command Prompt atau Powershell (di Windows + X):

  ```bash
  pip install --upgrade dapodik
  ```



  Contoh pennggunaan

  ```python
  from dapodik import Dapodik

  email = 'email@saya.com'
  password = 'password dapodik'

  d = Dapodik(email, password)
  sekolah = d.sekolah()
  daftar_peserta_didik = d.peserta_didik(sekolah_id=sekolah.sekolah_id)
  for peserta_didik in daftar_peserta_didik:
      print(peserta_didik.nama)
  ```



  Kode ini sama sekali tidak berafiliasi dengan, diizinkan, dipelihara, disponsori atau didukung oleh [Kemdikbud](https://kemdikbud.go.id/) atau afiliasi atau anak organisasinya. Ini adalah perangkat lunak yang independen dan tidak resmi. _Gunakan dengan risiko Anda sendiri._


pkgId: 9b4426fe92928c9aabe637a7d91f469daafdc600e5b798f03a32beff80bea145
name: python-dapp-runner
arch: src
version: 0.3.1
epoch: 0
release: 1
url: https://github.com/golemfactory/dapp-runner
rpm_license: LGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapp-runner-0.3.1-1.src.rpm
checksum_type: sha256
summary:
  Golem dapp-runner - a high-level interface for running decentralized applications using the Golem Network.

description:
  `dapp-runner` is a utility that allows you to run decentralized applications on [Golem](https://www.golem.network/).
  It uses simple application descriptors expressed in `yaml`, similar to those used by
  tools like `docker-compose`.

  `dapp-runner` runs alongside the [Golem daemon](https://github.com/golemfactory/yagna)
  and uses [yapapi](https://github.com/golemfactory/yapapi), Golem's Python high-level API
  to communicate with it. As opposed to using plain `yapapi` though, deployment of
  applications on Golem using `dapp-runner` requires no code and no experience in Python.



  In its present form, the `dapp-runner` constitutes an initial reference implementation
  of the multi-service application deployment framework described in
  [GAP-16](https://github.com/golemfactory/golem-architecture/pull/39).

  Following features of the framework are currently supported:

  -   Descriptor "Apply" operation
  -   Single-YAML package support
  -   Merging descriptor files
  -   GAOM explicit dependency syntax
  -   GAOM object dependency graph _[currently limited to the services' explicit dependency syntax]_



  While the `dapp-runner` is perfectly capable of running decentralized apps on its own, we are also
  providing a separate tool to facilitate running and managing multiple applications on a single
  machine, namely, the [dapp-manager](https://github.com/golemfactory/dapp-manager/).

  dApp Manager keeps track of the launched apps and allows you to easily query their output streams.
  It uses the `dapp-runner` as its back-end and both require the yagna daemon to communicate with the
  rest of the Golem Network.





  To run Golem apps, `dapp-runner` requires a properly configured yagna daemon.
  In the future, you'll be able to provision apps using external supervisor machines
  which will run a yagna daemon on your behalf.

  For now, please follow the ["Requestor development: a quick primer"](https://handbook.golem.network/requestor-tutorials/flash-tutorial-of-requestor-development)
  tutorial and ensure that your `yagna` is up and running. Only the first part of this
  tutorial is required - you don't need to run the blender example.

  Most importantly, make sure you have set the `YAGNA_APPKEY` in your evironment, e.g. with:

  ```bash
  export YAGNA_APPKEY=insert-your-32-char-app-key-here
  ```

  or, on Windows:

  ```bash
  set YAGNA_APPKEY=insert-your-32-char-app-key-here
  ```

  and if you don't know what your app-key is, you can always query `yagna` with:

  ```bash
  yagna app-key list
  ```



  First, ensure you have Python 3.8 or later:

  ```bash
  python3 --version
  ```

  [ depending on the platform, it may be just `python` instead of `python3` ]

  If your Python version is older, consider using [pyenv](https://github.com/pyenv/pyenv-installer).

  Once your python interpreter reports a version 3.8 or later, you can set-up your virtual
  environment:

  ```bash
  python3 -m venv ~/.envs/dapp-runner
  source ~/.envs/dapp-runner/bin/activate
  ```

  or, if you're on Windows:

  ```shell
  python -m venv --clear %HOMEDRIVE%HOMEPATH%\.envs\dapp-runner
  %HOMEDRIVE%HOMEPATH%\.envs\dapp-runner\Scripts\activate.bat
  ```





  ```bash
  git clone --recurse-submodules https://github.com/golemfactory/dapp-runner.git
  ```



  ```bash
  cd dapp-runner
  pip install -U pip poetry
  poetry install
  ```



  Make sure your `yagna` daemon is running,
  you have initialized the payment driver with `yagna payment init --sender`,
  and that you have set the `YAGNA_APPKEY` environment variable.

  Then run:

  ```bash
  dapp-runner start --config configs/default.yaml dapp-store/apps/webapp.yaml
  ```

  You should see the application being deployed on the Golem Network and once it's up,
  you'll be greeted with:

  ```shell
  {"http": {"local_proxy_address": "http://localhost:8080"}}
  ```

  You can connect to [this address](http://localhost:8080) using your local browser,
  and you'll see our minimalistic web application example running.

  Press Ctrl-C in the terminal where you ran `dapp-runner` to initiate its shutdown.



  As mentioned above, the decentralized applications that are deployed on Golem by the
  `dapp-runner` are described in `yaml` files, conforming to the schema
  described in [GAP-16](https://github.com/golemfactory/golem-architecture/pull/39).



  Here's an example application descriptor (`http-proxy.yaml`), that provisions a single
  instance of a simple, static website served with `nginx`:

  ```yaml
  payloads:
      nginx:
          runtime: "vm"
          params:
              image_hash: "16ad039c00f60a48c76d0644c96ccba63b13296d140477c736512127"
  nodes:
      http:
          payload: "nginx"
          init:
              - ["/docker-entrypoint.sh"]
              - ["/bin/chmod", "a+x", "/"]
              - ["/bin/sh", "-c", 'echo "Hello from inside Golem!" > /usr/share/nginx/html/index.html']
              - ["/bin/rm", "/var/log/nginx/access.log", "/var/log/nginx/error.log"]
              - ["/usr/sbin/nginx"]
          http_proxy:
              ports:
                  - "80" # specify just the remote port, allow the local port to be automatically chosen
  ```



  And here's an example of a slightly more complex application (`webapp.yaml`), that uses
  two kinds of services and explicitly connects them within a specified network:

  ```yaml
  payloads:
      db:
          runtime: "vm"
          params:
              image_hash: "85021afecf51687ecae8bdc21e10f3b11b82d2e3b169ba44e177340c"
      http:
          runtime: "vm"
          params:
              image_hash: "c37c1364f637c199fe710ca62241ff486db92c875b786814c6030aa1"
  nodes:
      db:
          payload: "db"
          init:
              - ["/bin/run_rqlite.sh"]
          network: "default"
          ip:
              - "192.168.0.2"
      http:
          payload: "http"
          init:
              - ["/bin/bash", "-c", "cd /webapp && python app.py --db-address 192.168.0.2 --db-port 4001 initdb"]
              - ["/bin/bash", "-c", "cd /webapp && python app.py --db-address 192.168.0.2 --db-port 4001 run > /webapp/out 2> /webapp/err &"]
          http_proxy:
              ports:
                  - "5000" # specify just the remote port, allow the local port to be automatically chosen
          network: "default"
          ip:
              - "192.168.0.3"
          depends_on:
              - "db"
  networks:
      default:
          ip: "192.168.0.0/24"
  ```





  As can be seen in the `http_proxy` example above, the `networks` definition can be omitted.

  Adding a `http_proxy` element to a `nodes` entry, causes the `dapp-runner` to implicitly
  add the `networks` object with a default of a single IPv4 network. Additionally, it adds
  the `vpn` capability to the requested parameters of the deployed `vm` runtime.

  **_Note:_** The `networks` and `capabilities` objects will only be implicitly added if
  they are not already present in the descriptor. If the application specifies any of
  those objects, it is assumed that the application authors know what they're doing.



  Similarly, specifying the payload as `vm/manifest` implicitly adds `manifest-support` to
  the requested `capabilities` for the runtime.

  **_Note:_** Again, this is only done if the `payload.params` doesn't already contain the
  `capabilities` object.



  Currently, the `dapp-runner` implements a single CLI command, `start`:

  ```shell
  Usage: dapp-runner start [OPTIONS] DESCRIPTORS...
  ```

  which allows the following options:

  ```shell
    -d, --data PATH    Path to the data file.
    -l, --log PATH     Path to the log file.
    -s, --state PATH   Path to the state file.
    --stdout PATH      Redirect stdout to the specified file.
    --stderr PATH      Redirect stderr to the specified file.
    -c, --config PATH  Path to the file containing yagna-specific config.
                       [required]
    --silent
    --help             Show this message and exit.
  ```

  The `--data`, `--log`, `--state`, `--stdout`, and `--stderr` arguments specify the
  locations of files to which the respective streams are written. If unspecified, all
  streams are written to the console which the `dapp-runner` is invoked from.





  The `data` stream consists of JSON-formatted output of specific components that are run
  as part of the services. Currently it carries the command execution events from
  exescript commands, e.g.:

  ```json
  {
      "db": {
          "0": [
              {
                  "command": {
                      "run": {
                          "entry_point": "/bin/run_rqlite.sh",
                          "args": [],
                          "capture": { "stdout": { "stream": {} }, "stderr": { "stream": {} } }
                      }
                  },
                  "success": true,
                  "stdout": null,
                  "stderr": null
              }
          ]
      }
  }
  ```

  and the parameters of any started instances of Local HTTP proxies:

  ```json
  { "http": { "local_proxy_address": "http://localhost:8080" } }
  ```

  The keys in the outermost dictionaries refer to names of service cluster as specified in
  the `yaml` descriptor file. For exescript commands, the secondary layer's keys refer to
  indices of instances within the specific cluster.



  The `state` stream consists of JSON-formatted descriptions of the state of the dapp
  after each state change, e.g.:

  ```json
  { "db": { "0": "running" }, "http": { "0": "starting" } }
  ```

  Here, again, the keys in the topmost dictionary refer to the names of service clusters
  defined in the `yaml` descriptor file and the secondary layer's keys refer to indices
  of specific instances.



  The `log` stream is a text stream of log messages emitted from `dapp-runner`.



  Finally, `stdout` and `stderr` refer to the standard output streams of the `dapp-runner`
  script.



  This is a mandatory argument, specifying a path to a `yaml` file containing a
  description of a configuration to connect to your `yagna` daemon, e.g.:

  ```yaml
  yagna:
      app_key: "$YAGNA_APPKEY"
      subnet_tag: "devnet-beta"

  payment:
      budget: 1.0 # GLM
      driver: "erc20"
      network: "holesky"
  ```



  One or more application descriptors, as specified in the
  ["Application descriptor"](#application-descriptor) section above.

  If more than one `yaml` descriptor file is given, all of the `yaml` files are merged
  into one descriptor before being processed further by the `dapp-runner`. The files
  are merged using a deep-merge strategy with contents of each subsequent `yaml` file
  overriding the colliding keys of the former ones.


pkgId: 3fac53082b5f9de7976353b7d970b9df7108c348aee7c07b5ab21eb53d2e4353
name: python-dapr
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: The official release of Dapr Python SDK.
url: https://dapr.io/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapr-1.14.0-1.src.rpm
checksum_type: sha256
description:
  Dapr is a portable, serverless, event-driven runtime that makes it easy for developers to
  build resilient, stateless and stateful microservices that run on the cloud and edge and
  embraces the diversity of languages and developer frameworks.

  Dapr codifies the best practices for building microservice applications into open,
  independent, building blocks that enable you to build portable applications with the language
  and framework of your choice. Each building block is independent and you can use one, some,
  or all of them in your application.


pkgId: 67d33e43839e475d6ea651409bc43fee505cd17584d45d3a8407e016855265d1
name: python-dapr-ext-fastapi
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: The official release of Dapr FastAPI extension.
url: https://dapr.io/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapr-ext-fastapi-1.14.0-1.src.rpm
checksum_type: sha256
description:
  This is the FastAPI extension for Dapr.

  Dapr is a portable, serverless, event-driven runtime that makes it easy for developers to
  build resilient, stateless and stateful microservices that run on the cloud and edge and
  embraces the diversity of languages and developer frameworks.

  Dapr codifies the best practices for building microservice applications into open,
  independent, building blocks that enable you to build portable applications with the language
  and framework of your choice. Each building block is independent and you can use one, some,
  or all of them in your application.


pkgId: c06a813d1ab8e6fcfeeeab509553bb36be048fe6ab3f067932a1b40f17589ccc
name: python-dapr-ext-grpc
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: The official release of Dapr Python SDK gRPC Extension.
url: https://dapr.io/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapr-ext-grpc-1.14.0-1.src.rpm
checksum_type: sha256
description:
  This is the gRPC extension for Dapr.

  Dapr is a portable, serverless, event-driven runtime that makes it easy for developers to
  build resilient, stateless and stateful microservices that run on the cloud and edge and
  embraces the diversity of languages and developer frameworks.

  Dapr codifies the best practices for building microservice applications into open,
  independent, building blocks that enable you to build portable applications with the language
  and framework of your choice. Each building block is independent and you can use one, some,
  or all of them in your application.


pkgId: 4eb91eae8758d8db447ff128500f403ab6d04b030012cae61560e82dede78adf
name: python-dapr-ext-workflow
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: The official release of Dapr Python SDK Workflow Authoring Extension.
url: https://dapr.io/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapr-ext-workflow-0.5.0-1.src.rpm
checksum_type: sha256
description:
  This is the Workflow authoring extension for Dapr.

  Dapr is a portable, serverless, event-driven runtime that makes it easy for developers to
  build resilient, stateless and stateful microservices that run on the cloud and edge and
  embraces the diversity of languages and developer frameworks.

  Dapr codifies the best practices for building microservice applications into open,
  independent, building blocks that enable you to build portable applications with the language
  and framework of your choice. Each building block is independent and you can use one, some,
  or all of them in your application.


pkgId: dca65c82831d460b90d53faed1db42e827c937a487db76534686e5bacbea3107
name: python-daq-config-server
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A service to put and get your config values from
url: https://pypi.org/project/daq-config-server/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daq-config-server-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Frontend CI](https://github.com/DiamondLightSource/daq-config-server/actions/workflows/gui_ci.yml/badge.svg)](https://github.com/DiamondLightSource/daq-config-server/actions/workflows/gui_ci.yml)
  [![Backend CI](https://github.com/DiamondLightSource/daq-config-server/actions/workflows/backend_ci.yml/badge.svg)](https://github.com/DiamondLightSource/daq-config-server/actions/workflows/backend_ci.yml)
  [![Coverage](https://codecov.io/gh/DiamondLightSource/daq-config-server/branch/main/graph/badge.svg)](https://codecov.io/gh/DiamondLightSource/daq-config-server)
  [![PyPI](https://img.shields.io/pypi/v/daq-config-server.svg)](https://pypi.org/project/daq-config-server)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)



  A service to put and get your config values from.

  Comprises a FastAPI backend with a valkey database to C/R/U/D config values, and a Chakra/React frontend for easier management.

  Currently the scope is JUST storing and retrieving feature flags for Hyperion/I03 UDC but we hope to expand this to replace all DAQ config files.

  |  Source  |     <https://github.com/DiamondLightSource/daq-config-server>      |
  | :------: | :----------------------------------------------------------------: |
  |  Docker  |  `docker run ghcr.io/DiamondLightSource/daq-config-server:latest`  |
  | Releases | <https://github.com/DiamondLightSource/daq-config-server/releases> |

  A simple app for storing and fetching values. Has a Valkey (Redis) instance as well as options for file-backed legacy
  values (e.g. `beamlineParameters`...)

  Currently the server application always needs to be run with the `--dev` flag, as it cannot yet look at the DLS
  filesystem to find the real beamline parameter files.

  To use the config values in an experimental application (e.g. Hyperion) you can do:

  ```python
  from daq_config_server.client import ConfigServer

  config_server = ConfigServer("<service ip address>", <port>)

  use_stub_offsets: bool = config_server.best_effort_get_feature_flag("use_stub_offsets")

  ```

  To work on the GUI you will probably need to run:

  ```bash
  module load node
  npm install
  ```

  in the gui directory to setup the environment.



  There is a convenient script in `./deployment/build_and_push_all.sh` to build all the containers, which takes
  a `--dev` option to push containers with `-dev` appended to their names and a `--no-push` option for local
  development. This ensures that environment variables for dev or prod builds are included in the built container,
  such as the GUI pointing at the subdomain URL vs. localhost, and the `root_path` of the FastAPI app. To push to
  the registry you must have identified to gcloud by having loaded a kubernetes module and running `gcloud auth login.`

  To deploy a live version, you can run the above script with no arguments and then while logged in to
  argus, in the `daq-config-server` namespace, run `kubectl rollout restart deployment`. If it is not
  currently deploy it you can deploy it with `helm install daq-config ./helmchart`.

  To test locally, you can build everything with `./deployment/build_and_push_all.sh --dev --no-push` and then
  run the containers `daq-config-server-dev` (with the command `daq-config-server --dev`), `daq-config-server-db-dev`,
  and `daq-config-server-gui-dev`, all with the `--net host` option.

  To test on pollux, log in to pollux in your namespace and run:

  ```bash
  helm install daq-config ./helmchart/ --values dev-values.yaml
  ```

  followed by:

  ```bash
  kubectl port-forward service/daq-config-server-svc 8080 8555
  ```

  after which you should be able to access the frontend on `http://localhost:8080` and the API on `http://localhost:8555`

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


pkgId: 3e7f8e8e275135a073ca0b7f38fee99a88035e0fdb0b54f62766a9b44e7def43
name: python-daqview
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: DAQ Data Analysis Software
url: https://pypi.org/project/daqview/
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daqview-0.7.3-1.src.rpm
checksum_type: sha256
description:
  DAQview is a desktop application for viewing live and historic DAQ data
  from the Airborne Engineering Ltd DAQ system.

  For more information and the user manual, refer to our website:

  https://www.ael.co.uk/pages/daqview.html

  Licensed under the GPL 3.0 license.



  The recommended way to install is to use `pipx` to install from the published
  version on PyPI:

  ```
  pipx install daqview
  ```

  To run DAQview after installation, run `daqview`.

  On a Linux desktop, complete installation by running `daqview --install`
  to add the application to your list of locally-installed applications.



  First ensure poetry is installed:

  ```
  pipx install poetry
  ```

  Then you should be able to install all dependencies using:

  ```
  poetry install
  ```

  Run using:
  ```
  poetry run python -m daqview
  ```

  Run tests with:
  ```
  poetry run pytest
  ```

  Run linters with:
  ```
  poetry run flake8 daqview
  ```


pkgId: e42362be332191375fdd8b3cec053eead679251422cd8d1eb3d13380937780a2
name: python-daqx
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/wtmtmw/daqx
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daqx-0.0.1-1.src.rpm
checksum_type: sha256
description:
  ![License](https://img.shields.io/badge/license-MIT-blue)

  :warning: This project is still under construction / development

  Python data acquisition toolbox - Wrapper that provides high-level layers for controlling data acquisition boards. It also handles low-level memory management, data transfer, and provides various types of event callbacks.

  Currently, it only supports boards from Measurement Computing. Support for National Instruments may be added in the future.


  - [Installation](#installation)
  - [Event Callbacks](#event-callbacks)
  - [Usage](#usage)
  - [Tutorial](#tutorial)



  - `pip install daqx`


  **Start callback -** AI, AO

  **Stop callback -** AI, AO

  **Trigger callback -** AI

  **Samples acquired callback -** AI


pkgId: 5956f2d3ceb2bee360782189c118a144af21c26df953d45030c888c99576f2b2
name: python-dar-backup
arch: src
version: 0.5.15
epoch: 0
release: 1
url: https://github.com/per2jensen/dar-backup
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dar-backup-0.5.15-1.src.rpm
checksum_type: sha256
summary:
  A script to do full, differential and incremental backups using dar.     Some files are restored from the backups during verification, after which par2 redundancy files are created.     The script also has a cleanup feature to remove old backups and par2 files.

description:
  [Saved][-]       [-L-][   0%][ ]  drwxr-xr-x   root	root	113 Mio	Sat May 11 16:16:48 2024	home
  [Saved][-]       [-L-][   0%][ ]  drwxrwxr-x   pj	pj	113 Mio	Sun Jun 23 10:46:30 2024	home/pj
  [Saved][-]       [-L-][   0%][ ]  drwxrwxr-x   pj	pj	113 Mio	Sun Jun 23 09:17:42 2024	home/pj/tmp
  [Saved][-]       [-L-][   1%][ ]  drwxrwxr-x   pj	pj	50 Mio	Wed Jun 19 20:52:13 2024	home/pj/tmp/LUT-play
  [Saved][ ]       [-L-][   0%][X]  -rw-rw-r--   pj	pj	49 Mio	Sun Jun 16 12:52:22 2024	home/pj/tmp/LUT-play/2024-06-16_12:52:22,15.NEF
  ```


  ```
  dar -l /tmp/example_FULL_2024-06-23  -g home/pj/tmp/LUT-play
  ```
  gives
  ```


pkgId: e92cbe2b9aaf29012047370da9865c81cb6c30ca82193ae4dad7475de4da2e56
name: python-daraja-client
arch: src
version: 0.1.2
epoch: 0
release: 1
url: https://github.com/anomalous254/daraja_client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daraja-client-0.1.2-1.src.rpm
checksum_type: sha256
summary:
  This python module provides a simple way to integrate the Safaricom MPESA Daraja 2.0 API into your Python projects. It is designed to handle common operations like generating access tokens, formatting phone numbers, and sending STK Push requests.

description:
  This python module provides a simple way to integrate the Safaricom MPESA Daraja 2.0 API into your Python projects. It is designed to handle common operations like generating access tokens, formatting phone numbers, and sending STK Push requests.



  - Generate access tokens securely.
  - Format and validate phone numbers.
  - Send STK Push requests for payments.
  - Easily configurable with environment variables.




  Install the library directly from PyPI:
  ```bash
  pip install daraja-client
  ```



  1. Clone the repository:
     ```bash
     git clone https://github.com/anomalous254/daraja_client.git
     ```

  2. Navigate to the project directory:
     ```bash
     cd daraja_client
     ```

  3. Install dependencies:
     ```bash
     pip install -r requirements.txt
     ```



  Add the following variables to your `.env` file in the root directory of your project:

  ```env
  DARAJA_API_CONSUMER_KEY='your_consumer_key'
  DARAJA_API_CONSUMER_SECRET='your_consumer_secret'
  DARAJA_API_PASS_KEY='your_pass_key'
  DARAJA_API_SHORT_CODE='your_shortcode'
  ```





  ```python
  from daraja_client.core import DarajaClient
  from decouple import config


  auth_url = "https://sandbox.safaricom.co.ke/oauth/v1/generate?grant_type=client_credentials"
  stk_push_url = 'https://sandbox.safaricom.co.ke/mpesa/stkpush/v1/processrequest'
  call_back_url = 'https://your-callback-url.com' #
  phone_number = '+254769507699' # person to receive the prompt


  cl = DarajaClient(
      auth_url=auth_url,
      consumer_key=config('DARAJA_API_CONSUMER_KEY'),
      consumer_secret=config('DARAJA_API_CONSUMER_SECRET'),
      pass_key=config('DARAJA_API_PASS_KEY'),
      shortcode=config('DARAJA_API_SHORT_CODE'),
      phone_number=phone_number,
      call_back_url=call_back_url
  )


  response = cl.send_stk_push(stk_push_url=stk_push_url)
  print(response)
  ```





  ```json
  {
      "message": "success",
      "stkpushID": "ws_CO_blahblahblah",
      "info": "You can use and store this stkpushID in your db model to be used for payment confirm during callback from Safaricom"
  }
  ```



  ```json
  {
      "message": "failed",
      "error": "Wrong credentials"
  }
  ```



  This library was developed by [Peter Nyando](https://nyando-tech.vercel.app/), a passionate software engineer dedicated to creating scalable and efficient solutions. Check out more of my work on my [portfolio](https://nyando-tech.vercel.app/).


  Ensure your `.env` file is properly configured.




  1. Fork the repository.
  2. Create a new branch.
  3. Make your changes and commit them.
  4. Push to your fork and submit a pull request.



  This project is licensed under the MIT License. See the `LICENSE` file for details.


pkgId: 3fda7dd61fec5f8f529aac818257f4be7804dcc3906b7e57a04a4ebcb6472b66
name: python-daraja-client
arch: src
version: 0.1.3
epoch: 0
release: 1
url: https://github.com/anomalous254/daraja_client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daraja-client-0.1.3-1.src.rpm
checksum_type: sha256
summary:
  This python module provides a simple way to integrate the Safaricom MPESA Daraja 2.0 API into your Python projects. It is designed to handle common operations like generating access tokens, formatting phone numbers, and sending STK Push requests.

description:
  This python module provides a simple way to integrate the Safaricom MPESA Daraja 2.0 API into your Python projects. It is designed to handle common operations like generating access tokens, formatting phone numbers, and sending STK Push requests.



  - Generate access tokens securely.
  - Format and validate phone numbers.
  - Send STK Push requests for payments.
  - Easily configurable with environment variables.




  Install the library directly from PyPI:
  ```bash
  pip install daraja-client
  ```



  1. Clone the repository:
     ```bash
     git clone https://github.com/anomalous254/daraja_client.git
     ```

  2. Navigate to the project directory:
     ```bash
     cd daraja_client
     ```

  3. Install dependencies:
     ```bash
     pip install -r requirements.txt
     ```



  Add the following variables to your `.env` file in the root directory of your project:

  ```env
  DARAJA_API_CONSUMER_KEY='your_consumer_key'
  DARAJA_API_CONSUMER_SECRET='your_consumer_secret'
  DARAJA_API_PASS_KEY='your_pass_key'
  DARAJA_API_SHORT_CODE='your_shortcode'
  ```





  ```python
  from daraja_client.core import DarajaClient
  from decouple import config


  auth_url = "https://sandbox.safaricom.co.ke/oauth/v1/generate?grant_type=client_credentials"
  stk_push_url = 'https://sandbox.safaricom.co.ke/mpesa/stkpush/v1/processrequest'
  call_back_url = 'https://your-callback-url.com' #
  phone_number = '+254769507699' # person to receive the prompt
  amount = '1'


  cl = DarajaClient(
      auth_url=auth_url,
      consumer_key=config('DARAJA_API_CONSUMER_KEY'),
      consumer_secret=config('DARAJA_API_CONSUMER_SECRET'),
      pass_key=config('DARAJA_API_PASS_KEY'),
      shortcode=config('DARAJA_API_SHORT_CODE'),
      phone_number=phone_number,
      call_back_url=call_back_url,
      amount=amount
  )


  response = cl.send_stk_push(stk_push_url=stk_push_url)
  print(response)
  ```





  ```json
  {
      "message": "success",
      "stkpushID": "ws_CO_blahblahblah",
      "info": "You can use and store this stkpushID in your db model to be used for payment confirm during callback from Safaricom"
  }
  ```



  ```json
  {
      "message": "failed",
      "error": "Wrong credentials"
  }
  ```



  This library was developed by [Peter Nyando](https://nyando-tech.vercel.app/), a passionate software engineer dedicated to creating scalable and efficient solutions. Check out more of my work on my [portfolio](https://nyando-tech.vercel.app/).


  Ensure your `.env` file is properly configured.




  1. Fork the repository.
  2. Create a new branch.
  3. Make your changes and commit them.
  4. Push to your fork and submit a pull request.



  This project is licensed under the MIT License. See the `LICENSE` file for details.


pkgId: 5c410387afdb7e9594f27fd1390180374acd12a981c9abb1d4e2623094a9c7c2
name: python-darglint
arch: src
version: 1.8.1
epoch: 0
release: 1
summary: A utility for ensuring Google-style docstrings stay up to date with the source code.
url: https://pypi.org/project/darglint/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darglint-1.8.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/terrencepreilly/darglint.svg?branch=develop)](https://travis-ci.com/terrencepreilly/darglint)



  A functional docstring linter which checks whether a docstring's
  description matches the actual function/method implementation.
  *Darglint* expects docstrings to be formatted using the
  [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html),
  or [Sphinx Style Guide](https://pythonhosted.org/an_example_pypi_project/sphinx.html#function-definitions),
  or [Numpy Style Guide](https://numpydoc.readthedocs.io/en/latest/format.html).

  Feel free to submit an issue/pull request if you spot a problem or
  would like a feature in *darglint*.

  **Table of Contents**:

  - [Project Status](#project-status)
  - [Installation](#installation)
  - [Configuration](#configuration)
  - [Usage](#usage)
  - [Scope](#scope)
  - [Sphinx](#sphinx)
  - [Numpy](#numpy)
  - [Integrations](#integrations)
  - [Flake8](#flake8)
  - [Roadmap](#roadmap)
  - [Contribution](#development-and-contributions)




  I no longer work with Python regularly, and I'd like to spend some more
  time on other projects.  So while I'll continue to maintain darglint,
  I likely won't be adding significant new features.  That said, I will
  try to accept pull requests.  See the contribution section for more
  information.  Consider it in maintenance mode.




  To install *darglint*, use pip.

  ```bash
  pip install darglint
  ```

  Or, clone the repository, `cd` to the directory, and

  ```bash
  pip install .
  ```



  *darglint* can be configured using a configuration file.  The configuration
  file must be named either *.darglint*, *setup.cfg*, or *tox.ini*.  It must
  also have a section starting with the section header, `[darglint]`.
  Finally, the configuration file must be located either in the directory
  *darglint* is called from, or from a parent directory of that working
  directory.

  Currently, the configuration file allows us to ignore errors, to specify
  message templates, to specify the strictness of checks and to ignore common
  exceptions.



  If we would like to ignore `ExcessRaiseError`s (because we know that
  an underlying function will raise an exception), then we would add its
  error code to a file named *.darglint*:

  ```ini
  [darglint]
  ignore=DAR402
  ```

  We can ignore multiple errors by using a comma-separated list:

  ```ini
  [darglint]
  ignore=DAR402,DAR103
  ```

  Instead of specifying error codes to ignore in general one can also specify a
  regex to exclude certain function names from tests. For example, the following
  configuration would disable linting on all private methods.
  ```ini
  [darglint]
  ignore_regex=^_(.*)
  ```



  If we would like to specify a message template, we may do so as
  follows:

  ```ini
  [darglint]
  message_template={msg_id}@{path}:{line}
  ```

  Which will produce a message such as `DAR102@driver.py:72`.

  Finally, we can specify the docstring style type using `docstring_style`
  ("google" by default):

  ```ini
  [darglint]
  docstring_style=sphinx
  ```



  Strictness determines how lax darglint will be when checking docstrings.
  There are three levels of strictness available:

  - short: One-line descriptions are acceptable; anything
  more and the docstring will be fully checked.

  - long: One-line descriptions and descriptions without
  arguments/returns/yields/etc. sections will be allowed.  Anything more,
  and the docstring will be fully checked.

  - full: (Default) Docstrings will be fully checked.

  For example, if we have the following function:

  ```python
  def double(x):
      
      return x * 2
  ```

  Then the following table describes which errors will be raised for
  each of the docstrings (rows) when checked against each of the
  configurations (columns):

  ```
  ┌──────────────────────────────┬──────────────────┬────────────────┬──────────────────┐
  │ Docstring                    │  short           │  long          │  full            │
  ├──────────────────────────────┼──────────────────┼────────────────┼──────────────────┤
  │ """Doubles the argument."""  │ None             │ None           │ Missing argument │
  │                              │                  │                │ Missing return   │
  │                              │                  │                │                  │
  │                              │                  │                │                  │
  ├──────────────────────────────┼──────────────────┼────────────────┼──────────────────┤
  │ """Doubles the argument.     │ Missing argument │ None           │ Missing argument │
  │                              │ Missing return   │                │ Missing return   │
  │ Not very pythonic.           │                  │                │                  │
  │                              │                  │                │                  │
  │ """                          │                  │                │                  │
  │                              │                  │                │                  │
  ├──────────────────────────────┼──────────────────┼────────────────┼──────────────────┤
  │ """Doubles the argument.     │ Missing return   │ Missing return │ Missing return   │
  │                              │                  │                │                  │
  │ Args:                        │                  │                │                  │
  │     x: The number to double. │                  │                │                  │
  │                              │                  │                │                  │
  │ """                          │                  │                │                  │
  └──────────────────────────────┴──────────────────┴────────────────┴──────────────────┘
  ```

  In short, if you want to be able to have single-line docstrings, and check
  all other docstrings against their described parameters, you would specify

  ```ini
  [darglint]
  strictness=short
  ```

  In your configuration file.



  We can specify a list of exceptions that don't need to be documented in the
  raises section of a docstring. For example,

  ```ini
  [darglint]
  ignore_raise=ValueError,MyCustomError
  ```



  When *darglint* fails unexpectedly, you can try to gather more
  information when submitting a bug by running with logging.
  For example,

  ```bash
  darglint --log-level=INFO unexpected_failures.py
  ```

  *Darglint* accepts the levels, `DEBUG`, `INFO`, `WARNING`, `ERROR`, and
  `CRITICAL`.







  Given a python source file, `serializers.py`, you would check the docstrings
  as follows:

  ```bash
  darglint serializers.py
  ```

  You can give an optional verbosity setting to *darglint*.  For example,

  ```bash
  darglint -v 2 *.py
  ```

  Would give a description of the error along with information as to this
  specific instance.  The default verbosity is 1, which gives the filename,
  function name, line number, error code, and some general hints.

  To use an arbitrary error format, you can pass a message template, which
  is a python format string.  For example, if we pass the message
  template

  ```bash
  darglint -m "{path}:{line} -> {msg_id}" darglint/driver.py
  ```

  Then we would get back error messages like

  ```bash
  darglint/driver.py :61 -> DAR101
  ```

  The following attributes can be passed to the format string:
  - *line*: The line number,
  - *msg*: The error message,
  - *msg_id*: The error code,
  - *obj*: The function/method name,
  - *path*: The relative file path.

  The message template can also be specified in the configuration file
  as the value `message_template`.

  *darglint* is particularly useful when combined with the utility, `find`.
  This allows us to check all of the files in our project at once.  For example,
  when eating my own dogfood (as I tend to do), I invoke *darglint* as follows:

  ```bash
  find . -name "*.py" | xargs darglint
  ```

  Where I'm searching all files ending in ".py" recursively from the
  current directory, and calling *darglint* on each one in turn.



  You can ignore specific errors in a particular docstring.  The syntax
  is much like that of *pycodestyle*, etc.  It generally takes the from
  of:

  ```python

  ```

  Where `<error>` is the particular error to ignore (`DAR402`, or `DAR201`
  for example), and `<argument>` is what (if anything) the ignore
  statement refers to (if nothing, then it is not specified).

  Let us say that we want to ignore a missing return statement
  in the following docstring:

  ```python
  def we_dont_want_a_returns_section():
    """Return the value, 3.

    

    """
    return 3
  ```

  We put the `noqa` anywhere in the top level of the docstring.
  However, this won't work if we are missing something more specific,
  like a parameter.  We may not want to ignore all missing parameters,
  either, just one particular one.  For example, we may be writing a
  function that takes a class instance as self. (Say, in a bound *celery*
  task.) Then we would do something like:

  ```python
  def a_bound_function(self, arg1):
    """Do something interesting.

    Args:
      arg1: The first argument.

    

    """
    arg1.execute(self)
  ```

  So, the argument comes to the right of the error.

  We may also want to mark excess documentation as being okay.  For example,
  we may not want to explicitly catch and raise a `ZeroDivisionError`.  We
  could do the following:

  ```python
  def always_raises_exception(x):
      """Raise a zero division error or type error.o

      Args:
        x: The argument which could be a number or could not be.

      Raises:
        ZeroDivisionError: If x is a number.  # noqa: DAR402
        TypeError: If x is not a number.  # noqa: DAR402

      """
      x / 0
  ```

  So, in this case, the argument for `noqa` is really all the way to
  the left.  (Or whatever description we are parsing.)  We could also
  have put it on its own line, as `# noqa: DAR402 ZeroDivisionError`.



  Darglint parses type annotations in docstrings, and can, optionally,
  compare the documented type to the actual type annotation.  This can
  be useful when migrating a codebase to use type annotations.

  In order to make these comparisons, Darglint only accepts types
  accepted by Python (see [PEP 484](https://www.python.org/dev/peps/pep-0484/).)
  That is, it does not accept parentheses in type signatures. (If
  parentheses are used in the type signature, Darglint will mark that
  argument as missing.  See Issue #90.)




  - *DAR001*: The docstring was not parsed correctly due to a syntax error.
  - *DAR002*: An argument/exception lacks a description
  - *DAR003*: A line is under-indented or over-indented.
  - *DAR004*: The docstring contains an extra newline where it shouldn't.
  - *DAR005*: The item contains a type section (parentheses), but no type.
  - *DAR101*: The docstring is missing a parameter in the definition.
  - *DAR102*: The docstring contains a parameter not in function.
  - *DAR103*: The docstring parameter type doesn't match function.
  - *DAR104*: (disabled) The docstring parameter has no type specified
  - *DAR105*: The docstring parameter type is malformed.
  - *DAR201*: The docstring is missing a return from definition.
  - *DAR202*: The docstring has a return not in definition.
  - *DAR203*: The docstring parameter type doesn't match function.
  - *DAR301*: The docstring is missing a yield present in definition.
  - *DAR302*: The docstring has a yield not in definition.
  - *DAR401*: The docstring is missing an exception raised.
  - *DAR402*: The docstring describes an exception not explicitly raised.
  - *DAR501*: The docstring describes a variable which is not defined.

  The number in the hundreds narrows the error by location in the docstring:

  - 000: Syntax, formatting, and style
  - 100: Args section
  - 200: Returns section
  - 300: Yields section
  - 400: Raises section
  - 500: Variables section

  You can enable disabled-by-default exceptions in the configuration file
  using the `enable` option.  It accepts a comma-separated list of error
  codes.

  ```ini
  [darglint]
  enable=DAR104
  ```



  Darglint's primary focus is to identify incorrect and missing documentationd
  of a function's signature. Checking style is a stretch goal, and is supported
  on a best-effort basis.  Darglint does not check stylistic preferences expressed
  by tools in the Python Code Quality Authority (through tools such as `pydocstyle`).
  So when using Darglint, it may be a good idea to also use `pydocstyle`, if you
  want to enforce style.  (For example, `pydocstyle` requires the short summary
  to be separated from other sections by a line break.  Darglint makes no such check.)



  Darglint can handle sphinx-style docstrings, but imposes some restrictions
  on top of the Sphinx style. For example, all fields (such as `:returns:`)
  must be the last items in the docstring.  They must be together, and all
  indents should be four spaces.  These restrictions may be loosened at a
  later date.

  To analyze Sphinx-style docstrings, pass the style flag to the command:

  ```bash
  darglint -s sphinx example.py
  darglint --docstring-style sphinx example.py
  ```

  Alternatively, you can specify the style in the configuration file using
  the setting, "docstring\_style":

  ```ini
  [darglint]
  docstring_style=sphinx
  ```



  Darglint now has an initial implementation for Numpy-style docstrings.
  Similarly to Sphinx-style docstrings, you can pass a style flag to the
  command:

  ```bash
  darglint -s numpy example.py
  darglint --docstring-style numpy example.py
  ```

  Or set it in a configuration file:

  ```ini
  [darglint]
  docstring_style=numpy
  ```

  The numpy parser and error reporter are not yet fully stabilized.
  Add issues or suggestions to the tracking bug, Issue #69.





  Darglint can be used in conjunction with Flake8 as a plugin.  The only
  setup necessary is to install Flake8 and Darglint in the same environment.
  Darglint will pull its configuration from Flake8. So, if you would like to
  lint Sphinx-style comments, then you should have `docstring_style=sphinx` in a
  Flake8 configuration file in the project directory.  The settings would
  be entered under the flake8 configuration, not a separate configuration
  for Darglint.  E.g.:

  ```ini
  [flake8]
  strictness=short
  docstring_style=sphinx
  ```

  To see which options are exposed through Flake8, you can check the Flake8
  tool:

  ```bash
  flake8 --help | grep --before-context=2 Darglint
  ```



  A plugin for SublimeLinter can be found [here](https://github.com/raddessi/SublimeLinter-contrib-darglint)



  Download [pre-commit](https://pre-commit.com/) and
  [install](https://pre-commit.com/#install) it. Once it is installed, add this
  to `.pre-commit-config.yaml` in your repository:

  ```yaml
  repos:
  -   repo: https://github.com/terrencepreilly/darglint
      rev: master
      hooks:
      - id: darglint
  ```

  Then run `pre-commit install` and you're ready to go. Before commiting,
  `darglint` will be run on the staged files. If it finds any errors, the user
  is notified and the commit is aborted. Store necessary configuration (such as
  error formatting) in `.darglint`, `setup.cfg` or `tox.ini`.




  Below are some of the current features or efforts.  Where a milestone or
  issue is associated with the idea, it will be mentioned.  Some of these
  ideas are moonshots and may not get implemented.  They are ordered
  roughly according to current priority/feasibility.

  - [ ] Expose command-line options through sphinx.
  - [ ] Robust logging for errors caused/encountered by *darglint*.
  - [ ] Check class docstrings (See Issue #25).
  - [ ] Autoformatting docstrings.  (See Milestone #3).
  - [ ] Optional aggressive style checking through command line flag.
  - [ ] ALE support.
  - [ ] Syntastic support. (Syntastic is not accepting new checkers until
  their next API stabilizes, so this may take some time.)






  Install `darglint`. First, clone the repository:

  ```bash
  git clone https://github.com/terrencepreilly/darglint.git
  ```

  `cd` into the directory, create a virtual environment (optional), then setup:

  ```bash
  cd darglint/
  virtualenv -p python3.6 .env
  source .env/bin/activate
  pip install -e .
  ```

  You can install dependencies using

  ```bash
  pip install poetry
  poetry install
  ```

  You can run the tests using

  ```bash
  python setup.py test
  ```

  Or, install `pytest` manually, `cd` to the project's root directory,
  and run

  ```bash
  pytest
  ```

  This project tries to conform by the styles imposed by `pycodestyle`
  and `pydocstyle`, as well as by `darglint` itself.


  A dockerfile exists for testing with Python3.4.  Although it's not
  officially supported (only 3.6+), it's nice to try to make minor
  version numbers support it.  You would build the dockerfile and
  test using something like

  ```bash
  pushd docker-build
  docker build -t darglint-34 -f Dockerfile.test34 .
  popd
  docker run -it --rm -v $(pwd):/code darglint-34 pytest
  ```



  If you would like to tackle an issue or feature, email me or comment on the
  issue to make sure it isn't already being worked on.  Contributions will
  be accepted through pull requests.  New features should include unit tests,
  and, of course, properly formatted documentation.

  Also, check out the wiki prior to updating the grammar.  It includes a
  description of darglint's parsing pipline.


pkgId: 909ca218ed87a5018124bf3e6e9c409084cd549d338ad052e6b72fde0984d2bc
name: python-darglint2
arch: src
version: 1.8.2
epoch: 0
release: 1
summary: A utility for ensuring Google-style docstrings stay up to date with the source code.
url: https://pypi.org/project/darglint2/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darglint2-1.8.2-1.src.rpm
checksum_type: sha256
description:
  A functional docstring linter which checks whether a docstring's
  description matches the actual function/method implementation.
  *Darglint2* expects docstrings to be formatted using the
  [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html),
  or [Sphinx Style Guide](https://pythonhosted.org/an_example_pypi_project/sphinx.html#function-definitions),
  or [Numpy Style Guide](https://numpydoc.readthedocs.io/en/latest/format.html).

  Feel free to submit an issue/pull request if you spot a problem or
  would like a feature in *darglint2*.

  **Table of Contents**:

  - [Project Status](#project-status)
  - [Installation](#installation)
  - [Configuration](#configuration)
  - [Usage](#usage)
  - [Scope](#scope)
  - [Sphinx](#sphinx)
  - [Numpy](#numpy)
  - [Integrations](#integrations)
  - [Flake8](#flake8)
  - [Roadmap](#roadmap)
  - [Contribution](#development-and-contributions)




  This is a renamed fork of the original
  [darglint](https://github.com/terrencepreilly/darglint) by
  [@terrencepreilly](https://github.com/terrencepreilly), and I'm maintaining it
  and accepting bugfixes.




  To install *darglint2*, use pip.

  ```bash
  pip install darglint2
  ```

  Or, clone the repository, `cd` to the directory, and

  ```bash
  pip install .
  ```



  *darglint2* can be configured using a configuration file.  The configuration
  file must be named either *.darglint2*, *.darglint*, *setup.cfg*, or *tox.ini*.  It must
  also have a section starting with the section header, `[darglint2]`.
  Finally, the configuration file must be located either in the directory
  *darglint2* is called from, or from a parent directory of that working
  directory.

  Currently, the configuration file allows us to ignore errors, to specify
  message templates, to specify the strictness of checks and to ignore common
  exceptions.



  If we would like to ignore `ExcessRaiseError`s (because we know that
  an underlying function will raise an exception), then we would add its
  error code to a file named *.darglint2*:

  ```ini
  [darglint2]
  ignore=DAR402
  ```

  We can ignore multiple errors by using a comma-separated list:

  ```ini
  [darglint2]
  ignore=DAR402,DAR103
  ```

  Instead of specifying error codes to ignore in general one can also specify a
  regex to exclude certain function names from tests. For example, the following
  configuration would disable linting on all private methods.
  ```ini
  [darglint2]
  ignore_regex=^_(.*)
  ```



  If we would like to specify a message template, we may do so as
  follows:

  ```ini
  [darglint2]
  message_template={msg_id}@{path}:{line}
  ```

  Which will produce a message such as `DAR102@driver.py:72`.

  Finally, we can specify the docstring style type using `docstring_style`
  ("google" by default):

  ```ini
  [darglint2]
  docstring_style=sphinx
  ```



  Strictness determines how lax darglint2 will be when checking docstrings.
  There are three levels of strictness available:

  - short: One-line descriptions are acceptable; anything
  more and the docstring will be fully checked.

  - long: One-line descriptions and descriptions without
  arguments/returns/yields/etc. sections will be allowed.  Anything more,
  and the docstring will be fully checked.

  - full: (Default) Docstrings will be fully checked.

  For example, if we have the following function:

  ```python
  def double(x):
      
      return x * 2
  ```

  Then the following table describes which errors will be raised for
  each of the docstrings (rows) when checked against each of the
  configurations (columns):

  ```
  ┌──────────────────────────────┬──────────────────┬────────────────┬──────────────────┐
  │ Docstring                    │  short           │  long          │  full            │
  ├──────────────────────────────┼──────────────────┼────────────────┼──────────────────┤
  │ """Doubles the argument."""  │ None             │ None           │ Missing argument │
  │                              │                  │                │ Missing return   │
  │                              │                  │                │                  │
  │                              │                  │                │                  │
  ├──────────────────────────────┼──────────────────┼────────────────┼──────────────────┤
  │ """Doubles the argument.     │ Missing argument │ None           │ Missing argument │
  │                              │ Missing return   │                │ Missing return   │
  │ Not very pythonic.           │                  │                │                  │
  │                              │                  │                │                  │
  │ """                          │                  │                │                  │
  │                              │                  │                │                  │
  ├──────────────────────────────┼──────────────────┼────────────────┼──────────────────┤
  │ """Doubles the argument.     │ Missing return   │ Missing return │ Missing return   │
  │                              │                  │                │                  │
  │ Args:                        │                  │                │                  │
  │     x: The number to double. │                  │                │                  │
  │                              │                  │                │                  │
  │ """                          │                  │                │                  │
  └──────────────────────────────┴──────────────────┴────────────────┴──────────────────┘
  ```

  In short, if you want to be able to have single-line docstrings, and check
  all other docstrings against their described parameters, you would specify

  ```ini
  [darglint2]
  strictness=short
  ```

  In your configuration file.



  We can specify a list of exceptions that don't need to be documented in the
  raises section of a docstring. For example,

  ```ini
  [darglint2]
  ignore_raise=ValueError,MyCustomError
  ```



  When *darglint2* fails unexpectedly, you can try to gather more
  information when submitting a bug by running with logging.
  For example,

  ```bash
  darglint2 --log-level=INFO unexpected_failures.py
  ```

  *Darglint2* accepts the levels, `DEBUG`, `INFO`, `WARNING`, `ERROR`, and
  `CRITICAL`.







  Given a python source file, `serializers.py`, you would check the docstrings
  as follows:

  ```bash
  darglint2 serializers.py
  ```

  You can give an optional verbosity setting to *darglint2*.  For example,

  ```bash
  darglint2 -v 2 *.py
  ```

  Would give a description of the error along with information as to this
  specific instance.  The default verbosity is 1, which gives the filename,
  function name, line number, error code, and some general hints.

  To use an arbitrary error format, you can pass a message template, which
  is a python format string.  For example, if we pass the message
  template

  ```bash
  darglint2 -m "{path}:{line} -> {msg_id}" darglint2/driver.py
  ```

  Then we would get back error messages like

  ```bash
  darglint2/driver.py :61 -> DAR101
  ```

  The following attributes can be passed to the format string:
  - *line*: The line number,
  - *msg*: The error message,
  - *msg_id*: The error code,
  - *obj*: The function/method name,
  - *path*: The relative file path.

  The message template can also be specified in the configuration file
  as the value `message_template`.

  *darglint2* is particularly useful when combined with the utility, `find`.
  This allows us to check all of the files in our project at once.  For example,
  when eating my own dogfood (as I tend to do), I invoke *darglint2* as follows:

  ```bash
  find . -name "*.py" | xargs darglint2
  ```

  Where I'm searching all files ending in ".py" recursively from the
  current directory, and calling *darglint2* on each one in turn.



  You can ignore specific errors in a particular docstring.  The syntax
  is much like that of *pycodestyle*, etc.  It generally takes the from
  of:

  ```python

  ```

  Where `<error>` is the particular error to ignore (`DAR402`, or `DAR201`
  for example), and `<argument>` is what (if anything) the ignore
  statement refers to (if nothing, then it is not specified).

  Let us say that we want to ignore a missing return statement
  in the following docstring:

  ```python
  def we_dont_want_a_returns_section():
    """Return the value, 3.

    

    """
    return 3
  ```

  We put the `noqa` anywhere in the top level of the docstring.
  However, this won't work if we are missing something more specific,
  like a parameter.  We may not want to ignore all missing parameters,
  either, just one particular one.  For example, we may be writing a
  function that takes a class instance as self. (Say, in a bound *celery*
  task.) Then we would do something like:

  ```python
  def a_bound_function(self, arg1):
    """Do something interesting.

    Args:
      arg1: The first argument.

    

    """
    arg1.execute(self)
  ```

  So, the argument comes to the right of the error.

  We may also want to mark excess documentation as being okay.  For example,
  we may not want to explicitly catch and raise a `ZeroDivisionError`.  We
  could do the following:

  ```python
  def always_raises_exception(x):
      """Raise a zero division error or type error.o

      Args:
        x: The argument which could be a number or could not be.

      Raises:
        ZeroDivisionError: If x is a number.  # noqa: DAR402
        TypeError: If x is not a number.  # noqa: DAR402

      """
      x / 0
  ```

  So, in this case, the argument for `noqa` is really all the way to
  the left.  (Or whatever description we are parsing.)  We could also
  have put it on its own line, as `# noqa: DAR402 ZeroDivisionError`.



  Darglint2 parses type annotations in docstrings, and can, optionally,
  compare the documented type to the actual type annotation.  This can
  be useful when migrating a codebase to use type annotations.

  In order to make these comparisons, Darglint2 only accepts types
  accepted by Python (see [PEP 484](https://www.python.org/dev/peps/pep-0484/).)
  That is, it does not accept parentheses in type signatures. (If
  parentheses are used in the type signature, Darglint2 will mark that
  argument as missing.  See Issue #90.)




  - *DAR001*: The docstring was not parsed correctly due to a syntax error.
  - *DAR002*: An argument/exception lacks a description
  - *DAR003*: A line is under-indented or over-indented.
  - *DAR004*: The docstring contains an extra newline where it shouldn't.
  - *DAR005*: The item contains a type section (parentheses), but no type.
  - *DAR101*: The docstring is missing a parameter in the definition.
  - *DAR102*: The docstring contains a parameter not in function.
  - *DAR103*: The docstring parameter type doesn't match function.
  - *DAR104*: (disabled) The docstring parameter has no type specified
  - *DAR105*: The docstring parameter type is malformed.
  - *DAR201*: The docstring is missing a return from definition.
  - *DAR202*: The docstring has a return not in definition.
  - *DAR203*: The docstring parameter type doesn't match function.
  - *DAR301*: The docstring is missing a yield present in definition.
  - *DAR302*: The docstring has a yield not in definition.
  - *DAR401*: The docstring is missing an exception raised.
  - *DAR402*: The docstring describes an exception not explicitly raised.
  - *DAR501*: The docstring describes a variable which is not defined.

  The number in the hundreds narrows the error by location in the docstring:

  - 000: Syntax, formatting, and style
  - 100: Args section
  - 200: Returns section
  - 300: Yields section
  - 400: Raises section
  - 500: Variables section

  You can enable disabled-by-default exceptions in the configuration file
  using the `enable` option.  It accepts a comma-separated list of error
  codes.

  ```ini
  [darglint2]
  enable=DAR104
  ```



  Darglint2's primary focus is to identify incorrect and missing documentationd
  of a function's signature. Checking style is a stretch goal, and is supported
  on a best-effort basis.  Darglint2 does not check stylistic preferences expressed
  by tools in the Python Code Quality Authority (through tools such as `pydocstyle`).
  So when using Darglint2, it may be a good idea to also use `pydocstyle`, if you
  want to enforce style.  (For example, `pydocstyle` requires the short summary
  to be separated from other sections by a line break.  Darglint2 makes no such check.)



  Darglint2 can handle sphinx-style docstrings, but imposes some restrictions
  on top of the Sphinx style. For example, all fields (such as `:returns:`)
  must be the last items in the docstring.  They must be together, and all
  indents should be four spaces.  These restrictions may be loosened at a
  later date.

  To analyze Sphinx-style docstrings, pass the style flag to the command:

  ```bash
  darglint2 -s sphinx example.py
  darglint2 --docstring-style sphinx example.py
  ```

  Alternatively, you can specify the style in the configuration file using
  the setting, "docstring\_style":

  ```ini
  [darglint2]
  docstring_style=sphinx
  ```



  Darglint2 now has an initial implementation for Numpy-style docstrings.
  Similarly to Sphinx-style docstrings, you can pass a style flag to the
  command:

  ```bash
  darglint2 -s numpy example.py
  darglint2 --docstring-style numpy example.py
  ```

  Or set it in a configuration file:

  ```ini
  [darglint2]
  docstring_style=numpy
  ```

  The numpy parser and error reporter are not yet fully stabilized.
  Add issues or suggestions to the tracking bug, Issue #69.





  Darglint2 can be used in conjunction with Flake8 as a plugin.  The only
  setup necessary is to install Flake8 and Darglint2 in the same environment.
  Darglint2 will pull its configuration from Flake8. So, if you would like to
  lint Sphinx-style comments, then you should have `docstring_style=sphinx` in a
  Flake8 configuration file in the project directory.  The settings would
  be entered under the flake8 configuration, not a separate configuration
  for Darglint2.  E.g.:

  ```ini
  [flake8]
  strictness=short
  docstring_style=sphinx
  ```

  To see which options are exposed through Flake8, you can check the Flake8
  tool:

  ```bash
  flake8 --help | grep --before-context=2 Darglint2
  ```



  A plugin for SublimeLinter can be found [here](https://github.com/raddessi/SublimeLinter-contrib-darglint).
  Note that it was built for the original `darglint`, not `darglint2`, and its
  compatibility with `darglint2` is yet to be verified.



  Download [pre-commit](https://pre-commit.com/) and
  [install](https://pre-commit.com/#install) it. Once it is installed, add this
  to `.pre-commit-config.yaml` in your repository:

  ```yaml
  repos:
  -   repo: https://github.com/akaihola/darglint2
      rev: master
      hooks:
      - id: darglint2
  ```

  Then run `pre-commit install` and you're ready to go. Before commiting,
  `darglint2` will be run on the staged files. If it finds any errors, the user
  is notified and the commit is aborted. Store necessary configuration (such as
  error formatting) in `.darglint2`, `.darglint`, `setup.cfg` or `tox.ini`.




  Below are some of the features or efforts from the original `darglint` project
  at the time of forking in February 2023.  Where a milestone or
  issue is associated with the idea, it will be mentioned.  Some of these
  ideas were moonshots and may not get implemented.  They are ordered
  roughly according to priority/feasibility stated by the original author.

  - [ ] Expose command-line options through sphinx.
  - [ ] Robust logging for errors caused/encountered by *darglint2*.
  - [ ] Check class docstrings (See
        [darglint#25](https://github.com/terrencepreilly/darglint/issues/25)).
  - [ ] Autoformatting docstrings. (See
        [darglint milestone #3](https://github.com/terrencepreilly/darglint/milestone/3)).
  - [ ] Optional aggressive style checking through command line flag.
  - [ ] ALE support.
  - [ ] Syntastic support. (Syntastic is not accepting new checkers until
  their next API stabilizes, so this may take some time.)






  Install `darglint2`. First, clone the repository:

  ```bash
  git clone https://github.com/akaihola/darglint2.git
  ```

  `cd` into the directory, create a virtual environment (optional), then setup:

  ```bash
  cd darglint2/
  virtualenv -p python3.6 .env
  source .env/bin/activate
  pip install -e .
  ```

  You can install dependencies using

  ```bash
  pip install poetry
  poetry install
  ```

  You can run the tests using

  ```bash
  python setup.py test
  ```

  Or, install `pytest` manually, `cd` to the project's root directory,
  and run

  ```bash
  pytest
  ```

  This project tries to conform by the styles imposed by `pycodestyle`
  and `pydocstyle`, as well as by `darglint2` itself.


  A dockerfile exists for testing with Python3.4.  Although it's not
  officially supported (only 3.6+), it's nice to try to make minor
  version numbers support it.  You would build the dockerfile and
  test using something like

  ```bash
  pushd docker-build
  docker build -t darglint2-34 -f Dockerfile.test34 .
  popd
  docker run -it --rm -v $(pwd):/code darglint2-34 pytest
  ```



  If you would like to tackle an issue or feature, email me or comment on the
  issue to make sure it isn't already being worked on.  Contributions will
  be accepted through pull requests.  New features should include unit tests,
  and, of course, properly formatted documentation.

  Also, check out the wiki prior to updating the grammar.  It includes a
  description of darglint2's parsing pipline.


pkgId: d9a956d61b3d607b249270a8f7cb4d529cb3593e9edf74da21c80e0ba9342dc0
name: python-dargs
arch: src
version: 0.4.8
epoch: 0
release: 1
summary: Process arguments for the deep modeling project.
url: https://github.com/deepmodeling/dargs
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dargs-0.4.8-1.src.rpm
checksum_type: sha256
description:
  [![conda-forge](https://img.shields.io/conda/dn/conda-forge/dargs?color=red&label=conda-forge&logo=conda-forge)](https://anaconda.org/conda-forge/dargs)
  [![pip install](https://img.shields.io/pypi/dm/dargs?label=pip%20install&logo=pypi)](https://pypi.org/project/dargs)
  [![Documentation Status](https://readthedocs.org/projects/dargs/badge/)](https://dargs.readthedocs.io/)

  This is a minimum version for checking the input argument dict.
  It would examine argument's type,  as well as keys and types of its sub-arguments.

  A special case called *variant* is also handled,
  where you can determine the items of a dict based the value of on one of its `flag_name` key.

  There are three main methods of `Argument` class:

  - `check` method that takes a dict and see if its type follows the definition in the class
  - `normalize` method that takes a dict and convert alias and add default value into it
  - `gendoc` method that outputs the defined argument structure and corresponding docs

  There are also `check_value` and `normalize_value` that
  ignore the leading key comparing to the base version.

  When targeting to html rendering, additional anchor can be made for cross reference.
  Set `make_anchor=True` when calling `gendoc` function and use standard ref syntax in rst.
  The id is the same as the argument path. Variant types would be in square brackets.

  Please refer to test files for detailed usage.



  - [PEP 484](https://peps.python.org/pep-0484/) type annotations
  - Native integration with [Sphinx](https://github.com/sphinx-doc/sphinx), [DP-GUI](https://github.com/deepmodeling/dpgui), and [Jupyter Notebook](https://jupyter.org/)
  - JSON encoder for `Argument` and `Variant` classes
  - Generate [JSON schema](https://json-schema.org/) from an `Argument`, which can be further integrated with JSON editors such as [Visual Studio Code](https://code.visualstudio.com/)

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


pkgId: 6152d603c651235e78677f825bedcb13484e99ba82f347a72d2e78cae49cfdb3
name: python-darkdetect
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Detect OS Dark Mode from Python
url: https://pypi.org/project/darkdetect/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darkdetect-0.8.0-1.src.rpm
checksum_type: sha256
description:
  This package allows to detect if the user is using Dark Mode on:

  - [macOS 10.14+](https://support.apple.com/en-us/HT208976)
  - [Windows 10 1607+](https://blogs.windows.com/windowsexperience/2016/08/08/windows-10-tip-personalize-your-pc-by-enabling-the-dark-theme/)
  - Linux with [a dark GTK theme](https://www.gnome-look.org/browse/cat/135/ord/rating/?tag=dark).

  The main application of this package is to detect the Dark mode from your GUI Python application (Tkinter/wx/pyqt/qt for python (pyside)/...) and apply the needed adjustments to your interface. Darkdetect is particularly useful if your GUI library **does not** provide a public API for this detection (I am looking at you, Qt). In addition, this package does not depend on other modules or packages that are not already included in standard Python distributions.




  ```
  import darkdetect

  >>> darkdetect.theme()
  'Dark'

  >>> darkdetect.isDark()
  True

  >>> darkdetect.isLight()
  False
  ```
  It's that easy.

  You can create a dark mode switch listener daemon thread with `darkdetect.listener` and pass a callback function. The function will be called with string "Dark" or "Light" when the OS switches the dark mode setting.

  ``` python
  import threading
  import darkdetect



  t = threading.Thread(target=darkdetect.listener, args=(print,))
  t.daemon = True
  t.start()
  ```



  The preferred channel is PyPI:
  ```
  pip install darkdetect
  ```

  Alternatively, you are free to vendor directly a copy of Darkdetect in your app. Further information on vendoring can be found [here](https://medium.com/underdog-io-engineering/vendoring-python-dependencies-with-pip-b9eb6078b9c0).



  To enable the macOS listener, additional components are required, these can be installed via:
  ```bash
  pip install darkdetect[macos-listener]
  ```



  - This software is licensed under the terms of the 3-clause BSD License.
  - This package can be installed on any operative system, but it will always return `None` unless executed on a OS that supports Dark Mode, including older versions of macOS and Windows.
  - On macOS, detection of the dark menu bar and dock option (available from macOS 10.10) is not supported.
  - [Details](https://stackoverflow.com/questions/25207077/how-to-detect-if-os-x-is-in-dark-mode) on the detection method used on macOS.
  - [Details](https://askubuntu.com/questions/1261366/detecting-dark-mode#comment2132694_1261366) on the experimental detection method used on Linux.


pkgId: 70cb288cf9cbfabd15d46297f2585ee84c8fa6e820d0f86544a778e78116ad1e
name: python-darkfeed
arch: src
version: 1.5
epoch: 0
release: 1
summary: A CLI and GUI parser for data from Dark Feed
url: https://github.com/santiag02/DarkFeed
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darkfeed-1.5-1.src.rpm
checksum_type: sha256
description:
  This is a simples parser for all great data available with the API key of [Dark Feed](https://darkfeed.io/).

  The idea is create functions to return data available in the interface and bring more insights, like:
  - Top 10 countries this year
  - Top 5 sectors in Brazil
  - Top 3 ransomwares in latam
  - Count of victims in America of the North in the last month
  - Filters in a time range
  - . . .



  ```bash
  pip install darkfeed
  ```



  If you don't know how run it you can use the argument `-h`, like this:

  ```bash
  darkfeed -h
  usage: darkfeed [-h] [-i] [-d] [-a AFTER] [-b BEFORE] [-c COUNTRIES] [-lc] [-s SECTORS] [-ls] [-r RANSOMWARES] [-lr] [-v VICTIM] [-top_c TOP_COUNTRIES] [-top_s TOP_SECTORS]
                  [-top_r TOP_RANSOMWARES] [-json] [-count] [-xlsx] [-n] [-nr] [-g]

  Ransomware statistics - Kudos DarkFeed (darkfeed.io).

  options:
    -h, --help            show this help message and exit
    -i, --init            First step. Pass your API key.
    -d, --download_base   To save/update base to a file
    -a AFTER, --after AFTER
                          Date started to collecting published victims. Format: YYYY-MM-DD
    -b BEFORE, --before BEFORE
                          Date finished to collecting published victims. Format: YYYY-MM-DD
    -c COUNTRIES, --country COUNTRIES
                          Country filer, write how many countries do you want split by [,]. You could also use: latam, south_america, central_america, north_america, europe, asia, africa or
                          oceania
    -lc, --list_countries
                          List all possible strings for countries
    -s SECTORS, --sectors SECTORS
                          Sector filter, choose the sectors of your interest. You can choose more than one split then with [,]
    -ls, --list_sectors   List all possible sectors.
    -r RANSOMWARES, --ransomwares RANSOMWARES
                          Ransomware filter, choose the ransomware group of your interest. You can choose more than one split then with [,]
    -lr, --list_ransomwares
                          List all ransowmare groups in our base
    -v VICTIM, --victim VICTIM
                          Use the name or substring to search a victm.
    -top_c TOP_COUNTRIES, --top_countries TOP_COUNTRIES
                          Get the global top X countries.
    -top_s TOP_SECTORS, --top_sectors TOP_SECTORS
                          Get the global top X sectors.
    -top_r TOP_RANSOMWARES, --top_ransomwares TOP_RANSOMWARES
                          Get the global top X ransomwares.
    -json                 To format your output to json
    -count                To count the num of items
    -xlsx                 To convert data to spreadsheet / xlsx
    -n, --news            Cyber news!
    -nr, --new_ransomwares
                          Return ransomware families based in first detection in DarkFeed database. You can use arguments of date to filter the returned ransomwares. The default is last
                          month. Reliability is from 2024
    -g, --start_gui       Init a web service.
  ```

  You can mix commands to receive different outputs, like xlsx or json. The last argument will define the output.

  |![CLI](https://github.com/santiag02/DarkFeed/blob/main/media/DarkFeed_CLI.gif "CLI")|
  |:---:|
  |CLI|



  ```bash
  darkfeed -g
  ```

  |![GUI](https://github.com/santiag02/DarkFeed/blob/main/media/DarkFeed_GUI.gif "GUI")|
  |:-----:|
  |GUI|


pkgId: 9c5400dfcadecf9e1f9d7d157c4ed5704de1bb31f76e3ac157df1ad37ef8003d
name: python-darksearch
arch: src
version: 2.1.3
epoch: 0
release: 1
summary: Python API wrapper for DarkSearch (darksearch.io).
url: https://github.com/thehappydinoa/DarkSearch
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darksearch-2.1.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/darksearch?color=orange&logo=pypi&logoColor=orange)](https://pypi.org/project/darksearch/)
  [![Python Version](https://img.shields.io/badge/python-3.6%2B-blue?logo=python)](https://www.python.org/downloads/)
  [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/thehappydinoa/DarkSearch/test?label=tests)](https://github.com/thehappydinoa/DarkSearch/actions)
  [![Read the Docs](https://img.shields.io/readthedocs/darksearch/latest)](https://censys-python.readthedocs.io/en/stable/?badge=stable)
  [![License](https://img.shields.io/github/license/thehappydinoa/DarkSearch)](LICENSE)

  Python API wrapper for DarkSearch ([darksearch.io](https://darksearch.io/)). Python 3.6+ is currently supported.



  ```bash
  pip install darksearch
  ```



  - [Documentation](https://darksearch.readthedocs.io/)



  All contributions (no matter how small) are always welcome.



  ```bash
  git clone git@github.com:thehappydinoa/DarkSearch.git
  poetry install
  ```



  ```bash
  pytest
  ```



  ```bash
  poetry build
  poetry publish
  ```



  This software is licensed under [MIT](LICENSE)


pkgId: 5647592e2190060237274debbc9f21353b9023312af2d757ae4d1880207d172e
name: python-darkseid
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: A library to interact with comic archives
url: https://github.com/Metron-Project/darkseid
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darkseid-5.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/darkseid.svg)](https://pypi.org/project/darkseid/)
  [![PyPI - Python](https://img.shields.io/pypi/pyversions/darkseid.svg)](https://pypi.org/project/darkseid/)
  [![Ruff](https://img.shields.io/badge/Linter-Ruff-informational)](https://github.com/charliermarsh/ruff)
  [![Pre-Commit](https://img.shields.io/badge/Pre--Commit-Enabled-informational?logo=pre-commit)](https://github.com/pre-commit/pre-commit)

  A [Python](https://www.python.org/) library to interact with comic archives.



  ```bash
  pip install darkseid
  ```



  [Read the project documentation](https://darkseid.readthedocs.io/en/stable/?badge=latest)



  Please use the
  [GitHub issue tracker](https://github.com/Metron-Project/darkseid/issues) to
  submit bugs or request features.


pkgId: 2ba929614d02d2b6d45f63ae1605262d17b6bbc360e3eeff0a73a77e0a44d441
name: python-darkskylib
arch: src
version: 0.3.91
epoch: 0
release: 1
summary: The Dark Sky API wrapper
url: https://github.com/lukaskubis/darkskylib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darkskylib-0.3.91-1.src.rpm
checksum_type: sha256
description:
  This  library for the `Dark Sky
  API <https://darksky.net/dev/docs>`__ provides access to detailed
  weather information from around the globe.


pkgId: 3b0333276089451b24e34d51024e1fc4f8c8ba22135b26f71bd10063e5aef264
name: python-dars
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Клиент для сервиса отдачи информации и документов ЕИС
url: https://gitverse.ru/gosplan-v2/dars
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dars-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Сервис отдачи информации и документов ЕИС (сокр. СОИ) - это сервис для доступа к документам, размещенным на официальном сайте ЕИС.

  > С 01.01.2025 выгрузка документов ЕИС на FTP сервер будет прекращена и доступ будет осуществляться только через COИ.

  В ЕИС опубликована [инструкция](https://zakupki.gov.ru/epz/main/public/download/downloadDocument.html?id=40288) по работе с данным сервисом.

  Настоящий проект представляет собой клиентский модуль на языке Python для взаимодействия с СОИ.



  Проект dars версии **v1** реализует обмен с сервисом *getDocsMIS2*, который с октября 2024г прекратил свою деятельность.
  Вместо него запущен новый сервис *getDocsLE2*. Дальнейшее развитие проекта *dars* будет направлено на реализацию
  обмена с  *getDocsLE2* в рамках версии **v2**.



  Установка

  ```bash
  pip install dars
  ```

  Использование CLI

  ```bash
  dars config edit

  dars getnsirequest --base=fz44  --nsicode=nsiOrganization --nsikind=all




  dars getpublicdocsrequest \
    --base=fz44 \
    --subsystemtype=PRIZ \     # тип подсистемы (см. раздел "Типы подсистем")
    --monthinfo=2024-04 \      # запрос на заданный месяц
    --exactdate=2024-04-30 \   # запрос на заданный день
    --todayinfo=0-12 \         # запрос на заданный час
    --offsettimezone=+3 \
    --organizations-data=/path/to/file/with/regNum.csv \
    --regnum=regnum1 \
    --regnum=regnum2 \
    --regnum=regnum3

  dars getpublicdocsrequest \
    --base=fz223 \
    --subsystemtype=RI223 \    # тип подсистемы (см. раздел "Типы подсистем")
    --monthinfo=2024-04 \      # запрос на заданный месяц
    --exactdate=2024-04-30 \   # запрос на заданный день
    --todayinfo=0-12 \         # запрос на заданный час
    --offsettimezone=UTC+03:00 \
    --organizations-data=/path/to/file/with/inns-with-kpp.csv \
  ```

  Использование модуля

  ```python
  import dars

  s3 = {
      "access_key": "key",
      "secret_key": "secret",
      "endpoint_url": "http://localhost:9002",
      "bucket": "drs",
      "region": "ru-1"
  }
  client = dars.client(sender='myapp', s3=s3)

  keys = client.getNsiRequest(
                  base='fz44',
                  nsicode='nsiOrganization',
                  nsikind='all',
  		prefix='/fz44/nsi/nsiOrganization'
                  )
  ```



  Тип подсистемы используюется в команде `dars getpublicdocsrequest --subsystemtype=SUBSYSTEMTYPE`.

  Перечень типов подсистем в соответствии со *схемой 14.2 интеграция 2*

  ```

  BTK - Библиотека типовых контрактов;
  PRIZ - Подсистема размещения извещений (без протоколов со сведениями об участниках);
  PRIZP - Подсистема размещения извещений (протоколы со сведениями об участниках);
  RPEC - Подсистема заключения контрактов;
  RPGZ - Реестр планов графиков с 2020 года;
  RPNZ - Реестр правил нормирования закупок;
  RDI - Реестр дополнительной информации о закупках и контрактах;
  RGK - реестр контрактов;
  RBG - реестр независимой гарантий;
  EA - Электронное актирование;
  UR - Односторонний отказ;
  RJ - Реестр жалоб;
  RPP - Реестр плановых проверок;
  RVP - Реестр внеплановых проверок;
  RRK - Реестр результатов контроля;
  RRA - Реестр результатов аудита;
  RNP - Реестр недобросовестных поставщиков;
  RKPO - Реестр квалифицированных подрядных организаций;
  PPRF615 - Реестр извещений и протоколов 615;
  RD615 - Реестр договоров 615;
  LKOK - Личный кабинет органа контроля;
  OZ - Отчеты заказчика


  RD223 - Реестр договоров;
  RJ223 - Реестр жалоб;
  RPP223 - Реестр плановых проверок;
  RPZ223 - Реестр планов закупок;
  RI223 - Реестр извещений о закупках;
  RZ223 - Реестр заказчиков;
  OV223 - Информация об объеме выручки;
  TPOZ223 - Типовые положения о закупках;
  POZ223 - Положения о закупках;
  RNP223 - Реестр недобросовестных поставщиков;
  OD223 - Отчетность по договорам;
  IPVP223 - Годовые отчеты ИПВП;
  MSP223 - Годовые отчеты МСП;
  POM223 - Подсистема оценки и мониторинга;
  RBG223 - Реестр независимых гарантий;
  TRU223 - Перечни ТРУ
  ```





  В файле схемы *GetDocsWS/GetDocsMIS/GetDocsMIS-ws-api.xsd* имеется схема *getPublicDocsResponse*,
  которая описывает ответ от СОИ с публичными документами: закупки, контракты и т.п.

  До версии 14.1.7 интеграция 1 в схеме *getPublicDocsResponse* имеется ошибка:
  *dataInfo/orgzanizations44DocsInfo* вместо *dataInfo/organizations44DocsInfo*. Аналогично для 223.


pkgId: 0324d879f0e16bb0fce69d128fd20962c1ab830d3c93a6fb5915333db25c34cb
name: python-dart
arch: src
version: 1.0
epoch: 0
release: 1
summary: Turn URL variables into models.
url: https://github.com/landakram/dart
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dart-1.0-1.src.rpm
checksum_type: sha256
description:
  Dart turns URL variables into database models with a decorator.
  That means you can do something like this:
      @app.route('/user/<user_id>/tracks', methods=['GET'])
      @dart.inject(User, 'user', from_var='user_id')
      def user_tracks(user=None):
          return jsonify(user.tracks)
  If you're smart, you might have a decorator that checks user authorization,
  something like ``@login_required``. You can compose Dart with other decorators
  to simplify logic, while still keeping your code readable and concise:
      def login_required(view):
          @functools.wraps(view)
          @dart.inject(User, 'user', from_var='user_id')
          @dart.inject(User, 'current_user', from_val=lambda: session['user_id'])
          def decorated_view(user=None, current_user=None, *args, **kwargs):
              if current_user != user:
                  abort(403)
              else:
                  return view(user=user, *args, **kwargs)
          return decorated_view
      @login_required
      def view(user=None):
          return '{} did it!'.format(user.name)
  Of course, Dart isn't just a Flask. It's literally just a decorator that
  takes a keyword arg or lambda expression and queries the model class using it as
  the primary key. That means you can use the Dart decorator with any function.
  For more info, check out the source code -- it's 27 lines.


pkgId: c1ba2b20218176181acff41d95b9af13e91173df4bf1a0d496d0298d908c7527
name: python-dart-fss
arch: src
version: 0.4.10
epoch: 0
release: 1
summary: Web-scraping https://dart.fss.or.kr
url: https://pypi.org/project/dart-fss/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dart-fss-0.4.10-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dart-fss.svg)](https://pypi.org/project/dart-fss/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dart-fss.svg)
  ![Build Status](https://bit.ly/3fufevG)
  [![Coverage](https://codecov.io/gh/josw123/dart-fss/branch/master/graphs/badge.svg)](https://codecov.io/gh/josw123/dart-fss)
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/7ebb506ba99d4a22b2bbcda2d85b3bde)](https://www.codacy.com/app/josw123/dart-fss?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=josw123/dart-fss&amp;utm_campaign=Badge_Grade)

  대한민국 금융감독원에서 운영하는 다트([DART](https://dart.fss.or.kr)) 사이트 크롤링 및 재무제표 추출을 위한 라이브러리

  - Source code: https://github.com/josw123/dart-fss



  -   [Open DART](https://opendart.fss.or.kr/)의 오픈 API를 이용한 전자공시 조회
  -   [DART](https://dart.fss.or.kr)의 전자공시 정보를 이용한 재무제표 추출



  - Open DART 지원 / 신규 Open DART API Key 필요
  - Python 3.7 이상 지원
  - Documentation: https://dart-fss.readthedocs.io/

  ``` bash
  pip install -U dart-fss
  ```





  -  [OPEN DART API 신청](https://opendart.fss.or.kr/)
  -  환경 변수 DART_API_KEY 설정 또는 패키지 사용전 아래와 같이 설정



  ```python
  import dart_fss as dart


  api_key='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
  dart.set_api_key(api_key=api_key)


  corp_list = dart.get_corp_list()


  samsung = corp_list.find_by_corp_name('삼성전자', exactly=True)[0]


  fs = samsung.extract_fs(bgn_de='20120101')


  fs.save()
  ```



  -   Open DART 및 DART 홈페이지의 경우 분당 1000회 이상 요청시 서비스가 제한될 수 있음
  -   [관련 공지사항](https://bit.ly/3cjF3Np): [FAQ]->[오픈API 이용한도는 어떻게 되나요?]


  This project is licensed under the MIT License


pkgId: c6df00ad4cdfe58b93247ff807c952ef8e81c7d452009aa469ebe48102698945
name: python-dart-tools
arch: src
version: 0.6.9
epoch: 0
release: 1
summary: The Dart CLI and Python Library
url: https://www.itsdart.com/?nr=1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dart-tools-0.6.9-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <h1>Dart Tools</h1>
    <p>
      <a href="https://pypi.org/project/dart-tools"><img src="https://img.shields.io/pypi/v/dart-tools.svg" alt="PyPI"></a>
      <a href="tox.ini"><img src="https://img.shields.io/pypi/pyversions/dart-tools" alt="Supported Python Versions"></a>
      <a href="LICENSE"><img src="https://img.shields.io/github/license/its-dart/dart-tools" alt="License"></a>
    </p>
  </div>

  [Dart](https://itsdart.com?nr=1) is Project Management powered by AI.

  `dart-tools` is the Dart CLI and Python Library. It enables direct integration with Dart through a terminal CLI or through Python.


  - [Setup](#setup)
  - [Using the CLI](#using-the-cli)
  - [Using the Python Library](#using-the-python-library)
  - [Advanced Usage](#advanced-usage)
  - [Help and Resources](#help-and-resources)




  In the terminal, install by running
  ```bash
  pip install dart-tools
  ```




  Start off by setting up authentication with
  ```bash
  dart login
  ```

  Then, you can create a new task with a command along the lines of
  ```bash
  dart createtask "Update the landing page" -p0 --tag marketing
  ```
  which will make a new task called 'Update the landing page' with priority 'Critical' (i.e. P0) and with the 'marketing' tag.

  You can explore all of these options and many more with `dart --help` or the more specific help for subcommands, in this case `dart createtask --help`.

  Another common workflow is to updating a preexisting task. To do this, run something like
  ```bash
  dart updatetask [DUID] -s Done
  ```
  This command will mark the referenced task 'Done'. Here `[DUID]` is meant to be replaced (including the brackets) with the 'Dart ID' of an existing task. You can get a DUID from any existing task in a number of ways, such as by copying it from the end of a task's URL or by clicking the '...' button in a task page in Dart and then choosing 'Copy ID'.




  First, set up authentication. Run `dart login` in the terminal for an interactive process, or visit [your Dart profile](https://app.itsdart.com/?settings=account) and then run `dart.login(token)` or save the token into the `DART_TOKEN` environment variable.

  Then, you can run something like
  ```python
  import os
  from dart import create_task, is_logged_in, update_task


  is_logged_in(should_raise=True)



  new_task = create_task(
      "Update the landing page", priority_int=0, tag_titles=["marketing"]
  )


  update_task(new_task.duid, status_title="Done")
  ```




  Almost anything that can be done in Dart can be done with the Python library, but there are not convenient wrapper functions for everything.
  For most advanced usage, the best thing to do is to [get in touch with us](mailto:support@itsdart.com) and we can help.

  However, if you want to explore on your own, the client is well-typed, so you can simply explore the code to see what is possible.
  All updates will go through the the `dart.transact` function.

  As an example, you could run something akin to `update_task` with
  ```python
  from dart import (
      Dart,
      Operation,
      OperationKind,
      OperationModelKind,
      TaskUpdate,
      TransactionKind,
  )


  dart = Dart()


  task_update = TaskUpdate(
      duid="[DUID]",
      size=5,
  )
  task_update_op = Operation(
      model=OperationModelKind.TASK,
      kind=OperationKind.UPDATE,
      data=task_update,
  )


  response = dart.transact([task_update_op], TransactionKind.TASK_UPDATE)
  ```




  - [Homepage](https://www.itsdart.com/?nr=1)
  - [Web App](https://app.itsdart.com/)
  - [Help Center](https://help.itsdart.com/)
  - [Bugs and Features](https://github.com/its-dart/dart-tools/issues)
  - [Library Source](https://github.com/its-dart/dart-tools/)
  - [Chat on Discord](https://discord.gg/RExv8jEkSh)
  - Email us at [support@itsdart.com](mailto:support@itsdart.com)

rpm_license:
  MIT License  Copyright (c) 2023 Dart  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: 9c2a5670eb28e8cfdbb7f6a24c481b98de4069389d7aafcf3072c1251959a93b
name: python-dartcms
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: DartCMS - open-source content management system for Django
url: https://github.com/astrikov-d/dartcms
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dartcms-0.2.1-1.src.rpm
checksum_type: sha256
description:
  DartCMS is an open-source content management system based on the popular Django Framework. It is friendly for developers and end-users.


pkgId: 0c039b2b9d710b1e863305a6e300728605c65c6aceb0857764f0c27ee3e644a3
name: python-darth-d
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A simple to use image generator based on OpenAIs DALL-E
url: https://github.com/haesleinhuepf/darth-d/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darth-d-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/pypi/l/darth-d.svg?color=green)](https://github.com/haesleinhuepf/darth-d/raw/main/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/darth-d.svg?color=green)](https://pypi.org/project/darth-d)
  [![Python Version](https://img.shields.io/pypi/pyversions/darth-d.svg?color=green)](https://python.org)
  [![tests](https://github.com/haesleinhuepf/darth-d/workflows/tests/badge.svg)](https://github.com/haesleinhuepf/darth-d/actions)
  [![codecov](https://codecov.io/gh/haesleinhuepf/darth-d/branch/master/graph/badge.svg)](https://codecov.io/gh/haesleinhuepf/darth-d)
  [![Development Status](https://img.shields.io/pypi/status/darth-d.svg)](https://en.wikipedia.org/wiki/Software_release_life_cycle#Alpha)
  [![napari hub](https://img.shields.io/endpoint?url=https://api.napari-hub.org/shields/darth-d)](https://napari-hub.org/plugins/darth-d)

  A simple to use image generator based on [OpenAIs DALL-E 2/3](https://openai.com/dall-e-2).
  It comes as [napari](https://napari.org/) plugin and has a Python interface.
  You need an [OpenAI API KEY](https://openai.com/blog/openai-api/) to use it.

  Using some of the functions on scientific images could be seen as scientific misconduct. Handle these functions with care.

  ![](https://github.com/haesleinhuepf/darth-d/raw/main/docs/images/replace_screencast.gif)





  You can generate images from text prompts in Python like this ([see this notebool](https://github.com/haesleinhuepf/darth-d/blob/main/demo/demo_darth-d.ipynb)).

  ```
  from darth_d import create
  ```

  ```
  image = create("an image of a cat")

  image
  ```

  ![](https://github.com/haesleinhuepf/darth-d/raw/main/docs/images/jupyter_screenshot.png)

  You can also vary images ([see this notebook](https://github.com/haesleinhuepf/darth-d/blob/main/demo/demo_vary.ipynb)):
  ```
  from darth_d import vary

  output_image = vary(input_image)
  ```

  ![](https://github.com/haesleinhuepf/darth-d/raw/main/docs/images/vary_screenshot.png)

  Replacing regions in images is also possible. Note: Using this function on scientific images could be seen as scientific misconduct. Handle this function with care.



  To generate images in Napari, click the `Tools > Generate > Image` menu. You can for example enter the prompt
  "a professional comic with white background showing a cat having an idea. the idea is visualized using a light bulb.

  ![](https://github.com/haesleinhuepf/darth-d/raw/main/docs/images/napari_screenshot.png)




  ```
  pip install darth-d
  ```

  If you want to use it from napari, please also install napari and the [tools menu](https://github.com/haesleinhuepf/napari-tools-menu):

  ```
  mamba install napari pyqt napari-tools-menu -c conda-forge
  ```



  * https://github.com/kephale/napari-stable-diffusion
  * https://github.com/seankmartin/napari-stable-diffusion



  The `darth-d` is developed in the open because we believe in the open source community. Feel free to drop feedback as [github issue](https://github.com/haesleinhuepf/darth-d) or via [image.sc](https://image.sc)



  Contributions are very welcome.



  Distributed under the terms of the [BSD-3] license,
  "darth-d" is free and open source software

  [BSD-3]: http://opensource.org/licenses/BSD-3-Clause


pkgId: f5804ae3ce0002b1cb238f31916b8375da2b5508f31928c147c0e594848b591a
name: python-dartmouth-langchain
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: LangChain components for Dartmouth-hosted models.
url: https://github.com/Dartmouth-Libraries/dartmouth-langchain
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dartmouth-langchain-0.2.7-1.src.rpm
checksum_type: sha256
description:
  LangChain components for Dartmouth-hosted models.


  The `dartmouth_langchain` package has been renamed to `langchain_dartmouth`, to conform with the existing third-party packages in the LangChain ecosystem. Versions higher than 0.2.7 will only be released under [the new name](https://pypi.org/project/langchain-dartmouth/).




  1. Install the package:

  ```
  pip install dartmouth-langchain
  ```

  2. Obtain a Dartmouth API key from [developer.dartmouth.edu](https://developer.dartmouth.edu/)
  3. Store the API key as an environment variable called `DARTMOUTH_API_KEY`:
  ```
  export DARTMOUTH_API_KEY=<your_key_here>
  ```



  This library provides an integration of Darmouth-hosted generative AI resources with [the LangChain framework](https://python.langchain.com/v0.1/docs/get_started/introduction).

  There are three main components currently implemened:

  - Large Language Models
  - Embedding models
  - Reranking models

  All of these components are based on corresponding LangChain base classes and can be used seamlessly wherever the corresponding LangChain objects can be used.





  There are two kinds of Large Language Models (LLMs) hosted by Dartmouth:

  - Base models without instruction tuning (require no special prompt format)
  - Instruction-tuned models (also known as Chat models) requiring [specific prompt formats](https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3/)

  Using a Dartmouth-hosted base language model:

  ```{python}
  from dartmouth_langchain.llms import DartmouthLLM

  llm = DartmouthLLM(model_name="codellama-13b-hf")

  response = llm.invoke("Write a Python script to swap two variables.")
  print(response)
  ```

  Using a Dartmouth-hosted chat model:

  ```{python}
  from dartmouth_langchain.llms import ChatDartmouth


  llm = ChatDartmouth(model_name="llama-3-8b-instruct")

  response = llm.invoke("Hi there!")

  print(response.content)
  ```
  > **Note**: The required prompt format is enforced automatically when you are using `ChatDartmouth`.



  Using a Dartmouth-hosted embeddings model:

  ```{python}
  from dartmouth_langchain import DartmouthEmbeddingsModel


  embeddings = DartmouthEmbeddingsModel()

  embeddings.embed_query("Hello? Is there anybody in there?")
  ```



  Using a Dartmouth-hosted reranking model:

  ```{python}
  from dartmouth_langchain.retrievers.document_compressors import DartmouthReranker
  from langchain.docstore.document import Document


  docs = [
      Document(page_content="Deep Learning is not..."),
      Document(page_content="Deep learning is..."),
      ]

  query = "What is Deep Learning?"
  reranker = DartmouthReranker(model_name="bge-reranker-v2-m3")
  ranked_docs = reranker.compress_documents(query=query, documents=docs)

  print(ranked_docs)
  ```




  For a list of available models, check the documentation of the RESTful [Dartmouth AI API](https://ai.dartmouth.edu/openapi/index.html).



  <table >
  <tbody>
    <tr>
      <td style="padding:0px;border-width:0px;vertical-align:center">
      Created by Simon Stone for Dartmouth College Libraries under <a href="https://creativecommons.org/licenses/by/4.0/">Creative Commons CC BY-NC 4.0 License</a>.<br>For questions, comments, or improvements, email <a href="mailto:researchdatahelp@groups.dartmouth.edu">Research Data Services</a>.
      </td>
      <td style="padding:0 0 0 1em;border-width:0px;vertical-align:center"><img alt="Creative Commons License" src="https://i.creativecommons.org/l/by/4.0/88x31.png"/></td>
    </tr>
  </tbody>
  </table>

  Except where otherwise noted, the example programs are made available under the OSI-approved MIT license.


pkgId: 603b8c02002fcf730d4b23f1c75afbd7454b9aaac0ba455ec73c49e6fe7f4ee0
name: python-dartrig
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: dartrig api wrapper
url: https://github.com/cheddars/dart_rigger
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dartrig-0.2.1-1.src.rpm
checksum_type: sha256
description:
  API Reference: https://opendart.fss.or.kr/guide/detail.do?apiGrpCd=DS001&apiId=2019001


  - Y : 유가
  - K : 코스닥
  - N : 코넥스
  - E : 기타


  - 유 : 본 공시사항은 한국거래소 유가증권시장본부 소관임
  - 코 : 본 공시사항은 한국거래소 코스닥시장본부 소관임
  - 채 : 본 문서는 한국거래소 채권상장법인 공시사항임
  - 넥 : 본 문서는 한국거래소 코넥스시장 소관임
  - 공 : 본 공시사항은 공정거래위원회 소관임
  - 연 : 본 보고서는 연결부분을 포함한 것임
  - 정 : 본 보고서 제출 후 정정신고가 있으니 관련 보고서를 참조하시기 바람
  - 철 : 본 보고서는 철회(간주)되었으니 관련 철회신고서(철회간주안내)를 참고하시기 바람



  ```python
  from dartrig import DartAPI

  keys = [
      "{YOUR_API_KEY_01}",
      "{YOUR_API_KEY_02}"
  ]

  dart = DartAPI(keys=keys)


  dart.get_disclosure_list(end_de='20210331')
  ```


pkgId: 96e3f7bdeb05b06fca9474fbfee6424c78982bded6f74103bba6bd514466fad4
name: python-darts
arch: src
version: 0.30.0
epoch: 0
release: 1
summary: A python library for easy manipulation and forecasting of time series.
url: https://unit8co.github.io/darts/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darts-0.30.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/u8darts.svg)](https://badge.fury.io/py/darts)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/u8darts-all.svg)](https://anaconda.org/conda-forge/u8darts-all)
  ![Supported versions](https://img.shields.io/badge/python-3.8+-blue.svg)
  [![Docker Image Version (latest by date)](https://img.shields.io/docker/v/unit8/darts?label=docker&sort=date)](https://hub.docker.com/r/unit8/darts)
  ![GitHub Release Date](https://img.shields.io/github/release-date/unit8co/darts)
  ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/unit8co/darts/release.yml?branch=master)
  [![Downloads](https://pepy.tech/badge/darts)](https://pepy.tech/project/darts)
  [![Downloads](https://pepy.tech/badge/u8darts)](https://pepy.tech/project/u8darts)
  [![codecov](https://codecov.io/gh/unit8co/darts/branch/master/graph/badge.svg?token=7F1TLUFHQW)](https://codecov.io/gh/unit8co/darts)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![Join the chat at https://gitter.im/u8darts/darts](https://badges.gitter.im/u8darts/darts.svg)](https://gitter.im/u8darts/darts?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  **Darts** is a Python library for user-friendly forecasting and anomaly detection
  on time series. It contains a variety of models, from classics such as ARIMA to
  deep neural networks. The forecasting models can all be used in the same way,
  using `fit()` and `predict()` functions, similar to scikit-learn.
  The library also makes it easy to backtest models,
  combine the predictions of several models, and take external data into account.
  Darts supports both univariate and multivariate time series and models.
  The ML-based models can be trained on potentially large datasets containing multiple time
  series, and some of the models offer a rich support for probabilistic forecasting.
  Darts also offers extensive anomaly detection capabilities.
  For instance, it is trivial to apply PyOD models on time series to obtain anomaly scores,
  or to wrap any of Darts forecasting or filtering models to obtain fully
  fledged anomaly detection models.

  * [Quickstart](https://unit8co.github.io/darts/quickstart/00-quickstart.html)
  * [User Guide](https://unit8co.github.io/darts/userguide.html)
  * [API Reference](https://unit8co.github.io/darts/generated_api/darts.html)
  * [Examples](https://unit8co.github.io/darts/examples.html)

  * [Introductory Blog Post](https://medium.com/unit8-machine-learning-publication/darts-time-series-made-easy-in-python-5ac2947a8878)
  * [Introduction video (25 minutes)](https://youtu.be/g6OXDnXEtFA)

  * [Training Models on Multiple Time Series](https://medium.com/unit8-machine-learning-publication/training-forecasting-models-on-multiple-time-series-with-darts-dc4be70b1844)
  * [Using Past and Future Covariates](https://medium.com/unit8-machine-learning-publication/time-series-forecasting-using-past-and-future-external-data-with-darts-1f0539585993)
  * [Temporal Convolutional Networks and Forecasting](https://medium.com/unit8-machine-learning-publication/temporal-convolutional-networks-and-forecasting-5ce1b6e97ce4)
  * [Probabilistic Forecasting](https://medium.com/unit8-machine-learning-publication/probabilistic-forecasting-in-darts-e88fbe83344e)
  * [Transfer Learning for Time Series Forecasting](https://medium.com/unit8-machine-learning-publication/transfer-learning-for-time-series-forecasting-87f39e375278)
  * [Hierarchical Forecast Reconciliation](https://medium.com/unit8-machine-learning-publication/hierarchical-forecast-reconciliation-with-darts-8b4b058bb543)

  We recommend to first setup a clean Python environment for your project with Python 3.8+ using your favorite tool
  ([conda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html "conda-env"),
  [venv](https://docs.python.org/3/library/venv.html), [virtualenv](https://virtualenv.pypa.io/en/latest/) with
  or without [virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/)).
  Once your environment is set up you can install darts using pip:
      pip install darts
  For more details you can refer to our
  [installation instructions](https://github.com/unit8co/darts/blob/master/INSTALL.md).


  Create a `TimeSeries` object from a Pandas DataFrame, and split it in train/validation series:
  ```python
  import pandas as pd
  from darts import TimeSeries

  df = pd.read_csv("AirPassengers.csv", delimiter=",")

  series = TimeSeries.from_dataframe(df, "Month", "#Passengers")

  train, val = series[:-36], series[-36:]
  ```
  Fit an exponential smoothing model, and make a (probabilistic) prediction over the validation series' duration:
  ```python
  from darts.models import ExponentialSmoothing
  model = ExponentialSmoothing()
  model.fit(train)
  prediction = model.predict(len(val), num_samples=1000)
  ```
  Plot the median, 5th and 95th percentiles:
  ```python
  import matplotlib.pyplot as plt
  series.plot()
  prediction.plot(label="forecast", low_quantile=0.05, high_quantile=0.95)
  plt.legend()
  ```
  <div style="text-align:center;">
  <img src="https://github.com/unit8co/darts/raw/master/static/images/example.png" alt="darts forecast example" />
  </div>

  Load a multivariate series, trim it, keep 2 components, split train and validation sets:
  ```python
  from darts.datasets import ETTh2Dataset
  series = ETTh2Dataset().load()[:10000][["MUFL", "LULL"]]
  train, val = series.split_before(0.6)
  ```
  Build a k-means anomaly scorer, train it on the train set
  and use it on the validation set to get anomaly scores:
  ```python
  from darts.ad import KMeansScorer
  scorer = KMeansScorer(k=2, window=5)
  scorer.fit(train)
  anom_score = scorer.score(val)
  ```
  Build a binary anomaly detector and train it over train scores,
  then use it over validation scores to get binary anomaly classification:
  ```python
  from darts.ad import QuantileDetector
  detector = QuantileDetector(high_quantile=0.99)
  detector.fit(scorer.score(train))
  binary_anom = detector.detect(anom_score)
  ```
  Plot (shifting and scaling some of the series
  to make everything appear on the same figure):
  ```python
  import matplotlib.pyplot as plt
  series.plot()
  (anom_score / 2. - 100).plot(label="computed anomaly score", c="orangered", lw=3)
  (binary_anom * 45 - 150).plot(label="detected binary anomaly", lw=4)
  ```
  <div style="text-align:center;">
  <img src="https://github.com/unit8co/darts/raw/master/static/images/example_ad.png" alt="darts anomaly detection example" />
  </div>

  * **Forecasting Models:** A large collection of forecasting models; from statistical models (such as
    ARIMA) to deep learning models (such as N-BEATS). See [table of models below](#forecasting-models).
  * **Anomaly Detection** The `darts.ad` module contains a collection of anomaly scorers,
    detectors and aggregators, which can all be combined to detect anomalies in time series.
    It is easy to wrap any of Darts forecasting or filtering models to build
    a fully fledged anomaly detection model that compares predictions with actuals.
    The `PyODScorer` makes it trivial to use PyOD detectors on time series.
  * **Multivariate Support:** `TimeSeries` can be multivariate - i.e., contain multiple time-varying
    dimensions/columns instead of a single scalar value. Many models can consume and produce multivariate series.
  * **Multiple series training (global models):** All machine learning based models (incl. all neural networks)
    support being trained on multiple (potentially multivariate) series. This can scale to large datasets too.
  * **Probabilistic Support:** `TimeSeries` objects can (optionally) represent stochastic
    time series; this can for instance be used to get confidence intervals, and many models support different
    flavours of probabilistic forecasting (such as estimating parametric distributions or quantiles).
    Some anomaly detection scorers are also able to exploit these predictive distributions.
  * **Past and Future Covariates support:** Many models in Darts support past-observed and/or future-known
    covariate (external data) time series as inputs for producing forecasts.
  * **Static Covariates support:** In addition to time-dependent data, `TimeSeries` can also contain
    static data for each dimension, which can be exploited by some models.
  * **Hierarchical Reconciliation:** Darts offers transformers to perform reconciliation.
    These can make the forecasts add up in a way that respects the underlying hierarchy.
  * **Regression Models:** It is possible to plug-in any scikit-learn compatible model
    to obtain forecasts as functions of lagged values of the target series and covariates.
  * **Training with sample weights:** All global models support being trained with sample weights. They can be
    applied to each observation, forecasted time step and target column.
  * **Forecast Start Shifting:** All global models support training and prediction on a shifted output window.
    This is useful for example for Day-Ahead Market forecasts, or when the covariates (or target series) are reported
    with a delay.
  * **Explainability:** Darts has the ability to *explain* some forecasting models using Shap values.
  * **Data processing:** Tools to easily apply (and revert) common transformations on
    time series data (scaling, filling missing values, differencing, boxcox, ...)
  * **Metrics:** A variety of metrics for evaluating time series' goodness of fit;
    from R2-scores to Mean Absolute Scaled Error.
  * **Backtesting:** Utilities for simulating historical forecasts, using moving time windows.
  * **PyTorch Lightning Support:** All deep learning models are implemented using PyTorch Lightning,
    supporting among other things custom callbacks, GPUs/TPUs training and custom trainers.
  * **Filtering Models:** Darts offers three filtering models: `KalmanFilter`, `GaussianProcessFilter`,
    and `MovingAverageFilter`, which allow to filter time series, and in some cases obtain probabilistic
    inferences of the underlying states/values.
  * **Datasets** The `darts.datasets` submodule contains some popular time series datasets for rapid
    and reproducible experimentation.

  Here's a breakdown of the forecasting models currently implemented in Darts. We are constantly working
  on bringing more models and features.
  | Model                                                                                                                                                                                                                                                                                     | Sources                                                                                                                                                                                                                           | Target Series Support:<br/><br/>Univariate/<br/>Multivariate | Covariates Support:<br/><br/>Past-observed/<br/>Future-known/<br/>Static | Probabilistic Forecasting:<br/><br/>Sampled/<br/>Distribution Parameters | Training & Forecasting on Multiple Series |
  |-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------|--------------------------------------------------------------------------|--------------------------------------------------------------------------|-------------------------------------------|
  | **Baseline Models**<br/>([LocalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#local-forecasting-models-lfms))                                                                                                                                                |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [NaiveMean](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveMean)                                                                                                                                           |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟥 🟥 🟥                                                                 | 🟥 🟥                                                                    | 🟥                                        |
  | [NaiveSeasonal](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveSeasonal)                                                                                                                                   |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟥 🟥 🟥                                                                 | 🟥 🟥                                                                    | 🟥                                        |
  | [NaiveDrift](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveDrift)                                                                                                                                         |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟥 🟥 🟥                                                                 | 🟥 🟥                                                                    | 🟥                                        |
  | [NaiveMovingAverage](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveMovingAverage)                                                                                                                         |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟥 🟥 🟥                                                                 | 🟥 🟥                                                                    | 🟥                                        |
  | **Statistical / Classic Models**<br/>([LocalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#local-forecasting-models-lfms))                                                                                                                                   |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [ARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.arima.html#darts.models.forecasting.arima.ARIMA)                                                                                                                                                           |                                                                                                                                                                                                                                   | 🟩 🟥                                                        | 🟥 🟩 🟥                                                                 | 🟩 🟥                                                                    | 🟥                                        |
  | [VARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.varima.html#darts.models.forecasting.varima.VARIMA)                                                                                                                                                       |                                                                                                                                                                                                                                   | 🟥 🟩                                                        | 🟥 🟩 🟥                                                                 | 🟩 🟥                                                                    | 🟥                                        |
  | [AutoARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.auto_arima.html#darts.models.forecasting.auto_arima.AutoARIMA)                                                                                                                                         |                                                                                                                                                                                                                                   | 🟩 🟥                                                        | 🟥 🟩 🟥                                                                 | 🟥 🟥                                                                    | 🟥                                        |
  | [StatsForecastAutoArima](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_arima.html#darts.models.forecasting.sf_auto_arima.StatsForecastAutoARIMA) (faster AutoARIMA)                                                                                      | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast)                                                                                                                                                                 | 🟩 🟥                                                        | 🟥 🟩 🟥                                                                 | 🟩 🟥                                                                    | 🟥                                        |
  | [ExponentialSmoothing](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.exponential_smoothing.html#darts.models.forecasting.exponential_smoothing.ExponentialSmoothing)                                                                                             |                                                                                                                                                                                                                                   | 🟩 🟥                                                        | 🟥 🟥 🟥                                                                 | 🟩 🟥                                                                    | 🟥                                        |
  | [StatsforecastAutoETS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_ets.html#darts.models.forecasting.sf_auto_ets.StatsForecastAutoETS)                                                                                                                 | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast)                                                                                                                                                                 | 🟩 🟥                                                        | 🟥 🟩 🟥                                                                 | 🟩 🟥                                                                    | 🟥                                        |
  | [StatsforecastAutoCES](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_ces.html#darts.models.forecasting.sf_auto_ces.StatsForecastAutoCES)                                                                                                                 | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast)                                                                                                                                                                 | 🟩 🟥                                                        | 🟥 🟥 🟥                                                                 | 🟥 🟥                                                                    | 🟥                                        |
  | [BATS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tbats_model.html#darts.models.forecasting.tbats_model.BATS) and [TBATS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tbats_model.html#darts.models.forecasting.tbats_model.TBATS) | [TBATS paper](https://robjhyndman.com/papers/ComplexSeasonality.pdf)                                                                                                                                                              | 🟩 🟥                                                        | 🟥 🟥 🟥                                                                 | 🟩 🟥                                                                    | 🟥                                        |
  | [Theta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.theta.html#darts.models.forecasting.theta.Theta) and [FourTheta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.theta.html#darts.models.forecasting.theta.FourTheta)               | [Theta](https://robjhyndman.com/papers/Theta.pdf) & [4 Theta](https://github.com/Mcompetitions/M4-methods/blob/master/4Theta%20method.R)                                                                                          | 🟩 🟥                                                        | 🟥 🟥 🟥                                                                 | 🟥 🟥                                                                    | 🟥                                        |
  | [StatsForecastAutoTheta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_theta.html#darts.models.forecasting.sf_auto_theta.StatsForecastAutoTheta)                                                                                                         | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast)                                                                                                                                                                 | 🟩 🟥                                                        | 🟥 🟥 🟥                                                                 | 🟩 🟥                                                                    | 🟥                                        |
  | [Prophet](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.prophet_model.html#darts.models.forecasting.prophet_model.Prophet)                                                                                                                                       | [Prophet repo](https://github.com/facebook/prophet)                                                                                                                                                                               | 🟩 🟥                                                        | 🟥 🟩 🟥                                                                 | 🟩 🟥                                                                    | 🟥                                        |
  | [FFT](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.fft.html#darts.models.forecasting.fft.FFT) (Fast Fourier Transform)                                                                                                                                          |                                                                                                                                                                                                                                   | 🟩 🟥                                                        | 🟥 🟥 🟥                                                                 | 🟥 🟥                                                                    | 🟥                                        |
  | [KalmanForecaster](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.kalman_forecaster.html#darts.models.forecasting.kalman_forecaster.KalmanForecaster) using the Kalman filter and N4SID for system identification                                                 | [N4SID paper](https://people.duke.edu/~hpgavin/SystemID/References/VanOverschee-Automatica-1994.pdf)                                                                                                                              | 🟩 🟩                                                        | 🟥 🟩 🟥                                                                 | 🟩 🟥                                                                    | 🟥                                        |
  | [Croston](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.croston.html#darts.models.forecasting.croston.Croston) method                                                                                                                                            |                                                                                                                                                                                                                                   | 🟩 🟥                                                        | 🟥 🟩 🟥                                                                 | 🟥 🟥                                                                    | 🟥                                        |
  | **Global Baseline Models**<br/>([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms))                                                                                                                                       |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [GlobalNaiveAggregate](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveAggregate)                                                                                           |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟥 🟥 🟥                                                                 | 🟥 🟥                                                                    | 🟩                                        |
  | [GlobalNaiveDrift](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveDrift)                                                                                                   |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟥 🟥 🟥                                                                 | 🟥 🟥                                                                    | 🟩                                        |
  | [GlobalNaiveSeasonal](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveSeasonal)                                                                                             |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟥 🟥 🟥                                                                 | 🟥 🟥                                                                    | 🟩                                        |
  | **Regression Models**<br/>([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms))                                                                                                                                            |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [RegressionModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_model.html#darts.models.forecasting.regression_model.RegressionModel): generic wrapper around any sklearn regression model                                                            |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟥 🟥                                                                    | 🟩                                        |
  | [LinearRegressionModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.linear_regression_model.html#darts.models.forecasting.linear_regression_model.LinearRegressionModel)                                                                                       |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [RandomForest](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.random_forest.html#darts.models.forecasting.random_forest.RandomForest)                                                                                                                             |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟥 🟥                                                                    | 🟩                                        |
  | [LightGBMModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.lgbm.html#darts.models.forecasting.lgbm.LightGBMModel)                                                                                                                                             |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [XGBModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.xgboost.html#darts.models.forecasting.xgboost.XGBModel)                                                                                                                                                 |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [CatBoostModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.catboost_model.html#darts.models.forecasting.catboost_model.CatBoostModel)                                                                                                                         |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | **PyTorch (Lightning)-based Models**<br/>([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms))                                                                                                                             |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [RNNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.rnn_model.html#darts.models.forecasting.rnn_model.RNNModel) (incl. LSTM and GRU); equivalent to DeepAR in its probabilistic version                                                                     | [DeepAR paper](https://arxiv.org/abs/1704.04110)                                                                                                                                                                                  | 🟩 🟩                                                        | 🟥 🟩 🟥                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [BlockRNNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.block_rnn_model.html#darts.models.forecasting.block_rnn_model.BlockRNNModel) (incl. LSTM and GRU)                                                                                                  |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟩 🟥 🟥                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [NBEATSModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nbeats.html#darts.models.forecasting.nbeats.NBEATSModel)                                                                                                                                             | [N-BEATS paper](https://arxiv.org/abs/1905.10437)                                                                                                                                                                                 | 🟩 🟩                                                        | 🟩 🟥 🟥                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [NHiTSModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nhits.html#darts.models.forecasting.nhits.NHiTSModel)                                                                                                                                                 | [N-HiTS paper](https://arxiv.org/abs/2201.12886)                                                                                                                                                                                  | 🟩 🟩                                                        | 🟩 🟥 🟥                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [TCNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tcn_model.html#darts.models.forecasting.tcn_model.TCNModel)                                                                                                                                             | [TCN paper](https://arxiv.org/abs/1803.01271), [DeepTCN paper](https://arxiv.org/abs/1906.04397), [blog post](https://medium.com/unit8-machine-learning-publication/temporal-convolutional-networks-and-forecasting-5ce1b6e97ce4) | 🟩 🟩                                                        | 🟩 🟥 🟥                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [TransformerModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.transformer_model.html#darts.models.forecasting.transformer_model.TransformerModel)                                                                                                             |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟩 🟥 🟥                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [TFTModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tft_model.html#darts.models.forecasting.tft_model.TFTModel) (Temporal Fusion Transformer)                                                                                                               | [TFT paper](https://arxiv.org/pdf/1912.09363.pdf), [PyTorch Forecasting](https://pytorch-forecasting.readthedocs.io/en/latest/models.html)                                                                                        | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [DLinearModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.dlinear.html#darts.models.forecasting.dlinear.DLinearModel)                                                                                                                                         | [DLinear paper](https://arxiv.org/pdf/2205.13504.pdf)                                                                                                                                                                             | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [NLinearModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nlinear.html#darts.models.forecasting.nlinear.NLinearModel)                                                                                                                                         | [NLinear paper](https://arxiv.org/pdf/2205.13504.pdf)                                                                                                                                                                             | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [TiDEModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tide_model.html#darts.models.forecasting.tide_model.TiDEModel)                                                                                                                                         | [TiDE paper](https://arxiv.org/pdf/2304.08424.pdf)                                                                                                                                                                                | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [TSMixerModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tsmixer_model.html#darts.models.forecasting.tsmixer_model.TSMixerModel)                                                                                                                             | [TSMixer paper](https://arxiv.org/pdf/2303.06053.pdf), [PyTorch Implementation](https://github.com/ditschuk/pytorch-tsmixer)                                                                                                      | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | **Ensemble Models**<br/>([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms)): Model support is dependent on ensembled forecasting models and the ensemble model itself                                                    |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [NaiveEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveEnsembleModel)                                                                                                                         |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |
  | [RegressionEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_ensemble_model.html#darts.models.forecasting.regression_ensemble_model.RegressionEnsembleModel)                                                                               |                                                                                                                                                                                                                                   | 🟩 🟩                                                        | 🟩 🟩 🟩                                                                 | 🟩 🟩                                                                    | 🟩                                        |

  Anyone is welcome to join our [Gitter room](https://gitter.im/u8darts/darts) to ask questions, make proposals,
  discuss use-cases, and more. If you spot a bug or have suggestions, GitHub issues are also welcome.
  If what you want to tell us is not suitable for Gitter or Github,
  feel free to send us an email at <a href="mailto:darts@unit8.co">darts@unit8.co</a> for
  darts related matters or <a href="mailto:info@unit8.co">info@unit8.co</a> for any other
  inquiries.

  The development is ongoing, and we welcome suggestions, pull requests and issues on GitHub.
  All contributors will be acknowledged on the
  [change log page](https://github.com/unit8co/darts/blob/master/CHANGELOG.md).
  Before working on a contribution (a new feature or a fix),
  [check our contribution guidelines](https://github.com/unit8co/darts/blob/master/CONTRIBUTING.md).

  If you are using Darts in your scientific work, we would appreciate citations to the following JMLR paper.
  [Darts: User-Friendly Modern Machine Learning for Time Series](https://www.jmlr.org/papers/v23/21-1177.html)
  Bibtex entry:
  ```
  @article{JMLR:v23:21-1177,
    author  = {Julien Herzen and Francesco LÃ¤ssig and Samuele Giuliano Piazzetta and Thomas Neuer and LÃ©o Tafti and Guillaume Raille and Tomas Van Pottelbergh and Marek Pasieka and Andrzej Skrodzki and Nicolas Huguenin and Maxime Dumonal and Jan KoÅ›cisz and Dennis Bader and FrÃ©dÃ©rick Gusset and Mounir Benheddi and Camila Williamson and Michal Kosinski and Matej Petrik and GaÃ«l Grosch},
    title   = {Darts: User-Friendly Modern Machine Learning for Time Series},
    journal = {Journal of Machine Learning Research},
    year    = {2022},
    volume  = {23},
    number  = {124},
    pages   = {1-6},
    url     = {http://jmlr.org/papers/v23/21-1177.html}
  }
  ```


pkgId: ddeed4194fcc382c45164f0d99f960d84b69b0c1d153877f2849baea7aac2da0
name: python-darts
arch: src
version: 0.31.0
epoch: 0
release: 1
summary: A python library for easy manipulation and forecasting of time series.
url: https://unit8co.github.io/darts/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darts-0.31.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/u8darts.svg)](https://badge.fury.io/py/darts)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/u8darts-all.svg)](https://anaconda.org/conda-forge/u8darts-all)
  ![Supported versions](https://img.shields.io/badge/python-3.8+-blue.svg)
  [![Docker Image Version (latest by date)](https://img.shields.io/docker/v/unit8/darts?label=docker&sort=date)](https://hub.docker.com/r/unit8/darts)
  ![GitHub Release Date](https://img.shields.io/github/release-date/unit8co/darts)
  ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/unit8co/darts/release.yml?branch=master)
  [![Downloads](https://pepy.tech/badge/darts)](https://pepy.tech/project/darts)
  [![Downloads](https://pepy.tech/badge/u8darts)](https://pepy.tech/project/u8darts)
  [![codecov](https://codecov.io/gh/unit8co/darts/branch/master/graph/badge.svg?token=7F1TLUFHQW)](https://codecov.io/gh/unit8co/darts)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![Join the chat at https://gitter.im/u8darts/darts](https://badges.gitter.im/u8darts/darts.svg)](https://gitter.im/u8darts/darts?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  **Darts** is a Python library for user-friendly forecasting and anomaly detection
  on time series. It contains a variety of models, from classics such as ARIMA to
  deep neural networks. The forecasting models can all be used in the same way,
  using `fit()` and `predict()` functions, similar to scikit-learn.
  The library also makes it easy to backtest models,
  combine the predictions of several models, and take external data into account.
  Darts supports both univariate and multivariate time series and models.
  The ML-based models can be trained on potentially large datasets containing multiple time
  series, and some of the models offer a rich support for probabilistic forecasting.
  Darts also offers extensive anomaly detection capabilities.
  For instance, it is trivial to apply PyOD models on time series to obtain anomaly scores,
  or to wrap any of Darts forecasting or filtering models to obtain fully
  fledged anomaly detection models.

  * [Quickstart](https://unit8co.github.io/darts/quickstart/00-quickstart.html)
  * [User Guide](https://unit8co.github.io/darts/userguide.html)
  * [API Reference](https://unit8co.github.io/darts/generated_api/darts.html)
  * [Examples](https://unit8co.github.io/darts/examples.html)

  * [Introductory Blog Post](https://medium.com/unit8-machine-learning-publication/darts-time-series-made-easy-in-python-5ac2947a8878)
  * [Introduction video (25 minutes)](https://youtu.be/g6OXDnXEtFA)

  * [Training Models on Multiple Time Series](https://medium.com/unit8-machine-learning-publication/training-forecasting-models-on-multiple-time-series-with-darts-dc4be70b1844)
  * [Using Past and Future Covariates](https://medium.com/unit8-machine-learning-publication/time-series-forecasting-using-past-and-future-external-data-with-darts-1f0539585993)
  * [Temporal Convolutional Networks and Forecasting](https://medium.com/unit8-machine-learning-publication/temporal-convolutional-networks-and-forecasting-5ce1b6e97ce4)
  * [Probabilistic Forecasting](https://medium.com/unit8-machine-learning-publication/probabilistic-forecasting-in-darts-e88fbe83344e)
  * [Transfer Learning for Time Series Forecasting](https://medium.com/unit8-machine-learning-publication/transfer-learning-for-time-series-forecasting-87f39e375278)
  * [Hierarchical Forecast Reconciliation](https://medium.com/unit8-machine-learning-publication/hierarchical-forecast-reconciliation-with-darts-8b4b058bb543)

  We recommend to first setup a clean Python environment for your project with Python 3.8+ using your favorite tool
  ([conda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html "conda-env"),
  [venv](https://docs.python.org/3/library/venv.html), [virtualenv](https://virtualenv.pypa.io/en/latest/) with
  or without [virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/)).
  Once your environment is set up you can install darts using pip:
      pip install darts
  For more details you can refer to our
  [installation instructions](https://github.com/unit8co/darts/blob/master/INSTALL.md).


  Create a `TimeSeries` object from a Pandas DataFrame, and split it in train/validation series:
  ```python
  import pandas as pd
  from darts import TimeSeries

  df = pd.read_csv("AirPassengers.csv", delimiter=",")

  series = TimeSeries.from_dataframe(df, "Month", "#Passengers")

  train, val = series[:-36], series[-36:]
  ```
  Fit an exponential smoothing model, and make a (probabilistic) prediction over the validation series' duration:
  ```python
  from darts.models import ExponentialSmoothing
  model = ExponentialSmoothing()
  model.fit(train)
  prediction = model.predict(len(val), num_samples=1000)
  ```
  Plot the median, 5th and 95th percentiles:
  ```python
  import matplotlib.pyplot as plt
  series.plot()
  prediction.plot(label="forecast", low_quantile=0.05, high_quantile=0.95)
  plt.legend()
  ```
  <div style="text-align:center;">
  <img src="https://github.com/unit8co/darts/raw/master/static/images/example.png" alt="darts forecast example" />
  </div>

  Load a multivariate series, trim it, keep 2 components, split train and validation sets:
  ```python
  from darts.datasets import ETTh2Dataset
  series = ETTh2Dataset().load()[:10000][["MUFL", "LULL"]]
  train, val = series.split_before(0.6)
  ```
  Build a k-means anomaly scorer, train it on the train set
  and use it on the validation set to get anomaly scores:
  ```python
  from darts.ad import KMeansScorer
  scorer = KMeansScorer(k=2, window=5)
  scorer.fit(train)
  anom_score = scorer.score(val)
  ```
  Build a binary anomaly detector and train it over train scores,
  then use it over validation scores to get binary anomaly classification:
  ```python
  from darts.ad import QuantileDetector
  detector = QuantileDetector(high_quantile=0.99)
  detector.fit(scorer.score(train))
  binary_anom = detector.detect(anom_score)
  ```
  Plot (shifting and scaling some of the series
  to make everything appear on the same figure):
  ```python
  import matplotlib.pyplot as plt
  series.plot()
  (anom_score / 2. - 100).plot(label="computed anomaly score", c="orangered", lw=3)
  (binary_anom * 45 - 150).plot(label="detected binary anomaly", lw=4)
  ```
  <div style="text-align:center;">
  <img src="https://github.com/unit8co/darts/raw/master/static/images/example_ad.png" alt="darts anomaly detection example" />
  </div>

  * **Forecasting Models:** A large collection of forecasting models; from statistical models (such as
    ARIMA) to deep learning models (such as N-BEATS). See [table of models below](#forecasting-models).
  * **Anomaly Detection** The `darts.ad` module contains a collection of anomaly scorers,
    detectors and aggregators, which can all be combined to detect anomalies in time series.
    It is easy to wrap any of Darts forecasting or filtering models to build
    a fully fledged anomaly detection model that compares predictions with actuals.
    The `PyODScorer` makes it trivial to use PyOD detectors on time series.
  * **Multivariate Support:** `TimeSeries` can be multivariate - i.e., contain multiple time-varying
    dimensions/columns instead of a single scalar value. Many models can consume and produce multivariate series.
  * **Multiple series training (global models):** All machine learning based models (incl. all neural networks)
    support being trained on multiple (potentially multivariate) series. This can scale to large datasets too.
  * **Probabilistic Support:** `TimeSeries` objects can (optionally) represent stochastic
    time series; this can for instance be used to get confidence intervals, and many models support different
    flavours of probabilistic forecasting (such as estimating parametric distributions or quantiles).
    Some anomaly detection scorers are also able to exploit these predictive distributions.
  * **Past and Future Covariates support:** Many models in Darts support past-observed and/or future-known
    covariate (external data) time series as inputs for producing forecasts.
  * **Static Covariates support:** In addition to time-dependent data, `TimeSeries` can also contain
    static data for each dimension, which can be exploited by some models.
  * **Hierarchical Reconciliation:** Darts offers transformers to perform reconciliation.
    These can make the forecasts add up in a way that respects the underlying hierarchy.
  * **Regression Models:** It is possible to plug-in any scikit-learn compatible model
    to obtain forecasts as functions of lagged values of the target series and covariates.
  * **Training with sample weights:** All global models support being trained with sample weights. They can be
    applied to each observation, forecasted time step and target column.
  * **Forecast Start Shifting:** All global models support training and prediction on a shifted output window.
    This is useful for example for Day-Ahead Market forecasts, or when the covariates (or target series) are reported
    with a delay.
  * **Explainability:** Darts has the ability to *explain* some forecasting models using Shap values.
  * **Data processing:** Tools to easily apply (and revert) common transformations on
    time series data (scaling, filling missing values, differencing, boxcox, ...)
  * **Metrics:** A variety of metrics for evaluating time series' goodness of fit;
    from R2-scores to Mean Absolute Scaled Error.
  * **Backtesting:** Utilities for simulating historical forecasts, using moving time windows.
  * **PyTorch Lightning Support:** All deep learning models are implemented using PyTorch Lightning,
    supporting among other things custom callbacks, GPUs/TPUs training and custom trainers.
  * **Filtering Models:** Darts offers three filtering models: `KalmanFilter`, `GaussianProcessFilter`,
    and `MovingAverageFilter`, which allow to filter time series, and in some cases obtain probabilistic
    inferences of the underlying states/values.
  * **Datasets** The `darts.datasets` submodule contains some popular time series datasets for rapid
    and reproducible experimentation.

  Here's a breakdown of the forecasting models currently implemented in Darts. We are constantly working
  on bringing more models and features.
  | Model                                                                                                                                                                                                                                                                                     | Sources                                                                                                                                                                                                                           | Target Series Support:<br/><br/>Univariate/<br/>Multivariate | Covariates Support:<br/><br/>Past-observed/<br/>Future-known/<br/>Static | Probabilistic Forecasting:<br/><br/>Sampled/<br/>Distribution Parameters | Training & Forecasting on Multiple Series |
  |-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------|--------------------------------------------------------------------------|--------------------------------------------------------------------------|-------------------------------------------|
  | **Baseline Models**<br/>([LocalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#local-forecasting-models-lfms))                                                                                                                                                |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [NaiveMean](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveMean)                                                                                                                                           |                                                                                                                                                                                                                                   | ✅ ✅                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | 🔴                                        |
  | [NaiveSeasonal](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveSeasonal)                                                                                                                                   |                                                                                                                                                                                                                                   | ✅ ✅                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | 🔴                                        |
  | [NaiveDrift](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveDrift)                                                                                                                                         |                                                                                                                                                                                                                                   | ✅ ✅                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | 🔴                                        |
  | [NaiveMovingAverage](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveMovingAverage)                                                                                                                         |                                                                                                                                                                                                                                   | ✅ ✅                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | 🔴                                        |
  | **Statistical / Classic Models**<br/>([LocalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#local-forecasting-models-lfms))                                                                                                                                   |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [ARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.arima.html#darts.models.forecasting.arima.ARIMA)                                                                                                                                                           |                                                                                                                                                                                                                                   | ✅ 🔴                                                        | 🔴 ✅ 🔴                                                                 | ✅ 🔴                                                                    | 🔴                                        |
  | [VARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.varima.html#darts.models.forecasting.varima.VARIMA)                                                                                                                                                       |                                                                                                                                                                                                                                   | 🔴 ✅                                                        | 🔴 ✅ 🔴                                                                 | ✅ 🔴                                                                    | 🔴                                        |
  | [AutoARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.auto_arima.html#darts.models.forecasting.auto_arima.AutoARIMA)                                                                                                                                         |                                                                                                                                                                                                                                   | ✅ 🔴                                                        | 🔴 ✅ 🔴                                                                 | 🔴 🔴                                                                    | 🔴                                        |
  | [StatsForecastAutoArima](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_arima.html#darts.models.forecasting.sf_auto_arima.StatsForecastAutoARIMA) (faster AutoARIMA)                                                                                      | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast)                                                                                                                                                                 | ✅ 🔴                                                        | 🔴 ✅ 🔴                                                                 | ✅ 🔴                                                                    | 🔴                                        |
  | [ExponentialSmoothing](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.exponential_smoothing.html#darts.models.forecasting.exponential_smoothing.ExponentialSmoothing)                                                                                             |                                                                                                                                                                                                                                   | ✅ 🔴                                                        | 🔴 🔴 🔴                                                                 | ✅ 🔴                                                                    | 🔴                                        |
  | [StatsforecastAutoETS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_ets.html#darts.models.forecasting.sf_auto_ets.StatsForecastAutoETS)                                                                                                                 | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast)                                                                                                                                                                 | ✅ 🔴                                                        | 🔴 ✅ 🔴                                                                 | ✅ 🔴                                                                    | 🔴                                        |
  | [StatsforecastAutoCES](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_ces.html#darts.models.forecasting.sf_auto_ces.StatsForecastAutoCES)                                                                                                                 | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast)                                                                                                                                                                 | ✅ 🔴                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | 🔴                                        |
  | [BATS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tbats_model.html#darts.models.forecasting.tbats_model.BATS) and [TBATS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tbats_model.html#darts.models.forecasting.tbats_model.TBATS) | [TBATS paper](https://robjhyndman.com/papers/ComplexSeasonality.pdf)                                                                                                                                                              | ✅ 🔴                                                        | 🔴 🔴 🔴                                                                 | ✅ 🔴                                                                    | 🔴                                        |
  | [Theta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.theta.html#darts.models.forecasting.theta.Theta) and [FourTheta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.theta.html#darts.models.forecasting.theta.FourTheta)               | [Theta](https://robjhyndman.com/papers/Theta.pdf) & [4 Theta](https://github.com/Mcompetitions/M4-methods/blob/master/4Theta%20method.R)                                                                                          | ✅ 🔴                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | 🔴                                        |
  | [StatsForecastAutoTheta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_theta.html#darts.models.forecasting.sf_auto_theta.StatsForecastAutoTheta)                                                                                                         | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast)                                                                                                                                                                 | ✅ 🔴                                                        | 🔴 🔴 🔴                                                                 | ✅ 🔴                                                                    | 🔴                                        |
  | [Prophet](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.prophet_model.html#darts.models.forecasting.prophet_model.Prophet)                                                                                                                                       | [Prophet repo](https://github.com/facebook/prophet)                                                                                                                                                                               | ✅ 🔴                                                        | 🔴 ✅ 🔴                                                                 | ✅ 🔴                                                                    | 🔴                                        |
  | [FFT](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.fft.html#darts.models.forecasting.fft.FFT) (Fast Fourier Transform)                                                                                                                                          |                                                                                                                                                                                                                                   | ✅ 🔴                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | 🔴                                        |
  | [KalmanForecaster](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.kalman_forecaster.html#darts.models.forecasting.kalman_forecaster.KalmanForecaster) using the Kalman filter and N4SID for system identification                                                 | [N4SID paper](https://people.duke.edu/~hpgavin/SystemID/References/VanOverschee-Automatica-1994.pdf)                                                                                                                              | ✅ ✅                                                        | 🔴 ✅ 🔴                                                                 | ✅ 🔴                                                                    | 🔴                                        |
  | [Croston](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.croston.html#darts.models.forecasting.croston.Croston) method                                                                                                                                            |                                                                                                                                                                                                                                   | ✅ 🔴                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | 🔴                                        |
  | **Global Baseline Models**<br/>([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms))                                                                                                                                       |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [GlobalNaiveAggregate](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveAggregate)                                                                                           |                                                                                                                                                                                                                                   | ✅ ✅                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | ✅                                        |
  | [GlobalNaiveDrift](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveDrift)                                                                                                   |                                                                                                                                                                                                                                   | ✅ ✅                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | ✅                                        |
  | [GlobalNaiveSeasonal](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveSeasonal)                                                                                             |                                                                                                                                                                                                                                   | ✅ ✅                                                        | 🔴 🔴 🔴                                                                 | 🔴 🔴                                                                    | ✅                                        |
  | **Regression Models**<br/>([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms))                                                                                                                                            |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [RegressionModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_model.html#darts.models.forecasting.regression_model.RegressionModel): generic wrapper around any sklearn regression model                                                            |                                                                                                                                                                                                                                   | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | 🔴 🔴                                                                    | ✅                                        |
  | [LinearRegressionModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.linear_regression_model.html#darts.models.forecasting.linear_regression_model.LinearRegressionModel)                                                                                       |                                                                                                                                                                                                                                   | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [RandomForest](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.random_forest.html#darts.models.forecasting.random_forest.RandomForest)                                                                                                                             |                                                                                                                                                                                                                                   | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | 🔴 🔴                                                                    | ✅                                        |
  | [LightGBMModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.lgbm.html#darts.models.forecasting.lgbm.LightGBMModel)                                                                                                                                             |                                                                                                                                                                                                                                   | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [XGBModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.xgboost.html#darts.models.forecasting.xgboost.XGBModel)                                                                                                                                                 |                                                                                                                                                                                                                                   | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [CatBoostModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.catboost_model.html#darts.models.forecasting.catboost_model.CatBoostModel)                                                                                                                         |                                                                                                                                                                                                                                   | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |
  | **PyTorch (Lightning)-based Models**<br/>([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms))                                                                                                                             |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [RNNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.rnn_model.html#darts.models.forecasting.rnn_model.RNNModel) (incl. LSTM and GRU); equivalent to DeepAR in its probabilistic version                                                                     | [DeepAR paper](https://arxiv.org/abs/1704.04110)                                                                                                                                                                                  | ✅ ✅                                                        | 🔴 ✅ 🔴                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [BlockRNNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.block_rnn_model.html#darts.models.forecasting.block_rnn_model.BlockRNNModel) (incl. LSTM and GRU)                                                                                                  |                                                                                                                                                                                                                                   | ✅ ✅                                                        | ✅ 🔴 🔴                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [NBEATSModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nbeats.html#darts.models.forecasting.nbeats.NBEATSModel)                                                                                                                                             | [N-BEATS paper](https://arxiv.org/abs/1905.10437)                                                                                                                                                                                 | ✅ ✅                                                        | ✅ 🔴 🔴                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [NHiTSModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nhits.html#darts.models.forecasting.nhits.NHiTSModel)                                                                                                                                                 | [N-HiTS paper](https://arxiv.org/abs/2201.12886)                                                                                                                                                                                  | ✅ ✅                                                        | ✅ 🔴 🔴                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [TCNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tcn_model.html#darts.models.forecasting.tcn_model.TCNModel)                                                                                                                                             | [TCN paper](https://arxiv.org/abs/1803.01271), [DeepTCN paper](https://arxiv.org/abs/1906.04397), [blog post](https://medium.com/unit8-machine-learning-publication/temporal-convolutional-networks-and-forecasting-5ce1b6e97ce4) | ✅ ✅                                                        | ✅ 🔴 🔴                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [TransformerModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.transformer_model.html#darts.models.forecasting.transformer_model.TransformerModel)                                                                                                             |                                                                                                                                                                                                                                   | ✅ ✅                                                        | ✅ 🔴 🔴                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [TFTModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tft_model.html#darts.models.forecasting.tft_model.TFTModel) (Temporal Fusion Transformer)                                                                                                               | [TFT paper](https://arxiv.org/pdf/1912.09363.pdf), [PyTorch Forecasting](https://pytorch-forecasting.readthedocs.io/en/latest/models.html)                                                                                        | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [DLinearModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.dlinear.html#darts.models.forecasting.dlinear.DLinearModel)                                                                                                                                         | [DLinear paper](https://arxiv.org/pdf/2205.13504.pdf)                                                                                                                                                                             | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [NLinearModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nlinear.html#darts.models.forecasting.nlinear.NLinearModel)                                                                                                                                         | [NLinear paper](https://arxiv.org/pdf/2205.13504.pdf)                                                                                                                                                                             | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [TiDEModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tide_model.html#darts.models.forecasting.tide_model.TiDEModel)                                                                                                                                         | [TiDE paper](https://arxiv.org/pdf/2304.08424.pdf)                                                                                                                                                                                | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [TSMixerModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tsmixer_model.html#darts.models.forecasting.tsmixer_model.TSMixerModel)                                                                                                                             | [TSMixer paper](https://arxiv.org/pdf/2303.06053.pdf), [PyTorch Implementation](https://github.com/ditschuk/pytorch-tsmixer)                                                                                                      | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |
  | **Ensemble Models**<br/>([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms)): Model support is dependent on ensembled forecasting models and the ensemble model itself                                                    |                                                                                                                                                                                                                                   |                                                              |                                                                          |                                                                          |                                           |
  | [NaiveEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveEnsembleModel)                                                                                                                         |                                                                                                                                                                                                                                   | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |
  | [RegressionEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_ensemble_model.html#darts.models.forecasting.regression_ensemble_model.RegressionEnsembleModel)                                                                               |                                                                                                                                                                                                                                   | ✅ ✅                                                        | ✅ ✅ ✅                                                                 | ✅ ✅                                                                    | ✅                                        |

  Anyone is welcome to join our [Gitter room](https://gitter.im/u8darts/darts) to ask questions, make proposals,
  discuss use-cases, and more. If you spot a bug or have suggestions, GitHub issues are also welcome.
  If what you want to tell us is not suitable for Gitter or Github,
  feel free to send us an email at <a href="mailto:darts@unit8.co">darts@unit8.co</a> for
  darts related matters or <a href="mailto:info@unit8.co">info@unit8.co</a> for any other
  inquiries.

  The development is ongoing, and we welcome suggestions, pull requests and issues on GitHub.
  All contributors will be acknowledged on the
  [change log page](https://github.com/unit8co/darts/blob/master/CHANGELOG.md).
  Before working on a contribution (a new feature or a fix),
  [check our contribution guidelines](https://github.com/unit8co/darts/blob/master/CONTRIBUTING.md).

  If you are using Darts in your scientific work, we would appreciate citations to the following JMLR paper.
  [Darts: User-Friendly Modern Machine Learning for Time Series](https://www.jmlr.org/papers/v23/21-1177.html)
  Bibtex entry:
  ```
  @article{JMLR:v23:21-1177,
    author  = {Julien Herzen and Francesco LÃ¤ssig and Samuele Giuliano Piazzetta and Thomas Neuer and LÃ©o Tafti and Guillaume Raille and Tomas Van Pottelbergh and Marek Pasieka and Andrzej Skrodzki and Nicolas Huguenin and Maxime Dumonal and Jan KoÅ›cisz and Dennis Bader and FrÃ©dÃ©rick Gusset and Mounir Benheddi and Camila Williamson and Michal Kosinski and Matej Petrik and GaÃ«l Grosch},
    title   = {Darts: User-Friendly Modern Machine Learning for Time Series},
    journal = {Journal of Machine Learning Research},
    year    = {2022},
    volume  = {23},
    number  = {124},
    pages   = {1-6},
    url     = {http://jmlr.org/papers/v23/21-1177.html}
  }
  ```


pkgId: a04b44c0273a1e28a4ba4a8c7a7b83e083ac54d436cedd6211d41b471fe6d56d
name: python-darwin-py
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: Library and command line interface for darwin.v7labs.com
url: https://docs.v7labs.com/reference/getting-started-2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darwin-py-1.0.10-1.src.rpm
checksum_type: sha256
description:
  Once installed, `darwin` is accessible as a command line tool.
  A useful way to navigate the CLI usage is through the help command `-h/--help` which will
  provide additional information for each command available.

  To perform remote operations on Darwin you first need to authenticate.
  This requires a [team-specific API-key](https://darwin.v7labs.com/?settings=api-keys).
  If you do not already have a Darwin account, you can [contact us](https://www.v7labs.com/contact) and we can set one up for you.
  To start the authentication process:
  ```
  $ darwin authenticate
  API key:
  Make example-team the default team? [y/N] y
  Datasets directory [~/.darwin/datasets]:
  Authentication succeeded.
  ```
  You will be then prompted to enter your API-key, whether you want to set the corresponding team as
  default and finally the desired location on the local file system for the datasets of that team.
  This process will create a configuration file at `~/.darwin/config.yaml`.
  This file will be updated with future authentications for different teams.

  Lists a summary of local existing datasets
  ```
  $ darwin dataset local
  NAME            IMAGES     SYNC_DATE         SIZE
  mydataset       112025     yesterday     159.2 GB
  ```
  Lists a summary of remote datasets accessible by the current user.
  ```
  $ darwin dataset remote
  NAME                       IMAGES     PROGRESS
  example-team/mydataset     112025        73.0%
  ```

  To create an empty dataset remotely:
  ```
  $ darwin dataset create test
  Dataset 'test' (example-team/test) has been created.
  Access at https://darwin.v7labs.com/datasets/579
  ```
  The dataset will be created in the team you're authenticated for.
  To delete the project on the server:
  ```
  $ darwin dataset remove test
  About to delete example-team/test on darwin.
  Do you want to continue? [y/N] y
  ```

  Uploads data to an existing remote project.
  It takes the dataset name and a single image (or directory) with images/videos to upload as
  parameters.
  The `-e/--exclude` argument allows to indicate file extension/s to be ignored from the data_dir.
  e.g.: `-e .jpg`
  For videos, the frame rate extraction rate can be specified by adding `--fps <frame_rate>`
  Supported extensions:
  - Video files: [`.mp4`, `.bpm`, `.mov` formats].
  - Image files [`.jpg`, `.jpeg`, `.png` formats].
  ```
  $ darwin dataset push test /path/to/folder/with/images
  100%|████████████████████████| 2/2 [00:01<00:00,  1.27it/s]
  ```
  Before a dataset can be downloaded, a release needs to be generated:
  ```
  $ darwin dataset export test 0.1
  Dataset test successfully exported to example-team/test:0.1
  ```
  This version is immutable, if new images / annotations have been added you will have to create a new release to included them.
  To list all available releases
  ```
  $ darwin dataset releases test
  NAME                           IMAGES     CLASSES                   EXPORT_DATE
  example-team/test:0.1               4           0     2019-12-07 11:37:35+00:00
  ```
  And to finally download a release.
  ```
  $ darwin dataset pull test:0.1
  Dataset example-team/test:0.1 downloaded at /directory/choosen/at/authentication/time .


pkgId: 9413b9f6a6d3f09f4cb77a28127f9ada4e55f8a2416afb26784f6c10e28549ef
name: python-darwinio
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: An evolution simulator
url: https://github.com/tusharhero/darwinio
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-darwinio-0.12.0-1.src.rpm
checksum_type: sha256
description:
  [![Made with Emacs](https://tusharhero.github.io/emacs.gif)](https://github.com/tusharhero/ecfpaw)
  [![GPLv3](https://www.gnu.org/graphics/gplv3-with-text-84x42.png)](https://www.gnu.org/licenses/gpl-3.0.html)
  [![Python Powered](https://www.python.org/static/community_logos/python-powered-w-70x28.png)](https://python.org)



   ```ascii
   ______   _______  _______          _________ _       _________ _______
  (  __  \ (  ___  )(  ____ )|\     /|\__   __/( (    /|\__   __/(  ___  )
  | (  \  )| (   ) || (    )|| )   ( |   ) (   |  \  ( |   ) (   | (   ) |
  | |   ) || (___) || (____)|| | _ | |   | |   |   \ | |   | |   | |   | |
  | |   | ||  ___  ||     __)| |( )| |   | |   | (\ \) |   | |   | |   | |
  | |   ) || (   ) || (\ (   | || || |   | |   | | \   |   | |   | |   | |
  | (__/  )| )   ( || ) \ \__| () () |___) (___| )  \  |___) (___| (___) |
  (______/ |/     \||/   \__/(_______)\_______/|/    )_)\_______/(_______)
   ```

  This is a Python program that simulates the process of evolution, complete with
  organisms, genetic codes, and neural networks.



  - You get to randomly generate organisms, and see how they evolve.
  - Change the conditions while the simulation is running.
  - You can control - Food and Temperature



  ![main game play screenshot](./documentation/screenshot/main_game_play.png)





  1. Make sure your python is up-to date
  2. Install pipx
     
      ```
      apt install pipx
      ```
     
      ```
      pacman -S python-pipx

      ```
     
      ```
      sudo emerge --sync
      sudo emerge --ask --update --deep --newuse @world
      sudo emerge --ask dev-python/pip
      sudo pip install pipx

      ```
  3. Open your terminal, and install darwinio by running
     ```bash
     pipx install darwinio
     ```
  4. To run the program,
     ```bash
     pipx run darwinio
     ```



  1. Make sure you python is up-to date, if you don't have python installed
     install a recent version from [python's official website.](https://python.org/).

     Or, if you have `winget` available, you can use,
     ```powershell
     winget install python
     ```
  2. Open your terminal/Powershell, and install darwinio by running
     ```powershell
     py -m pip install darwinio
     ```
  3. To run the program,
     ```powershell
     py -m darwinio
     ```





  1. Clone the repository to your local machine using the following command in your terminal
      ```
      git clone https://github.com/tusharhero/darwinio.git
      ```
  2. Create a virtual environment and source it
     ```
     python -m venv .venv
     source ./.venv/bin/activate
     ```
  3. Get the requirements
     ```
     pip install build
     ```
  4. Build and install it
     ```
     python -m build
     pip install .
     ```
  5. Test it by running it.
     ```
     python -m darwinio
     ```


  This program is copyright © 2023 Tushar Maharana <tusharhero@sdf.org>,
  and Mihir Nallagonda <adhikshithamihir@gmail.com>.

  This program is licensed under the terms of the
  [GNU GENERAL PUBLIC LICENSE VERSION 3](./LICENSE.md) which means this is Free Software.


pkgId: 448d810c00c00c36adb08437bdcd375d8ad781af66f260c6c5bf3b306684e35e
name: python-das
arch: src
version: 0.32.4
epoch: 0
release: 1
summary: DAS
url: https://github.com/janclemenslab/das
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-das-0.32.4-1.src.rpm
checksum_type: sha256
description:
  <!-- [![Test install](https://github.com/janclemenslab/das/actions/workflows/main.yml/badge.svg)](https://github.com/janclemenslab/das/actions/workflows/main.yml) -->


  _DAS_ is a method for automatically annotating song from raw audio recordings based on a deep neural network. _DAS_ can be used with a graphical user interface, from the terminal, or from within python scripts.

  If you have questions, feedback, or find bugs please raise an [issue](https://github.com/janclemenslab/das/issues).

  Please cite _DAS_ as:

  Elsa Steinfath, Adrian Palacios, Julian Rottschäfer, Deniz Yuezak, Jan Clemens (2021).
  _Fast and accurate annotation of acoustic signals with deep neural networks._
  [eLife](https://doi.org/10.7554/eLife.68837)





  __Anaconda__: _DAS_ is installed using an anaconda environment. For that, first install the [anaconda python distribution](https://docs.anaconda.com/anaconda/install/) (or [miniconda](https://docs.conda.io/en/latest/miniconda.html)).

  If you have conda already installed, make sure you have conda v4.8.4+. If not, update from an older version with `conda update conda`.

  <!-- ```shell
  curl https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -o miniconda.sh
  sh miniconda.sh -b -p $HOME/miniconda
  export PATH="$HOME/miniconda/bin:$PATH"
  ``` -->
  <!--
  __CUDA libraries for using the GPU__: While _DAS_ works well for annotating song using the CPU, a GPU will greatly improve annotation speed and is recommended for training a _DAS_ network. The network is implemented in the deep-learning framework Tensorflow. To make sure that Tensorflow can use your GPU, the required CUDA libraries need to be installed. See the [tensorflow docs](https://www.tensorflow.org/install/gpu) for details. -->

  __Libsoundfile on linux__: The graphical user interface (GUI) reads audio data using [soundfile](http://pysoundfile.readthedocs.io/), which relies on `libsndfile`. `libsndfile` will be automatically installed on Windows and macOS. On Linux, the library needs to be installed manually with: `sudo apt-get install libsndfile1`. Note that _DAS_ will work w/o `libsndfile` but will not be able to load exotic audio formats.


  Create an anaconda environment called `das` that contains all the required packages.

  On windows:
  ```shell
  conda install mamba -c conda-forge -n base -y
  mamba create python=3.9 das=0.32.3 "numpy<1.24" -c conda-forge -c ncb -c anaconda -c nvidia -n das -y
  ```

  On Linux or MacOS (intel and arm):
  ```shell
  conda install mamba -c conda-forge -n base -y
  mamba create python=3.10 das=0.32.3 -c conda-forge -c ncb -c anaconda -c nvidia -c apple -n das -y
  ```


  To start the graphical user interface:
  ```shell
  conda activate das
  das gui
  ```

  The documentation at [https://janclemenslab.org/das/](https://janclemenslab.org/das/) provides information on the usage of _DAS_:

  - A [quick start tutorial](https://janclemenslab.org/das/quickstart.html) walks through all steps from manually annotating song, over training a network, to generating new annotations.
  - How to use the [graphical user interface](https://janclemenslab.org/das/tutorials_gui/tutorials_gui.html).
  - How to use _DAS_ [from the terminal or from python scripts](https://janclemenslab.org/das/tutorials/tutorials.html).




  The following packages were modified and integrated into das:

  - Keras implementation of TCN models modified from [keras-tcn](https://github.com/philipperemy/keras-tcn) (in `das.tcn`)
  - Trainable STFT layer implementation modified from [kapre](https://github.com/keunwoochoi/kapre) (in `das.kapre`)

  See the sub-module directories for the original READMEs.


pkgId: 39e8d2a304c05ddd3821856828b925907387180a4b89fba70a549a5c653338aa
name: python-das-ice
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Python librairy to process DAS data
url: https://pypi.org/project/das-ice/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-das-ice-0.2.0-1.src.rpm
checksum_type: sha256
description:
  DAS_Ice is a python librairy to process DAS data. It is based on `xarray` and `dask` in order to allow processing of large dataset.


pkgId: df06f9793735e09aa8b6b067ec7bae141db7463b2d06f5dad70e6f307329ebdb
name: python-dasbus
arch: src
version: 1.7
epoch: 0
release: 1
summary: DBus library in Python 3
url: https://github.com/rhinstaller/dasbus
rpm_license: GNU Lesser General Public License v2 or later (LGPLv2+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dasbus-1.7-1.src.rpm
checksum_type: sha256
description:
  This DBus library is written in Python 3, based on GLib and inspired by pydbus. Find out more in
  the [documentation](https://dasbus.readthedocs.io/en/latest/).

  The code used to be part of the [Anaconda Installer](https://github.com/rhinstaller/anaconda)
  project. It was based on the [pydbus](https://github.com/LEW21/pydbus) library, but we replaced
  it with our own solution because its upstream development stalled. The dasbus library is
  a result of this effort.

  [![Build Status](https://travis-ci.com/rhinstaller/dasbus.svg?branch=master)](https://travis-ci.com/rhinstaller/dasbus)
  [![Documentation Status](https://readthedocs.org/projects/dasbus/badge/?version=latest)](https://dasbus.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://codecov.io/gh/rhinstaller/dasbus/branch/master/graph/badge.svg)](https://codecov.io/gh/rhinstaller/dasbus)



  * Python 3.6+
  * PyGObject 3

  You can install [PyGObject](https://pygobject.readthedocs.io) provided by your operating system
  or use PyPI. The system package is usually called `python3-gi`, `python3-gobject` or `pygobject3`.
  See the [instructions](https://pygobject.readthedocs.io/en/latest/getting_started.html) for
  your platform (only for PyGObject, you don't need cairo or GTK).

  The library is known to work with Python 3.8, PyGObject 3.34 and GLib 2.63, but these are not the
  required minimal versions.



  Install the package from [PyPI](https://pypi.org/project/dasbus/) or install the package
  provided by your operating system if available.



  Follow the instructions above to install the requirements before you install `dasbus` with `pip`.
  The required dependencies has to be installed manually in this case.

  ```
  pip3 install dasbus
  ```



  Follow the instructions for your operating system to install the `python-dasbus` package.
  The required dependencies should be installed automatically by the system package manager.

  * [Arch Linux](https://dasbus.readthedocs.io/en/latest/#install-on-arch-linux)
  * [Debian / Ubuntu](https://dasbus.readthedocs.io/en/latest/#install-on-debian-ubuntu)
  * [Fedora / CentOS / RHEL](https://dasbus.readthedocs.io/en/latest/#install-on-fedora-centos-rhel)
  * [openSUSE](https://dasbus.readthedocs.io/en/latest/#install-on-opensuse)



  Show the current hostname.

  ```python
  from dasbus.connection import SystemMessageBus
  bus = SystemMessageBus()

  proxy = bus.get_proxy(
      "org.freedesktop.hostname1",
      "/org/freedesktop/hostname1"
  )

  print(proxy.Hostname)
  ```

  Send a notification to the notification server.

  ```python
  from dasbus.connection import SessionMessageBus
  bus = SessionMessageBus()

  proxy = bus.get_proxy(
      "org.freedesktop.Notifications",
      "/org/freedesktop/Notifications"
  )

  id = proxy.Notify(
      "", 0, "face-smile", "Hello World!",
      "This notification can be ignored.",
      [], {}, 0
  )

  print("The notification {} was sent.".format(id))
  ```

  Handle a closed notification.

  ```python
  from dasbus.loop import EventLoop
  loop = EventLoop()

  from dasbus.connection import SessionMessageBus
  bus = SessionMessageBus()

  proxy = bus.get_proxy(
      "org.freedesktop.Notifications",
      "/org/freedesktop/Notifications"
  )

  def callback(id, reason):
      print("The notification {} was closed.".format(id))

  proxy.NotificationClosed.connect(callback)
  loop.run()
  ```

  Asynchronously fetch a list of network devices.

  ```python
  from dasbus.loop import EventLoop
  loop = EventLoop()

  from dasbus.connection import SystemMessageBus
  bus = SystemMessageBus()

  proxy = bus.get_proxy(
      "org.freedesktop.NetworkManager",
      "/org/freedesktop/NetworkManager"
  )

  def callback(call):
      print(call())

  proxy.GetDevices(callback=callback)
  loop.run()
  ```

  Inhibit the system suspend and hibernation.

  ```python
  import os
  from dasbus.connection import SystemMessageBus
  from dasbus.unix import GLibClientUnix
  bus = SystemMessageBus()

  proxy = bus.get_proxy(
      "org.freedesktop.login1",
      "/org/freedesktop/login1",
      client=GLibClientUnix
  )

  fd = proxy.Inhibit(
      "sleep", "my-example", "Running an example", "block"
  )

  proxy.ListInhibitors()
  os.close(fd)
  ```

  Define the org.example.HelloWorld service.

  ```python
  class HelloWorld(object):
      __dbus_xml__ = """
      <node>
          <interface name="org.example.HelloWorld">
              <method name="Hello">
                  <arg direction="in" name="name" type="s" />
                  <arg direction="out" name="return" type="s" />
              </method>
          </interface>
      </node>
      """

      def Hello(self, name):
          return "Hello {}!".format(name)
  ```

  Define the org.example.HelloWorld service with an automatically generated XML specification.

  ```python
  from dasbus.server.interface import dbus_interface
  from dasbus.typing import Str

  @dbus_interface("org.example.HelloWorld")
  class HelloWorld(object):

      def Hello(self, name: Str) -> Str:
          return "Hello {}!".format(name)

  print(HelloWorld.__dbus_xml__)
  ```

  Publish the org.example.HelloWorld service on the session message bus.

  ```python
  from dasbus.connection import SessionMessageBus
  bus = SessionMessageBus()
  bus.publish_object("/org/example/HelloWorld", HelloWorld())
  bus.register_service("org.example.HelloWorld")

  from dasbus.loop import EventLoop
  loop = EventLoop()
  loop.run()
  ```

  See more examples in the [documentation](https://dasbus.readthedocs.io/en/latest/examples.html).



  Look at the [complete examples](https://github.com/rhinstaller/dasbus/tree/master/examples) or
  [DBus services](https://github.com/rhinstaller/anaconda/tree/master/pyanaconda/modules) of
  the Anaconda Installer for more inspiration.


pkgId: 6d4ebaecc4a10599429e6fb34233e208e0ce85101a32ed7fe4dd4caf68a97249
name: python-daschat-base
arch: src
version: 0.15.10
epoch: 0
release: 1
summary: Base package for Daschat modules.
url: https://github.com/daschat-io/daschat_base
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daschat-base-0.15.10-1.src.rpm
checksum_type: sha256
description:
  Base package for the development of integration modules with chat applications for the handsoff of conversations.


  <p align="center">
  <a href="https://www.python.org/">
      <img src="https://img.shields.io/badge/Made%20with-Python-1f425f.svg"
          alt = "Made with Python">
  </a>

  <a href="https://pypi.python.org/pypi/daschat_base">
      <img src="https://img.shields.io/pypi/v/daschat_base.svg"
          alt = "Release Status">
  </a>

  <a href="https://github.com/daschat-io/daschat_base/actions">
      <img src="https://github.com/daschat-io/daschat_base/actions/workflows/main.yml/badge.svg?branch=release" alt="CI Status">
  </a>

  <!-- <a href="https://daschat-handsoff-base.readthedocs.io/en/latest/?badge=latest">
      <img src="https://readthedocs.org/projects/daschat-base/badge/?version=latest" alt="Documentation Status">
  </a> -->

  </p>



  * Free software: MIT
  * Documentation: <https://daschat-io.github.io/daschat_base/>




  Install Python versions using `pyenv` and enable all versions to be used with `tox`:

  ``` console
  $ pyenv install 3.8.10 3.9.5
  $ pyenv shell 3.8.10 3.9.5
  $ pyenv local 3.8.10
  ```



   - [Cookiecutter](https://github.com/audreyr/cookiecutter)
   - [zillionare/cookiecutter-pypackage](https://github.com/zillionare/cookiecutter-pypackage)
   - [Naereen/badges](https://github.com/Naereen/badges)


pkgId: 1195d84c845137766125827de62c04e8469624e4a1dee27994d601fab3057f54
name: python-dascore
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: A python library for distributed fiber optic sensing
url: https://dascore.org
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dascore-0.1.4-1.src.rpm
checksum_type: sha256
description:
  A python library for distributed fiber optic sensing.

  [![coverage](https://codecov.io/gh/dasdae/dascore/branch/master/graph/badge.svg)](https://codecov.io/gh/dasdae/dascore)
  [![PyPI Version](https://img.shields.io/pypi/v/dascore.svg)](https://pypi.python.org/pypi/dascore)
  [![supported versions](https://img.shields.io/pypi/pyversions/dascore.svg?label=python_versions)](https://pypi.python.org/pypi/dascore)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/dascore.svg?label=pypi)](https://pypi.org/project/dascore/)
  [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/dascore.svg?label=conda)](https://github.com/conda-forge/dascore-feedstock)
  [![DOI](https://zenodo.org/badge/422627477.svg)](https://zenodo.org/badge/latestdoi/422627477)
  [![Licence](https://www.gnu.org/graphics/lgplv3-88x31.png)](https://www.gnu.org/licenses/lgpl.html)

  [Code](https://github.com/DASDAE/dascore)

  Documentation [[stable](https://dascore.org), [development](https://dascore.netlify.app/)]

  [Citation](https://seismica.library.mcgill.ca/article/view/1184)

  > Chambers, D., Jin, G., Tourei, A., Issah, A. H. S., Lellouch, A., Martin, E., Zhu, D., Girard, A., Yuan, S., Cullison, T., Snyder, T., Kim, S., Danes, N., Pnithan, N., Boltz, M. S. & Mendoza, M. M. (2024). DASCore: a Python Library for Distributed Fiber Optic Sensing. Seismica, 3(2).

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


pkgId: 32210a6e93ead02e4e3b848ff1074d8f3b9f549163ccb1fa9d48979ed16485e3
name: python-dash-ag-grid
arch: src
version: 31.2.0
epoch: 0
release: 1
summary: Dash wrapper around AG Grid, the best interactive data grid for the web.
url: https://dash.plotly.com/dash-ag-grid
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-ag-grid-31.2.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/AnnMarieW/dash-ag-grid-examples/assets/72614349/0c7319e4-0ebd-437a-bbdc-1091ec7ae325" width="1000"/>

  We welcome contributions to `dash-ag-grid`.  Please see our [contributing guide](https://github.com/plotly/dash-ag-grid/blob/main/CONTRIBUTING.md) for more information.


pkgId: 60e85ab78fb033ef663f3fc44d72690d88f6ab281d7d65bd3f31ced6a7d94bb7
name: python-dash-auth
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Dash Authorization Package.
url: https://plotly.com/dash
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-auth-2.3.0-1.src.rpm
checksum_type: sha256
description:
  *pages/home.py*
  ```python
  from dash import Input, Output, html, register_page
  from dash_auth import public_callback
  register_page(__name__, "/")
  layout = [
      html.H1("Home Page"),
      html.Button("Click me", id="home-button"),
      html.Div(id="home-contents"),
  ]

  @public_callback(
      Output("home-contents", "children"),
      Input("home-button", "n_clicks"),
  )
  def home(n_clicks):
      if not n_clicks:
          return "You haven't clicked the button."
      return "You clicked the button {} times".format(n_clicks)


pkgId: e4d3b9caddfa807fd39bb5d3e9b32dd8d7f1b31b0fd7ec026c15c18bfcd9107e
name: python-dash-auth-external
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Integrate your dashboards with 3rd party APIs and external OAuth providers.
url: https://github.com/jamesholcombe/dash-auth-external
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-auth-external-1.2.1-1.src.rpm
checksum_type: sha256
description:
  Integrate your dashboards with 3rd party APIs and external OAuth providers.



  Do you want to build a Plotly Dash app which pulls user data from external APIs such as Google, Spotify, Slack etc?

  **Dash-auth-external** provides a simple interface to authenticate users through OAuth2 code flow. Allowing developers to serve user tailored content.



  **Dash-auth-external** is distributed via [PyPi](https://pypi.org/project/dash-auth-external/)

  ```
  pip install dash-auth-external
  ```



  ```python

  AUTH_URL = "https://accounts.spotify.com/authorize"
  TOKEN_URL = "https://accounts.spotify.com/api/token"
  CLIENT_ID = "YOUR_CLIENT_ID"


  auth = DashAuthExternal(AUTH_URL, TOKEN_URL, CLIENT_ID)
  ```

  We then pass the flask server from this object to dash on init.

  ```python
  app = Dash(__name__, server= auth.server)
  ```

  That's it! You can now define your layout and callbacks as usual.

  > To obtain your access token, call the get_token method of your Auth object.
  > **NOTE** This can **ONLY** be done in the context of a dash callback.

  ```python
  ...

  app.layout = html.Div(
  [
  html.Div(id="example-output"),
  dcc.Input(id="example-input")
  ])

  @app.callback(
  Output("example-output", "children"),
  Input("example-input", "value")
  )
  def example_callback(value):
      token = auth.get_token()
       

      token_data = auth.get_token_data()
      
      print(token)
      print(token_data)

      return token

  ```

  Results in something like:

  ```bash
  >>> fakeToken123
  >>> {
      "access_token" : "fakeToken123",
      "user_id" : "lucifer",
      "some_other_key" : 666,
      "expires_at" : "judgmentDay"
  }

  ```



  If your OAuth provider supports refresh tokens, these are automatically checked and handled in the _get_token_ method.

  > Check if your OAuth provider requires any additional scopes to support refresh tokens



  If you hit 400 responses (bad request) from either endpoint, there are a number of things that might need configuration.

  Make sure you have checked the following

  - **Register your redirect URI** with OAuth provider!

  _The library uses a default redirect URI of http://127.0.0.1:8050/redirect_.



  Contributions, issues, and ideas are all more than welcome.


pkgId: 4d496f064cadd495c08dad9c320971314187cfe9a2e9bc7294c70a9eeadd16d8
name: python-dash-bio
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Dash components for bioinformatics
url: http://github.com/plotly/dash-bio
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-bio-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/plotly/dash-bio/tree/master.svg?style=svg)](https://circleci.com/gh/plotly/dash-bio)
  [![PyPI version](https://badge.fury.io/py/dash-bio.svg)](https://badge.fury.io/py/dash-bio)

  Dash Bio is a suite of bioinformatics components built to work with
  [Dash](https://github.com/plotly/dash/).

  Announcement: https://medium.com/@plotlygraphs/announcing-dash-bio-ed8835d5da0c

  Demo:
  [https://dash-gallery.plotly.host/Portal/?search=Bioinformatics](https://dash-gallery.plotly.host/Portal/?search=Bioinformatics)

  Documentation:
  [https://dash.plotly.com/dash-bio](https://dash.plotly.com/dash-bio)



  The Dash Bio components each fall into one of three categories:

  - Custom chart types
  - Sequence analysis tools
  - 3D rendering tools




  - Dash Circos
  - Dash Clustergram
  - Dash Manhattan Plot
  - Dash Needle Plot
  - Dash Volcano Plot



  - Dash Alignment Chart
  - Dash Onco Print
  - Dash Forna Container
  - Dash Sequence Viewer



  - Dash Mol2D
  - Dash Mol3D
  - Dash Speck
  - Dash Ngl




  It's easy to add a fully interactive chromosomal, molecular or genomic visualization to your Dash app by simply
  including the Dash Bio component into your app layout as follows:

  ```python
  import urllib.request as urlreq
  from dash import Dash, html
  import dash_bio as dashbio

  app = Dash(__name__)

  data = urlreq.urlopen(
      'https://raw.githubusercontent.com/plotly/dash-bio-docs-files/master/alignment_viewer_p53.fasta'
  ).read().decode('utf-8')

  app.layout = html.Div([
      dashbio.AlignmentChart(
          id='my-default-alignment-viewer',
          data=data
      )
  ])

  if __name__ == '__main__':
      app.run_server(debug=True)
  ```

  See the [Dash Bio documentation](https://dash.plotly.com/dash-bio) for more components and examples.




  1. Create a virtual environment:

      The following steps require a virtual environment tool to be installed on your computer: `pip install virtualenv`

      a. On macOS and Linux: `python3 -m venv env`

      b. On Windows, enter: `py -m venv env`

  2. Activate your new environment:

      a. On macOS and Linux, enter: `source env/bin/activate`

      b. On Windows, enter: `.\env\Scripts\activate`

  3. Install required libraries (make sure you have pip installed with `pip help`):
  ```
  pip install dash dash-bio pandas numpy Jupyterlab
  ```

  4. To run Dash inside Jupyter lab:

      a. Install jupyter-dash:  `pip install jupyter-dash`

      b. Enter `jupyter lab build`

      (Note: This step requires Node.js and NPM installed on yourcomputer. To check if Node and NPM are installed, enter `node -v` and `npm -v` in your terminal. For install instructions see [nodejs.org](https://nodejs.org/en/).

  5. To display Plotly figures in JupyterLab:
  ```
  pip install jupyterlab "ipywidgets>=7.5”
  jupyter labextension install jupyterlab-plotly@4.14.3
  ```

  6. Start JupyterLab by typing: `jupyter lab`

      Important: JupyterLab must be run within the virtual environment that was previously activated.


  For more on running a Dash app in Jupyter Lab visit [Getting Started with Jupyter Dash](https://github.com/plotly/jupyter-dash/blob/master/notebooks/getting_started.ipynb).



  Learn more about Dash at
  [https://plotly.com/products/dash/](https://plotly.com/products/dash/).



  For inquiries about Dash app development, advanced OEM integration,
  and more, please [reach
  out](https://plotly.typeform.com/to/mH1Cpb).



  If you would like to contribute to this repository, or run demo apps and tests, please refer to
  the [contributing
  guidelines](https://github.com/plotly/dash-bio/blob/master/CONTRIBUTING.md).


pkgId: ee4f3466e78f6f0f00ce9f541f93b79fe8fd0f79b8e92837dc87768a4fcdb64b
name: python-dash-blueprint-components
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Dash plotly porting of BlueprintJS
url: https://pypi.org/project/dash-blueprint-components/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-blueprint-components-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Dash Blueprint Components (```DBPC```) is the porting for dash plotly of the blueprintjs React-based UI toolkit for the web.

  It is optimized for building complex data-dense interfaces for desktop applications.

  All the rights belongs to BlueprintJS team.


  - Official Blueprint documentation: https://blueprintjs.com/docs/
  - Pypi homepage: https://pypi.org/project/dash-blueprint-components/
  - Dash blueprint components docs: https://dash-blueprint-components.com/blueprint/



  ```python
  pip install dash-blueprint-components
  ```



  ```python
  from dash import Dash, html, callback, Input, Output
  import dash_blueprint_components as dbpc


  app = Dash(
      __name__,
  )

  app.layout = html.Div(
      children=[
          dbpc.Button(
              id='button',
              text='Click me!'
          ),
          html.Div(
              id='output'
          )
      ]
  )

  @callback(
      Output('output', 'children'),
      Input('button', 'n_clicks')
  )
  def click(n_clicks):
      if n_clicks is not None:
          return n_clicks

  if __name__ == "__main__":
      app.run_server()
  ```


pkgId: d9f0048567f5a1140953538b437da114a81b8c4edd562f878197e075064d98fc
name: python-dash-bootstrap-components
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Bootstrap themed components for use in Plotly Dash
url: https://dash-bootstrap-components.opensource.faculty.ai/
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-bootstrap-components-1.6.0-1.src.rpm
checksum_type: sha256
description:
  <h1>Dash Bootstrap Components</h1>

  <p align="center">
    <a href="https://dash-bootstrap-components.opensource.faculty.ai/">
      <img src="https://cdn.opensource.faculty.ai/dbc/assets/logo.svg" alt="dash-bootstrap-components logo" width="200" height="200">
    </a>
  </p>

  <p align="center">
    Bootstrap components for Plotly Dash
    <br>
    <a href="https://dash-bootstrap-components.opensource.faculty.ai/">Explore the documentation </a>~
    <a href="https://github.com/facultyai/dash-bootstrap-components/issues/new?template=bug.md">Report a bug </a>~
    <a href="https://github.com/facultyai/dash-bootstrap-components/issues/new?template=feature.md">Request a feature</a>
    <br>
    <br>
    <img alt="GitHub Actions" src="https://github.com/facultyai/dash-bootstrap-components/workflows/Tests/badge.svg?branch=main">
    <img alt="GitHub" src="https://img.shields.io/github/license/facultyai/dash-bootstrap-components">
    <img alt="PyPI" src="https://img.shields.io/pypi/v/dash-bootstrap-components">
    <img alt="Conda (channel only)" src="https://img.shields.io/conda/vn/conda-forge/dash-bootstrap-components">
    <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/dash-bootstrap-components">
  </p>

  _dash-bootstrap-components_ is a library of [Bootstrap][bootstrap-homepage]
  components for use with [Plotly Dash][dash-homepage], that makes it easier to
  build consistently styled Dash apps with complex, responsive layouts.





  You can install _dash-bootstrap-components_ with `pip`:

  ```sh
  pip install dash-bootstrap-components
  ```



  You can also install _dash-bootstrap-components_ with `conda` through the
  conda-forge channel:

  ```sh
  conda install -c conda-forge dash-bootstrap-components
  ```



  To use _dash-bootstrap-components_ you must do two things:

  - Link a Bootstrap v5 compatible stylesheet
  - Incorporate _dash-bootstrap-components_ into your layout



  _dash-bootstrap-components_ doesn't come with CSS included. This is to give you
  the freedom to use any Bootstrap v5 stylesheet of your choice. This means
  however that in order for the components to be styled properly, you must link
  to a stylesheet yourself.

  For convenience, links to [BootstrapCDN][bootstrapcdn] for each theme are
  available through the `themes` module, which can be used as follows:

  ```python
  import dash
  import dash_bootstrap_components as dbc

  app = dash.Dash(external_stylesheets=[dbc.themes.BOOTSTRAP])
  ```

  For more information on how to link local or external CSS, check out the
  [Dash documentation][dash-docs-external].



  With CSS linked, you can start building your app's layout with our Bootstrap
  components. See our [_documentation_][docs-components] for a full list of
  available components.



  We welcome contributions to _dash-bootstrap-components_. If you find a bug or
  something is unclear please [submit a bug report][bug-report], if you have ideas
  for new features please feel free to make a [feature request][feature-request].
  If you would like to submit a pull request, please read our
  [contributing guide][contribution-guide].



  Code and documentation is copyright [Faculty Science Ltd.][faculty]
  2018-2022, and released under the [Apache 2.0 license](./LICENSE.txt)

  [dash-homepage]: https://dash.plot.ly/
  [dash-docs-external]: https:/dash.plot.ly/external-resources
  [bootstrap-homepage]: https://getbootstrap.com/
  [dbc-repo]: https://github.com/facultyai/dash-bootstrap-components
  [reactstrap-homepage]: https://reactstrap.github.io/
  [docs-homepage]: https://dash-bootstrap-components.opensource.faculty.ai
  [docs-components]: https://dash-bootstrap-components.opensource.faculty.ai/l/components
  [bootstrapcdn]: https://www.bootstrapcdn.com/
  [faculty]: https://faculty.ai
  [bug-report]: https://github.com/facultyai/dash-bootstrap-components/issues/new?template=bug.md
  [feature-request]: https://github.com/facultyai/dash-bootstrap-components/issues/new?template=feature.md
  [contribution-guide]: https://github.com/facultyai/dash-bootstrap-components/blob/main/.github/CONTRIBUTING.md


pkgId: a29af849a5071b4b22ea5045cc04f65610e0d6ca3363c0e02347f610c167bb5b
name: python-dash-bootstrap-templates
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: A collection of Plotly figure templates with a Bootstrap theme
url: https://github.com/AnnMarieW/dash-bootstrap-templates
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-bootstrap-templates-1.2.4-1.src.rpm
checksum_type: sha256
description:
  ```python
  ```
  Here is the same app, but using a the `ThemeSwitchAIO` component to toggle between two themes.
  See the  [(code here)](https://github.com/AnnMarieW/dash-bootstrap-templates/blob/main/examples/demo_toggle.py).
  It's also possible to change the icons.  See an example of using Bootstrap icons instead of the default FontAwesome
  icons [here](https://github.com/AnnMarieW/dash-bootstrap-templates/blob/main/examples/demo_toggle_icons.py).
  ![theme_toggle](https://user-images.githubusercontent.com/72614349/141466191-13709102-a2fb-45b5-a984-383d3e6ab373.gif)
  <br>
  <br>

  __Requires dash-bootstrap-components>=1.5.0__
  This is the recommended way to switch between a light and a dark mode using  [Bootstrap Color modes](https://getbootstrap.com/docs/5.3/customize/color-modes/)
  available in Bootstrap 5.3.0.
  ![color-mode-templates](https://github.com/AnnMarieW/dash-bootstrap-templates/assets/72614349/86c56043-08e0-4b8a-a473-13e2ef89533a)
  ```python
  from dash import Dash, html, dcc, Input, Output, clientside_callback, callback
  import plotly.express as px
  import dash_bootstrap_components as dbc
  from dash_bootstrap_templates import load_figure_template
  load_figure_template(["minty", "minty_dark"])
  df = px.data.gapminder()
  app = Dash(__name__, external_stylesheets=[dbc.themes.MINTY, dbc.icons.FONT_AWESOME])
  color_mode_switch =  html.Span(
      [
          dbc.Label(className="fa fa-moon", html_for="switch"),
          dbc.Switch( id="switch", value=False, className="d-inline-block ms-1", persistence=True),
          dbc.Label(className="fa fa-sun", html_for="switch"),
      ]
  )
  app.layout = dbc.Container(
      [
          html.Div(["Bootstrap Light Dark Color Modes Demo"], className="bg-primary text-white h3 p-2"),
          color_mode_switch,
          dcc.Graph(id="graph", className="border"),
      ]
  )
  @callback(
      Output("graph", "figure"),
      Input("switch", "value"),
  )
  def update_figure_template(switch_on):
      template = "minty" if switch_on else "minty_dark"
      fig = px.scatter(
          df.query("year==2007"),
          x="gdpPercap",
          y="lifeExp",
          size="pop",
          color="continent",
          log_x=True,
          size_max=60,
          template=template,
      )
      return fig
  clientside_callback(
      """
      (switchOn) => {
         switchOn
           ? document.documentElement.setAttribute('data-bs-theme', 'light')
         return window.dash_clientside.no_update
      }
      """,
      Output("switch", "id"),
      Input("switch", "value"),
  )
  if __name__ == "__main__":
      app.run_server(debug=True)
  ```
  <br>
  <br>

  Here is an example of the theme change component to show different Bootstrap themes with Dash AG Grid:
  See live demo https://hellodash.pythonanywhere.com/adding-themes/ag-grid
  ![ag-grid-dbc-theme](https://github.com/AnnMarieW/dash-bootstrap-templates/assets/72614349/10bd25fc-1e01-4ba9-ac38-d18a14d7ef4f)
  <br>
  <br>

  [Dash Labs](https://community.plotly.com/t/introducing-dash-labs/52087) is Plotly library that explores new features for future releases of Dash.
  In Dash Labs V0.4.0, there was a cool feature where Bootstrap themed figure templates were created "on the fly". This was a
  part of the layout templates project that is no longer being developed.
  Even though these Bootstrap themed figure templates will not be included in Dash, the `dash-bootstrap-templates` makes
  them available to you. The figure templates are created using the Dash Labs' algorithms and saved in json format.  When
  you use `load_figure_template()` in your app, it loads the json file, adds it to `plotly.io` and sets it as the default figure template for an app.  See more
  information about  Plotly figure templates [here](https://plotly.com/python/templates/).
  <br>
  <br>

  This library provides a figure template for the following Bootstrap/Bootswatch themes:
  templates = [
    "bootstrap",
    "cerulean",
    "cosmo",
    "cyborg",
    "darkly",
    "flatly",
    "journal",
    "litera",
    "lumen",
    "lux",
    "materia",
    "minty",
    "morph",
    "pulse",
    "quartz",
    "sandstone",
    "simplex",
    "sketchy",
    "slate",
    "solar",
    "spacelab",
    "superhero",
    "united",
    "vapor",
    "yeti",
    "zephyr"
  ]
  templates_dark = ['bootstrap_dark', 'cerulean_dark', 'cosmo_dark', 'cyborg_dark', 'darkly_dark', 'flatly_dark', 'journal_dark', 'litera_dark', 'lumen_dark', 'lux_dark', 'materia_dark', 'minty_dark', 'morph_dark', 'pulse_dark', 'quartz_dark', 'sandstone_dark', 'simplex_dark', 'sketchy_dark', 'slate_dark', 'solar_dark', 'spacelab_dark', 'superhero_dark', 'united_dark', 'vapor_dark', 'yeti_dark', 'zephyr_dark']
  Note in dark themes ["cyborg", "darkly", "slate", "solar", "superhero", "vapor"], there is not much difference in the figure templates in light or dark color modes.

  **ThemeChangerAIO** is an All-in-One component  composed  of a parent `html.Div` with
  the following components as children:
  - `dbc.Button` ("`switch`") Opens the Offcanvas component for user to select a theme.
  - `dbc.Offcanvas` ("`offcanvas`")
  - `dbc.RadioItems` ("`radio`").  The themes are displayed as RadioItems inside the `dbc.Offcanvas` component.
    The `value` is a url for the theme
  - `html.Div` is used as the `Output` of the clientside callbacks.
  The ThemeChangerAIO component updates the stylesheet  when the `value` of radio changes. (ie the user selects a new theme)
  - param: `radio_props` A dictionary of properties passed into the dbc.RadioItems component. The default `value` is `dbc.themes.BOOTSTRAP`
  - param: `button_props`  A dictionary of properties passed into the dbc.Button component.
  - param: `offcanvas_props`. A dictionary of properties passed into the dbc.Offcanvas component
  - param: `aio_id` The All-in-One component ID used to generate components' dictionary IDs.
  The All-in-One component dictionary IDs are available as:
  - ThemeChangerAIO.ids.radio(aio_id)
  - ThemeChangerAIO.ids.offcanvas(aio_id)
  - ThemeChangerAIO.ids.button(aio_id)

  **ThemeSwitchAIO** is an All-in-One component  composed  of a parent `html.Div` with the following components as children:
  - `dbc.Switch` ("`switch`") with icons to the left and right of the switch.
  - `dcc.Store` ("`store`") The `themes` are stored in the `data` prop.
  - `html.Div` is used as the `Output` of the clientside callbacks.
  The ThemeSwitchAIO component updates the stylesheet when triggered by changes to the `value` of `switch` or when
  the themes are updated in the "`store`" component.  The themes in the switch may be updated in a callback
  by changing the theme urls in the "`store`" component.
  - param: `switch_props` A dictionary of properties passed into the dbc.Switch component.
  - param: `themes` A list of two urls for the external stylesheets or pathnames to files.
  - param: `icons`  A dict of the icons to the left and right of the switch. The default is
    `{"left" :"fa fa-moon", "right" :"fa fa-sun"}`.
  - param: `aio_id` The All-in-One component ID used to generate component's dictionary IDs.
  The All-in-One component dictionary IDs are available as
  - ThemeSwitchAIO.ids.switch(aio_id)


pkgId: 70e780644ff7906445787372fd03ac351a093b13d068f979a80a2441c7b7895f
name: python-dash-chart-editor
arch: src
version: 0.0.1a5
epoch: 0
release: 1
summary: Dash wrapper for Plotly's react-chart-editor
url: https://github.com/BSd3v/dash-chart-editor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-chart-editor-0.0.1a5-1.src.rpm
checksum_type: sha256
description:
  Dash Chart Editor is a Dash component wrapper for the [Plotly React Chart Editor](https://github.com/plotly/react-chart-editor) package, enabling you to use an editor panel for Plotly charts in your Dash app.


  `pip install dash-chart-editor`

  To build locally see the [Contributing Guide](https://github.com/BSd3v/dash-chart-editor/blob/main/CONTRIBUTING.md)




  ![chart-editor-quickstart](https://user-images.githubusercontent.com/72614349/228352185-77700687-764b-424b-9384-83ca87c6050d.gif)



  ```python
  import dash_chart_editor as dce
  from dash import Dash, html
  import pandas as pd

  df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/solar.csv')
  app = Dash(__name__, external_scripts=["https://cdn.plot.ly/plotly-2.18.2.min.js"])


  app.layout = html.Div([
      html.H4("Dash Chart Editor Demo with the Plotly Solar dataset"),
      dce.DashChartEditor(dataSources=df.to_dict("list")),
  ])


  if __name__ == "__main__":
      app.run_server(debug=True)

  ```



  See more demo apps in the `/examples` folder

  - [quickstart.py](https://github.com/BSd3v/dash-chart-editor/blob/dev/examples/quickstart.py)  The quickstart app shown above.

  - [figure_templates.py](https://github.com/BSd3v/dash-chart-editor/blob/dev/examples/figure_templates.py) - A demo on how to use plotly figure templates with the chart editor.

  - [figure_templates_dbc.py](https://github.com/BSd3v/dash-chart-editor/blob/dev/examples/figure_templates_dbc.py) -  A demo of Bootstrap themed figure templates from the [Dash Bootstrap Templates](https://github.com/AnnMarieW/dash-bootstrap-templates) library.

  - [customize.py](https://github.com/BSd3v/dash-chart-editor/blob/dev/examples/customize.py) - Example of ways to customize DashChartEditor
    - add a logo with `logoSrc`
    - only allow certain figure types with `traceOptions`
    - set graph mode bar menu with `config`.  See all the options https://github.com/plotly/plotly.js/blob/master/src/plot_api/plot_config.js.

  - [default_figure.py](https://github.com/BSd3v/dash-chart-editor/blob/dev/examples/default_figure.py) - Shows how to add a default figure to use when the app starts.


  - [change_datasets.py](https://github.com/BSd3v/dash-chart-editor/blob/dev/examples/change_datasets.py) - An example showing loading different datasets in a dropdown

  - [display_dce_figure_in_dccGraph.py]() - This app shows how to save a figure edited in `dash-chart-editor` and using
  it in a different part of a dashboard - in this case it's displayed in a `dcc.Graph()`.

  - [three_figure_demo.py]() - This demos how to use a dash-chart-editor in a model to update three different figures in an app.



  We welcome contributions to dash-chart-editor. If you find a bug or something is unclear please submit a bug report, if you have ideas for new features please feel free to make a feature request.

  If you would like to submit a pull request, please read our [contributing guide](https://github.com/BSd3v/dash-chart-editor/blob/dev/CONTRIBUTING.md), which contains instructions on how to build and install dash-chart-editor locally, and how to submit the pull request itself.



  Access this documentation in your Python terminal with:
  ```
  >>> import dash_chart_editor
  >>> help(dash_chart_editor.DashChartEditor)

  ```

  ```
  - id (string; optional):
      Dash prop to be registered for use with callbacks.

  - annotateOptions (dict; default True):
      Options that drive the available options under the "Annotate"
      tree.

      `annotateOptions` is a boolean | dict with keys:

      - images (boolean; optional)

      - shapes (boolean; optional)

      - text (boolean; optional)

  - config (dict; default {editable: True}):
      Plotly config options, listed here:
      https://github.com/plotly/plotly.js/blob/master/src/plot_api/plot_config.js.

  - controlOptions (dict; default True):
      Options that drive the available options under the "Control"
      tree.

      `controlOptions` is a boolean | dict with keys:

      - menus (boolean; optional)

      - sliders (boolean; optional)

  - data (boolean | number | string | dict | list; optional):
      Output data of the chart editor.

  - dataSources (dict with strings as keys and values of type list; optional):
      Input dataSources for driving the chart editors selections.

  - figure (dict; optional):
       Output figure of the chart editor (dcc.Graph esk output).

  - frames (boolean | number | string | dict | list; optional):
      Output frames of the chart editor.

  - layout (boolean | number | string | dict | list; optional):
      Output layout of the chart editor.

  - loadFigure (dict with strings as keys and values of type boolean | number | string | dict | list; optional):
      {data, layout, frames} given to the chart, used to populate
      selections and chart when loading.

  - logoSrc (string; optional):
      Logo that will be displayed in the chart editor.

  - logoStyle (dict; optional):
      Style object of the Logo.

  - saveState (boolean; default True):
       When passed True, this will save the current state of the grid to `figure`.


  - structureOptions (dict; default True):
      Options that drive the available options under the "Structure"
      tree.

      `structureOptions` is a boolean | dict with keys:

      - subplots (boolean; optional)

      - traces (boolean; optional)

      - transforms (boolean; optional)

  - style (dict; default {width: '100%', height: '100%'}):
      style of the whole editing element, including charting area.

  - styleOptions (dict; default True):
      Options that drive the available options under the "Style" tree.

      `styleOptions` is a boolean | dict with keys:

      - axes (boolean; optional)

      - colorBars (boolean; optional)

      - general (boolean; optional)

      - legend (boolean; optional)

      - maps (boolean; optional)

      - traces (boolean; optional)

  - traceOptions (boolean | number | string | dict | list; optional):
      List of trace options to display.
   ```


pkgId: 6e583c1ace2b3449f8c44cd4910589dea33eb57a5594e7ce271e3ac4cc6872c7
name: python-dash-cm
arch: src
version: 0.1.25
epoch: 0
release: 1
summary: Description
url: https://pypi.org/project/dash-cm/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-cm-0.1.25-1.src.rpm
checksum_type: sha256
description:
  ```bash
  pip install --upgrade dash_cm
  ```

  Optionally:
  ```bash
  sudo tee /usr/local/bin/dashcm > /dev/null <<EOT


  exec "python" -m dash_cm "\$@"
  EOT
  sudo chmod +x /usr/local/bin/dashcm
  ```

  And then use as executable
  ```bash
  dashcm serve &
  ```

  To check used ports:
  `netstat -tulpn | grep LISTEN |grep 3000`




  Create the two following files:


  - `/usr/share/mime/packages/cardiac-model.xml`
      ```
      <?xml version="1.0" encoding="UTF-8"?>
          <mime-info xmlns="https://www.freedesktop.org/standards/shared-mime-info">
          <mime-type type="application/zip">
              <comment xml:lang="en">Cardiac Model</comment>
              <glob pattern="*.model"/>
              <glob pattern="*.zip"/>
          </mime-type>
      </mime-info>
      ```

  - `/usr/share/applications/cardiac-model.desktop`
      ```
      [Desktop Entry]
      Encoding=UTF-8
      Version=1.0
      Type=Application
      Terminal=true
      Exec=dashcm load %F
      Name=CardiacModel
      Icon=<path-to>/dash_cm/build/static/icons/logo_512.png
      ```


pkgId: ab459562f272403915b0c3f0787820d9cd843242a0b13c7b1e8e6962aaf1b495
name: python-dash-cognito-auth
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Dash Cognito Auth
url: https://github.com/fspijkerman/dash-cognito-auth
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-cognito-auth-0.0.5-1.src.rpm
checksum_type: sha256
description:
  ![Build + Test](https://github.com/fspijkerman/dash-cognito-auth/actions/workflows/build.yml/badge.svg) [![PyPI version](https://badge.fury.io/py/dash-cognito-auth.svg)](https://pypi.org/project/dash-cognito-auth/)

  Dash Cognito Auth is a simple library using Cognito OAuth to authenticate and
  view a [Dash](https://dash.plot.ly/) app.

  This Library uses [Flask Dance](https://github.com/singingwolfboy/flask-dance)
  and a modified version of Plotly's own [dash auth](https://github.com/plotly/dash-auth)
  for authentication.

  This Library is heavily inspired by [dash-google-oauth](https://github.com/lchapo/dash-google-auth) created by Lucas Chapin



  ```bash
  $ pip install dash-cognito-auth
  ```



  Authentication can be added to your Dash application using the `CognitoOAuth`
  class, i.e.

  ```python
  from dash import Dash
  from flask import Flask
  from dash_cognito_auth import CognitoOAuth

  server = Flask(__name__)
  server.config.update({
    'COGNITO_OAUTH_CLIENT_ID': ...,
    'COGNITO_OAUTH_CLIENT_SECRET': ...,
  })

  app = Dash(__name__, server=server, url_base_pathname="/")

  additional_scopes = [...]
  auth = CognitoOAuth(
     app,
     domain='mydomain',
     region='eu-west-1',
     additional_scopes,
     logout_url="/logout"
  )


  ...
  ```



  This repository contains a simple [Example App](example/) that demonstrates how to add Cognito authentication to your Dash app as well as the Login and Logout Flows.



  - Check out the repository
  - Run `pip install -r requirements.txt` to install the package
  - Run `pip install -r requirements-dev.txt` to install additional dependencies for running the tests
  - If you want to run the [Sample App](example/) or the end to end tests, it makes sense to deploy the [Cloudformation Template](example/aws_resources.yaml) in order to get a functioning User Pool + App Client
  - Run the tests locally
     - Use `python -m pytest tests --ignore-glob "*end_to_end*"` to exclude the integration / end to end tests that require a [Cognito Setup](#integration-tests)
     - Use `python -m pytest tests` to run all tests




  There are integration tests against a Cognito User Pool + App Client, if you want to run those - either create a `.env` file with this content or set the environment variables with the same name.

  ```shell

  COGNITO_USER_NAME=<username>
  COGNITO_EMAIL=<email-that-must-match>
  COGNITO_PASSWORD=<password>


  COGNITO_DOMAIN=<just-the-prefix>
  COGNITO_REGION=<aws-region-of-the-cognito-userpool>
  COGNITO_OAUTH_CLIENT_ID=<app-client-id>
  COGNITO_OAUTH_CLIENT_SECRET=<app-client-secret>
  ```


pkgId: 7374dce69ea2b39ac05297b3e3ffeb67dcf40a1d26f13969bd11154f8edcdc00
name: python-dash-core-components
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Core component suite for Dash
url: https://pypi.org/project/dash-core-components/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-core-components-2.0.0-1.src.rpm
checksum_type: sha256
description:
  This package provides the core React component suite for [Dash][].
  [![CircleCI](https://circleci.com/gh/plotly/dash-core-components.svg?style=svg)](https://circleci.com/gh/plotly/dash-core-components)

  The `dash` package contains some tools to build components and drive the bundles build process.
  To avoid the circular dependency situation, we don't add `dash` as a required install in the `dash-core-components` setup.
  But, in order to do development locally, you need to install `dash` before everything.
  1. Install the dependencies with:
  ```bash


  $ pip install virtualenv --user && virtualenv venv && . venv/bin/activate

  $ python -m venv venv && . venv/bin/activate

  $ pip install dash[dev,testing]  # in some shells you need \ to escape []

  $ npm i --ignore-scripts && npm run build

  $ pip install -e .
  ```


  You can run the Selenium integration tests with the
  ```sh
  npm test
  ```

  1. Run the build watcher by running
          $ npm run build:watch
  2. Run the dash layout you want to test
          
          $ python my_dash_layout.py

  ```sh
  $ npm run uninstall-local
  ```

  There's an npm script that will handle publish, provided you have the right credentials. You can run it by running
  ```sh
  $ npm run publish-all
  ```
  See the [Publishing New Components/Features](CONTRIBUTING.md#publishing-new-componentsfeatures) section of the Contributing guide for step-by-step instructions on publishing new components.

  See the [dash-component-boilerplate](https://github.com/plotly/dash-component-boilerplate) repo for more information.
  [Dash]: https://plotly.com/dash
  [Dash Component Boilerplate]: (https://github.com/plotly/dash-component-boilerplate)
  [NPM package authors]: https://www.npmjs.com/package/dash-core-components/access
  [PyPi]: https://pypi.python.org/pypi

  Cross-browser Testing Powered by [![image](https://user-images.githubusercontent.com/1394467/64290307-e4c66600-cf33-11e9-85a1-12c82230a597.png)](https://saucelabs.com)


pkgId: d2ef5e4c07abd957d06e8d19a1e8732013fc862098720cde300dee1f944f44a2
name: python-dash-cytoscape
arch: src
version: 1.0.2
epoch: 0
release: 1
url: https://dash.plotly.com/cytoscape
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-cytoscape-1.0.2-1.src.rpm
checksum_type: sha256
summary:
  A Component Library for Dash aimed at facilitating network visualization in Python, wrapped around Cytoscape.js

description:
  <div align="center">
    <a href="https://dash.plotly.com/project-maintenance">
      <img src="https://dash.plotly.com/assets/images/maintained-by-plotly.png" width="400px" alt="Maintained by Plotly">
    </a>
  </div>


  [![CircleCI](https://circleci.com/gh/plotly/dash-cytoscape.svg?style=svg)](https://circleci.com/gh/plotly/dash-cytoscape)

  A Dash component library for creating interactive and customizable networks in Python, wrapped around [Cytoscape.js](http://js.cytoscape.org/).

  ![usage-stylesheet-demo](https://raw.githubusercontent.com/plotly/dash-cytoscape/master/demos/images/usage-stylesheet-demo.gif)

  -   🌟 [Medium Article](https://medium.com/@plotlygraphs/introducing-dash-cytoscape-ce96cac824e4)
  -   📣 [Community Announcement](https://community.plotly.com/t/announcing-dash-cytoscape/19095)
  -   💻 [Github Repository](https://github.com/plotly/dash-cytoscape)
  -   📚 [User Guide](https://dash.plotly.com/cytoscape)
  -   🗺 [Component Reference](https://dash.plotly.com/cytoscape/reference)
  -   📺 [Webinar Recording](https://www.youtube.com/watch?v=snXcIsCMQgk)





  Make sure that dash and its dependent libraries are correctly installed:

  ```commandline
  pip install dash
  ```

  If you want to install the latest versions, check out the [Dash docs on installation](https://dash.plotly.com/installation).



  Install the library using `pip`:

  ```
  pip install dash-cytoscape
  ```

  If you wish to use the CyLeaflet mapping extension, you must install the optional `leaflet` dependencies:

  ```
  pip install dash-cytoscape[leaflet]
  ```

  Create the following example inside an `app.py` file:

  ```python
  import dash
  import dash_cytoscape as cyto
  from dash import html

  app = dash.Dash(__name__)
  app.layout = html.Div([
      cyto.Cytoscape(
          id='cytoscape',
          elements=[
              {'data': {'id': 'one', 'label': 'Node 1'}, 'position': {'x': 50, 'y': 50}},
              {'data': {'id': 'two', 'label': 'Node 2'}, 'position': {'x': 200, 'y': 200}},
              {'data': {'source': 'one', 'target': 'two','label': 'Node 1 to 2'}}
          ],
          layout={'name': 'preset'}
      )
  ])

  if __name__ == '__main__':
      app.run_server(debug=True)
  ```

  ![basic-usage](https://raw.githubusercontent.com/plotly/dash-cytoscape/master/demos/images/basic-usage.gif)



  You can also add external layouts. Use the `cyto.load_extra_layouts()` function to get started:

  ```python
  import dash
  import dash_cytoscape as cyto
  from dash import html

  cyto.load_extra_layouts()

  app = dash.Dash(__name__)
  app.layout = html.Div([
      cyto.Cytoscape(...)
  ])
  ```

  Calling `cyto.load_extra_layouts()` also enables generating SVG images.





  ```R
  install.packages(c("devtools", "dash"))
  ```



  Install the library using devtools:

  ```
  devtools::install_github("plotly/dash-cytoscape")
  ```

  Create the following example inside an `app.R` file:

  ```R
  library(dash)
  library(dashHtmlComponents)
  library(dashCytoscape)

  app <- Dash$new()

  app$layout(
    htmlDiv(
      list(
        cytoCytoscape(
          id = 'cytoscape-two-nodes',
          layout = list('name' = 'preset'),
          style = list('width' = '100%', 'height' = '400px'),
          elements = list(
            list('data' = list('id' = 'one', 'label' = 'Node 1'), 'position' = list('x' = 75, 'y' = 75)),
            list('data' = list('id' = 'two', 'label' = 'Node 2'), 'position' = list('x' = 200, 'y' = 200)),
            list('data' = list('source' = 'one', 'target' = 'two'))
          )
        )
      )
    )
  )

  app$run_server()
  ```



  The [Dash Cytoscape User Guide](https://dash.plotly.com/cytoscape/) contains everything you need to know about the library. It contains useful examples, functioning code, and is fully interactive. You can also use the [component reference](https://dash.plotly.com/cytoscape/reference/) for a complete and concise specification of the API.

  To learn more about the core Dash components and how to use callbacks, view the [Dash documentation](https://dash.plotly.com/).

  For supplementary information about the underlying Javascript API, view the [Cytoscape.js documentation](http://js.cytoscape.org/).



  Make sure that you have read and understood our [code of conduct](CODE_OF_CONDUCT.md), then head over to [CONTRIBUTING](CONTRIBUTING.md) to get started.



  Instructions on how to run [tests](CONTRIBUTING.md#tests) are given in [CONTRIBUTING.md](CONTRIBUTING.md).



  Dash, Cytoscape.js and Dash Cytoscape are licensed under MIT. Please view [LICENSE](LICENSE) for more details.



  See https://plotly.com/dash/support for ways to get in touch.



  Huge thanks to the Cytoscape Consortium and the Cytoscape.js team for their contribution in making such a complete API for creating interactive networks. This library would not have been possible without their massive work!

  The Pull Request and Issue Templates were inspired from the
  [scikit-learn project](https://github.com/scikit-learn/scikit-learn).





  [Code](usage-elements.py) | [Demo](https://dash-gallery.plotly.host/cytoscape-elements)
  ![View usage-elements on Github](demos/images/usage-elements-demo.gif)



  [Code](usage-stylesheet.py) | [Demo](https://dash-gallery.plotly.host/cytoscape-stylesheet)
  ![View usage-stylesheet on Github](demos/images/usage-stylesheet.gif)



  [Code](demos/usage-phylogeny.py) | [Demo](https://dash-gallery.plotly.host/cytoscape-phylogeny/)
  ![View usage-phylogeny on Github](demos/images/usage-phylogeny.gif)



  [Code](usage-advanced.py) | [Demo](https://dash-gallery.plotly.host/cytoscape-advanced)
  ![View usage-advanced on Github](demos/images/usage-advanced.gif)



  [Code](usage-events.py) | [Demo](https://dash-gallery.plotly.host/cytoscape-events)
  ![View usage-events on Github](demos/images/usage-events.gif)



  [Code](demos/usage-elements-extra.py)
  ![View usage-elements-extra on Github](demos/images/usage-elements-extra.gif)



  [Code](demos/usage-image-export.py)
  ![View usage-image-export on Github](demos/images/usage-image-export.gif)



  [Code](demos/usage-responsive-graph.py)
  ![View usage-responsive-graph on Github](demos/images/usage-responsive-graph.gif)

  For an extended gallery, visit the [demos' readme](demos/README.md).


pkgId: a4780ec1557d92f16a9ab74ef0f340c6871e2c9a2cd513c2b50500cec228222f
name: python-dash-daq
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: DAQ components for Dash
url: http://github.com/plotly/dash-daq
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-daq-0.5.0-1.src.rpm
checksum_type: sha256
description:
  DAQ components for Dash.

  Docs: https://dash.plotly.com/dash-daq



  `pip install dash_daq`

  (Or for Python 3, `pip3 install dash_daq`)



  ```sh

  git clone https://github.com/plotly/dash-daq.git


  $ yarn


  $ yarn start
  ```


  Component API documentation can be found at https://dash.plotly.com/dash-daq





  You can start up a demo development server to see a demo of the rendered
  components:

  ```sh
  $ yarn demo
  $ open http://localhost:9000
  ```

  You have to maintain the list of components in `demo/Demo.react.js`.





  ```sh
  $ yarn test
  ```



  1. Build development bundle to `lib/` and watch for changes

          
          $ yarn start

  2. Install module locally (after every change)

          
          $ yarn install-local

          
          
          $ python setup.py install

  3. Run the Dash demo

          $ python demo.py




  Before publishing to PyPi, you can test installing the module locally:

  ```sh

  $ yarn run install-local
  ```



  ```sh
  $ yarn run uninstall-local
  ```




  ```sh
  vim dash_daq/version.py # and increase it to X.X.X
  rm -rf node_modules dist build lib
  yarn install
  yarn build-tarball
  ls dist/dash_daq-X.X.X.tar.gz # this is your tarball
  ```


   * Dash Daq HP Multimeter - [http://dash-gallery.plotly.host/dash-daq-hp-multimeter](http://dash-gallery.plotly.host/dash-daq-hp-multimeter)
   * Dash Daq IV Tracer - [http://dash-gallery.plotly.host/dash-daq-iv-tracer](http://dash-gallery.plotly.host/dash-daq-iv-tracer)
   * Dash Daq LED Control - [http://dash-gallery.plotly.host/dash-daq-led](http://dash-gallery.plotly.host/dash-daq-led)
   * Dash Daq Omega PID - [http://dash-gallery.plotly.host/dash-daq-omega-pid](http://dash-gallery.plotly.host/dash-daq-omega-pid)
   * Dash Daq Pressure Gauge KJL - [http://dash-gallery.plotly.host/dash-daq-pressure-gauge-kjl](http://dash-gallery.plotly.host/dash-daq-pressure-gauge-kjl)
   * Dash Daq Pressure Gauge Pfeiffer - [https://dash-gallery.plotly.host/dash-daq-pressure-gauge-pv](https://dash-gallery.plotly.host/dash-daq-pressure-gauge-pv)
   * Dash Daq Robotic Arm Edge - [http://dash-gallery.plotly.host/dash-daq-robotic-arm](http://dash-gallery.plotly.host/dash-daq-robotic-arm)
   * Dash Daq Sparki - [http://dash-gallery.plotly.host/dash-daq-sparki](http://dash-gallery.plotly.host/dash-daq-sparki)
   * Dash Daq Stepper Motor - [http://dash-gallery.plotly.host/dash-daq-stepper-motor](http://dash-gallery.plotly.host/dash-daq-stepper-motor)
   * Dash Tektronix 350 - [http://dash-gallery.plotly.host/dash-daq-tektronix350](http://dash-gallery.plotly.host/dash-daq-tektronix350)
   * Dash Ocean Optics - [http://dash-gallery.plotly.host/dash-ocean-optics](http://dash-gallery.plotly.host/dash-ocean-optics)


pkgId: c8660dcc648b3f81a516d026749702bd2bdf876d602872eb863b1d33515f85ac
name: python-dash-datetimepicker
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Dash component to select date and times
url: https://pypi.org/project/dash-datetimepicker/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-datetimepicker-0.0.7-1.src.rpm
checksum_type: sha256
description:
  This is a dash datetime range picker based on [react-datetime](https://github.com/YouCanBookMe/react-datetime).
  In contrast to the dash datepicker from dash-core-components, it is also possible to specify hours and minutes on a certain day.



  ```bash

  docker-compose up
  docker exec -it dash-datepicker bash


  cookiecutter https://github.com/plotly/dash-component-boilerplate.git


  cd dash_datetimepicker


  . venv/bin/activate
  pip install -r requirements.txt
  python usage.py


  npm start


  npm run build
  ```



  ```bash

  deactivate
  python setup.py sdist
  pip install dist/dash_datetimepicker-0.0.6.tar.gz
  python usage.py


  twine check dist/*
  twine upload dist/*

  rm -rf dist

  npm login
  npm publish


  pip install dash_datetimepicker
  python dash_datetimepicker/usage.py
  ```


pkgId: d76b85116b13e93e76d9a708f692a4569ff0ec82e92558ab3b8ea4cf93c59cf3
name: python-dash-devextreme
arch: src
version: 0.16.6
epoch: 0
release: 1
summary: Wrapper of DevExtreme components for Plotly Dash
url: https://pypi.org/project/dash-devextreme/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-devextreme-0.16.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dash-devextreme.svg)](https://pypi.org/project/dash-devextreme/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dash_devextreme.svg)
  [![NPM](https://img.shields.io/npm/v/dash-devextreme.svg)](https://www.npmjs.com/package/dash-devextreme)
  [![PyPI - License](https://img.shields.io/pypi/l/dash-devextreme.svg)](./LICENSE)

  Wrapper of [DevExtreme][] components for Plotly [Dash][]




  ```bash
  $ pip install dash_devextreme
  ```



  ```python
  import dash
  import dash_devextreme as ddx
  import dash_html_components as html


  data = [
      {'id': 1, 'name': 'Sales', 'text': 'abc'},
      {'id': 2, 'parent_id': 1, 'name': 'Sales 1', 'text': 'abc'},
      {'id': 3, 'parent_id': 1, 'name': 'Sales 2', 'text': 'abc'},
      {'id': 4, 'name': 'Developers', 'text': 'abc'},
      {'id': 5, 'parent_id': 4, 'name': 'Dev 1', 'text': 'abc'},
  ]

  app = dash.Dash('')
  app.scripts.config.serve_locally = True

  app.layout = html.Div(children=[
      ddx.TreeList(
          dataSource=data,
          columns=[
              {'dataField': 'name', 'width': 290},
              {'dataField': 'text'},
          ],
          keyExpr='id',
          parentIdExpr='parent_id',
          width='100%'
      )
  ])


  if __name__ == '__main__':
      app.run_server(debug=True)
  ```



  Go to this link to learn about [Dash][].

  See the [dash-component-boilerplate][] repo for more information.



  MIT

  [DevExtreme]: https://js.devexpress.com/
  [Dash]: https://github.com/plotly/dash
  [dash-component-boilerplate]: https://github.com/plotly/dash-component-boilerplate


pkgId: 7972ebba68648e97598565b669c8b48bdeb3b4617b66b9b0bba6afd291320598
name: python-dash-down
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/emilhe/dash-down
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-down-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![Unit tests](https://github.com/emilhe/dash-down/actions/workflows/python-test.yml/badge.svg)](https://github.com/emilhe/dash-down/actions/workflows/python-test.yml)
  [![codecov](https://codecov.io/gh/emilhe/dash-down/branch/main/graph/badge.svg?token=kZXx2N1QGY)](https://codecov.io/gh/emilhe/dash-down)

  The `dash-down` package provides tools to render markdown files into Plotly Dash component trees. Besides standard markdown syntax, a custom interpretation of the [directive syntax extension](https://mistune.readthedocs.io/en/latest/directives.html) makes it possible to embed Dash code blocks and/or applications (including callbacks). For a live demo, please take look at the [`dash-extensions` documentation](https://www.dash-extensions.com/sections/installation).



  Make sure that you have setup [poetry](https://python-poetry.org/). Then run

      poetry install

  to install dependencies.



      poetry run python example.py



      poetry run pytest



  Custom content is rendered via the markdown [directive syntax extension](https://mistune.readthedocs.io/en/latest/directives.html). A directive has the following syntax,

      .. directive-name:: directive value
         :option-key: option value
         :option-key: option value

         full featured markdown text here

  where the `directive-name` is mandatory, while the `value`, the `options` (specified as key value pairs), and the `text` are optional.



  Currently, the bundled directives are

  * **api-doc** - a directive for rendering api documentation for a component
  * **dash-proxy** - a directive for rendering dash apps (including interactivity)



  The easiest way to create a custom directive is to create a function with the following signature,

  ```python
  from box import Box
  from dash_extensions.enrich import DashBlueprint

  def directive_name(value: str, text: str, options: Box[str, str], blueprint: DashBlueprint):
      """
      :param value: the directive value (optional)
      :param text: the markdown text (optional)
      :param options: a Box object containing all key value pairs (optional)
      :param blueprint: the DashBlueprint of the resulting Dash component tree, used e.g. for callback registration
      :return: a Dash component
      """
      ...
  ```

  Say, we want to make a new directive that yields a plot of the `iris` dataset. The code would then be along the lines of,

  ```python
  import plotly.express as px
  from box import Box
  from dash_extensions.enrich import dcc, DashBlueprint

  def graph(value: str, text: str, options: Box[str, str], blueprint: DashBlueprint):
      df = getattr(px.data, options.dataset)()
      fig = px.scatter(df, x=options.x, y=options.y)
      return dcc.Graph(figure=fig)
  ```

  With this directive defined, it is now possible to create a graph similar to [the one in the Dash docs](https://dash.plotly.com/dash-core-components/graph) with the following syntax,

      .. graph::
         :dataset: iris
         :x: sepal_width
         :y: sepal_length

  To render a markdown file using the new, shiny directive, the syntax would be,

  ```python
  from dash_extensions.enrich import DashProxy
  from dash_down.express import md_to_blueprint_dmc, GITHUB_MARKDOWN_CSS_LIGHT

  ...

  blueprint = md_to_blueprint_html('path_to_your_md_file', directives=[graph])
  app = DashProxy(blueprint=blueprint, external_stylesheets=[GITHUB_MARKDOWN_CSS_LIGHT])

  if __name__ == '__main__':
      app.run_server()
  ```

  A working example is bundled in the repo (see `example_custom_directive.py`).



  The layout of the blueprint returned by the renderer can be customized by passing a custom app shell via the `shell` keyword of the `md_to_blueprint_html` function. A working example is bundled in the repo (see `example_code_renderer.py`).

  Per default, the app shell is a `Div` element with `className="markdown-body"`. This class makes it possible to use GitHub CSS for styling.



  The layout of the Dash apps rendered via the `DashProxyDirective` can be customized via the `dash_proxy_shell` keyword of the `md_to_blueprint_html` function. A working example is bundled in the repo (see `example_code_renderer.py`).

  Per default, the app shell `Div` element with the code rendered as the first child and the resulting app rendered as the second.



  Make a subclass of `DashMantineRenderer` (or `DashHtmlRenderer`, if you prefer to start from raw HTML) and override the render function(s) for any element that you want to change. A good place to start would be to look at the `DashMantineRenderer` class itself for inspiration.


pkgId: 0ead8f42f3d8c1e312f56f3bfec078ae6323ab0cefa67256c28e4add74982eac
name: python-dash-draggable
arch: src
version: 0.1.2
epoch: 0
release: 1
url: https://pypi.org/project/dash-draggable/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-draggable-0.1.2-1.src.rpm
checksum_type: sha256
summary:
  A Dash component for building draggable and resizable grid layouts. Based on the well-known react-grid-layout.


pkgId: 9f8407f3a027507ea05ac9e0f7fda030fe1be58eafb83c74d905d44bae172f53
name: python-dash-enterprise-auth
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Authentication integrations for apps using Dash Enterprise
url: https://plotly.com/dash
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-enterprise-auth-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Authentication for apps deployed to [Dash Enterprise](https://plotly.com/dash)

  Learn more at https://dash.plotly.com/dash-enterprise/app-authentication

  ```py
  import dash_enterprise_auth as auth

  @callback(...)
  def private_data(...):
      username = auth.get_username()
      if username:
          return get_view_for_user(username)
      else:
          return public_view()
  ```


pkgId: e12aad78f86ab3a868457107462ecc9f9b0c6587425ca7a22270303a806d5c69
name: python-dash-enterprise-auth
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Authentication integrations for apps using Dash Enterprise
url: https://plotly.com/dash
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-enterprise-auth-0.2.3-1.src.rpm
checksum_type: sha256
description:
  Authentication for apps deployed to [Dash Enterprise](https://plotly.com/dash)

  Learn more at https://dash.plotly.com/dash-enterprise/app-authentication

  <div align="center">
    <a href="https://dash.plotly.com/project-maintenance">
      <img src="https://dash.plotly.com/assets/images/maintained-by-plotly.png" width="400px" alt="Maintained by Plotly">
    </a>
  </div>

  ```py
  import dash_enterprise_auth as auth

  @callback(...)
  def private_data(...):
      username = auth.get_username()
      if username:
          return get_view_for_user(username)
      else:
          return public_view()
  ```


pkgId: 6e12c5ff5cce066296235aeeb569fe3c3e1ed3688e7e7daa2e6e5a5c03294048
name: python-dash-express-components
arch: src
version: 0.0.110
epoch: 0
release: 1
summary: Simple widgets to add plotly express style plotting to dash
url: https://github.com/VK/dash-express-components
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-express-components-0.0.110-1.src.rpm
checksum_type: sha256
description:
  ![Publish release](https://github.com/VK/dash-express-components/workflows/Publish%20release/badge.svg)
  [![PyPI](https://img.shields.io/pypi/v/dash-express-components?logo=pypi)](https://pypi.org/project/dash-express-components)
  [![npm](https://img.shields.io/npm/v/dash_express_components.svg?logo=npm)](https://www.npmjs.com/package/dash_express_components)
  [![Documentation](https://github.com/VK/dash-express-components/workflows/Documentation/badge.svg)](https://vk.github.io/dash-express-components)
  [![Test](https://github.com/VK/dash-express-components/actions/workflows/test.yml/badge.svg)](https://github.com/VK/dash-express-components/actions/workflows/test.yml)
  [![codecov](https://codecov.io/gh/VK/dash-express-components/branch/main/graph/badge.svg?token=13XCRAQY0D)](https://codecov.io/gh/VK/dash-express-components)



  * [**dxc.Filter**](https://vk.github.io/dash-express-components/Filter.html) to define  filter configurations for numerical, categorical or temporal columns.
  * [**dxc.Transform**](https://vk.github.io/dash-express-components/Transform.html) to specify a series of data transformations like melt, group by or aggregate.
  * [**dxc.Plotter**](https://vk.github.io/dash-express-components/Plotter.html) to set a plot layout like scatter, box, image or table.
  * [**dxc.Configurator**](https://vk.github.io/dash-express-components/Configurator.html) is a component that combines
  [**dxc.Filter**](https://vk.github.io/dash-express-components/Filter.html),
  [**dxc.Transform**](https://vk.github.io/dash-express-components/Transform.html) and
  [**dxc.Plotter**](https://vk.github.io/dash-express-components/Plotter.html)
  to make the components even easier to use, since the interaction between them is handled automatically.
  * [**dxc.Graph**](https://vk.github.io/dash-express-components/Graph.html) uses [dcc.Graph](https://dash.plotly.com/dash-core-components/graph) and [dash_table.DataTable](https://dash.plotly.com/datatable) to show a plot or a table based on the plot configuration.





  <img align="right" src="https://raw.githubusercontent.com/VK/dash-express-components/main/.media/dataflow.png" width="370px">

  First, the metadata is extracted from the dataframe ***df*** with **dxc.get_meta(*df*)**. This ***meta*** json is needed for
  [**dxc.Filter**](https://vk.github.io/dash-express-components/Filter.html),
  [**dxc.Transform**](https://vk.github.io/dash-express-components/Transform.html) or  [**dxc.Plotter**](https://vk.github.io/dash-express-components/Plotter.html) to show all options without additional queries to the dataframe. As a result, the components react quite quickly.

  Since the metadata can be changed by filter or transform operations, and we don't want additional server calls, the changes are directly computed in the web components. You can access the metadata after transformations via the ***meta_out*** property of [**dxc.Filter**](https://vk.github.io/dash-express-components/Filter.html) and [**dxc.Transform**](https://vk.github.io/dash-express-components/Transform.html).

  A combined ***config*** is needed to compute the final plot with **dxc.get_plot(*df*, *config*)**. You can combine the configurations of each component yourself or use the [**dxc.Configurator**](https://vk.github.io/dash-express-components/Configurator.html) to get a combined configuration like:

  <img align="right" src="https://raw.githubusercontent.com/VK/dash-express-components/main/.media/box.png" width="370px">

  ```python
  {
      "filter": [
          {
              "col": "continent",
              "type": "isnotin",
              "value": ["Oceania"]
          }
      ],
      "transform": [
          {
              "type": "aggr",
              "groupby": [
                  "country",
                  "continent"
              ],
              "cols": ["gdpPercap"],
              "types": ["median"]
          }
      ],
      "plot": {
          "type": "box",
          "params": {
              "x": "continent",
              "y": "gdpPercap_median",
              "color": "continent",
              "aggr": ["mean"],
              "reversed_x": True
          }
      }
  }
  ```

  An example with the gapminder dataset and [**dash-lumino-components**](https://github.com/VK/dash-lumino-components) for the MDI layout.
  ![example](https://raw.githubusercontent.com/VK/dash-express-components/main/examples/lumino/recording.gif)




  Install dependencies
  ```console
  $ pip install dash-express-components
  ```
  and start with quickly editable graphs:
  ```python
  import dash_express_components as dxc
  app.layout = html.Div([

      
      html.Div([
          dxc.Configurator(
              id="plotConfig",
              meta=meta,
          ),
      ], style={"width": "500px", "float": "left"}),

      
      html.Div([
          dxc.Graph(id="fig",
                    meta=meta,
                    style={"height": "100%", "width": "100%"}
                   )],
          style={"width": "calc(100% - 500px)", "height": "calc(100vh - 30px)",
                 "display": "inline-block", "float": "left"}
      )
  ])
  ```


  1. Install npm packages
      ```console
      $ npm install
      ```

  2. Create a virtual env and activate.
      ```console
      $ virtualenv venv
      $ . venv/bin/activate
      ```
      _Note: venv\Scripts\activate for windows_

  3. Install python packages required to build components.
      ```console
      $ pip install -r requirements.txt
      ```

  4. Build your code
      ```console
      $ npm run build
      ```

  5. Run the example
      ```console
      $ python usage.py
      ```


pkgId: a8a042683f93e1df97a9eeda142dce350315bc28cf5724aba582f613ff06a22b
name: python-dash-extendable-graph
arch: src
version: 1.3.0
epoch: 0
release: 1
url: https://github.com/bcliang/dash-extendable-graph
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-extendable-graph-1.3.0-1.src.rpm
checksum_type: sha256
summary:
  A Dash Graph component modified to support use of figure.data-structured input to extend and/or add traces.

description:
  `dash-extendable-graph` is a Dash component library containing a single component: `ExtendableGraph`. The component was forked from Plotly's core `Graph` component ([dash-core-components](https://github.com/plotly/dash-core-components)). `dash-extendable-graph` has modified `extendData` and `prependData` properties that accept trace data matching the format for `figure["data"]`. These properties support (1) adding new traces and (2) allow multiple trace types to be extended/prepended within a single callback (not supported by the core component)

  Note: As of version 1.1.0, `dash-extendable-graph` includes a minimized plotly.js as an internal dependency. Previously, the component assumed it would be used in conjunction with `dash-core-components`.

  [![PyPI](https://img.shields.io/pypi/v/dash-extendable-graph.svg)](https://pypi.org/project/dash-extendable-graph/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dash-extendable-graph.svg)
  [![PyPI - License](https://img.shields.io/pypi/l/dash-extendable-graph.svg)](./LICENSE)



  Get started with:
  1. Install Dash and dependencies: https://dash.plot.ly/installation
  ```bash
  $ pip install -r requirements.txt
  ```
  2. Install dash-extendable-graph
  ```bash
  $ pip install dash-extendable-graph
  ```
  3. Run `python usage.py`
  4. Visit http://localhost:8050 in your web browser



  General examples may be found in `usage.py`



  1. `updateData` [list]: a list of dictionaries, each dictionary representing trace data in a format matching `figure['data']` (e.g `dict(x=[1], y=[1])`)
  2. `traceIndices` [list, optional]: identify the traces that should be extended. If the specified trace index does not exist, a (new) corresponding trace shall be appended to the figure.
  3. `maxPoints` [number, optional]: define the maximum number of points to plot in the figure (per trace).

  Based on the [`Plotly.extendTraces()` api](https://github.com/plotly/plotly.js/blob/master/src/plot_api/plot_api.js#884). However, the `updateData` key has been modified to better match the contents of `Plotly.plot()` (e.g. `Graph.figure`). Aside from following dash-familiar styling, this component allows the user to extend traces of different types in a single call (`Plotly.extendTraces()` takes a map of key:val and assumes all traces will share the same data keys).



  1. `updateData` [list]: a list of dictionaries, each dictionary representing trace data in a format matching `figure['data']` (e.g `dict(x=[1], y=[1])`)
  2. `traceIndices` [list, optional]: identify the traces that should be extended. If the specified trace index does not exist, a (new) corresponding trace shall be appended to the figure.
  3. `maxPoints` [number, optional]: define the maximum number of points to plot in the figure (per trace).

  Based on the [`Plotly.prependTraces()` api](https://github.com/plotly/plotly.js/blob/master/src/plot_api/plot_api.js#L942). However, the `updateData` key has been modified to better match the contents of `Plotly.plot()` (e.g. `Graph.figure`). Aside from following dash-familiar styling, this component allows the user to prepend traces of different types in a single call (`Plotly.prependTraces()` takes a map of key:val and assumes all traces will share the same data keys).



  Extend a trace once per second, limited to 100 maximum points.

  ```python
  import dash_extendable_graph as deg
  import dash
  from dash.dependencies import Input, Output, State
  import dash_html_components as html
  import dash_core_components as dcc
  import random

  app = dash.Dash(__name__)

  app.scripts.config.serve_locally = True
  app.css.config.serve_locally = True

  app.layout = html.Div([
      deg.ExtendableGraph(
          id='extendablegraph_example',
          figure=dict(
              data=[{'x': [0],
                     'y': [0],
                     'mode':'lines+markers'
                     }],
          )
      ),
      dcc.Interval(
          id='interval_extendablegraph_update',
          interval=1000,
          n_intervals=0,
          max_intervals=-1),
      html.Div(id='output')
  ])


  @app.callback(Output('extendablegraph_example', 'extendData'),
                [Input('interval_extendablegraph_update', 'n_intervals')],
                [State('extendablegraph_example', 'figure')])
  def update_extendData(n_intervals, existing):
      x_new = existing['data'][0]['x'][-1] + 1
      y_new = random.random()
      return [dict(x=[x_new], y=[y_new])], [0], 100


  if __name__ == '__main__':
      app.run_server(debug=True)

  ```



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



  1. Dependencies
  ```bash
  $ npm install
  $ virtualenv venv
  $ . venv/bin/activate
  $ pip install -r requirements.txt
  ```

  For developers:
  ```
  $ pip install -r tests/requirements.txt
  ```

  2. Build
  ```bash
  $ npm run build
  ```
  3. Check out the component via component-playground
  ```bash
  $ npm run start
  ```
      The demo app is in `src/demo`
  4. Check out the sample Dash application using the component
  ```bash
  $ python setup.py install
  $ python usage.py
  ```



  [![lgtm](https://img.shields.io/lgtm/grade/javascript/g/bcliang/dash-extendable-graph.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/bcliang/dash-extendable-graph/context:javascript)



  Run linting + integration tests in one command:

  ```bash
  $ npm run test
  ```

  Or run tests individually:



  Uses `flake8`, `eslint`, and `prettier`. Check `package.json`, `.eslintrc`, `.eslintignore` for configuration settings.
  ```bash
  $ npm run lint
  ```

  Also you can apply formatting settings.
  ```bash
  $ npm run format
  ```



  Integration tests for the component can be found in `tests/`
  ```bash
  $ pytest
  ```

  Selenium test runner configuration options are located in `pytest.ini` (e.g. `--webdriver`, `--headless`). See `dash[testing]` documentation for more information on built-ins provided by the dash test fixture.

  Run individual integration tests based on the filename.
  ```bash
  $ pytest tests/test_extend_maxpoints.py
  ```



  [![CI](https://github.com/bcliang/dash-extendable-graph/actions/workflows/python-js-package.yml/badge.svg)](https://github.com/bcliang/dash-extendable-graph/actions/workflows/python-js-package.yml)

  This repository uses a github action to automate integration testing. Linting and Tests are triggered for each pull request created in the `master` branch.



  [![Publish](https://github.com/bcliang/dash-extendable-graph/actions/workflows/publish.yml/badge.svg)](https://github.com/bcliang/dash-extendable-graph/actions/workflows/publish.yml)

  This repository uses a github action to automate package deployment (in this case, compiling a source archive and binary wheel using `setuptools`). Publishing is triggered on each published release.


pkgId: 0596da5ddbbb81681cc0dfba38fb2aa8d26176fe1ffe5eb9515a469759455663
name: python-dash-extensions
arch: src
version: 1.0.18
epoch: 0
release: 1
summary: Extensions for Plotly Dash.
url: https://dash-extensions.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-extensions-1.0.18-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Latest Release](https://img.shields.io/pypi/v/dash-extensions.svg)](https://pypi.org/project/dash-extensions/)
  [![codecov](https://img.shields.io/codecov/c/github/thedirtyfew/dash-extensions?logo=codecov)](https://codecov.io/gh/thedirtyfew/dash-extensions)
  [![Testing](https://github.com/thedirtyfew/dash-extensions/actions/workflows/python-test.yml/badge.svg)](https://github.com/thedirtyfew/dash-extensions/actions/workflows/python-test.yml)
  [![CodeQL](https://github.com/thedirtyfew/dash-extensions/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/thedirtyfew/dash-extensions/actions/workflows/codeql-analysis.yml)

  The `dash-extensions` package is a collection of utility functions, syntax extensions, and Dash components that aim to improve the Dash development experience. It can be divided in five main pillars,

  * The `enrich` module, which contains various enriched versions of Dash components
  * A number of custom components, e.g. the `Websocket` component, which enables real-time communication and push notifications
  * The `javascript` module, which contains functionality to ease the interplay between Dash and JavaScript
  * The `pages` module, which extends the functionality of [Dash Pages](https://dash.plotly.com/urls)
  * The `snippets/validation/streaming` modules, which contain a collection of utility functions (documentation limited to source code comments)

  The `enrich` module enables a number of _transforms_ that add functionality and/or syntactic sugar to Dash. Examples include

  * Making it possible to avoid invoking a callback _if it is already running_ via the `BlockingCallbackTransform`
  * Enabling logging from within Dash callbacks via the `LogTransform`
  * Improving app performance via the `ServersideOutputTransform`

  to name a few. To enable interactivity, the documentation has been moved to a [separate page](http://dash-extensions.com).

  NB: The 1.0.0 version introduces a number of breaking changes, see documentation for details.



  [![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=Z9RXT5HVPK3B8&currency_code=DKK&source=url)


pkgId: ed9c0ec9174d632fbaf55a0f33109d2aa6b7fa420ebe39d2bb9a1ccf1cfb6f0f
name: python-dash-flash
arch: src
version: 0.1.0a1
epoch: 0
release: 1
summary: Flash - async port of the Dash framework
url: https://github.com/chgiesse/flash
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-flash-0.1.0a1-1.src.rpm
checksum_type: sha256
description:
  `Flash` is a async patch of the [Plotly Dash](https://github.com/plotly/dash) library, building on Quart as backend instead of Flask. It is very inspired by the already existing [dash-async](https://github.com/snehilvj/async-dash) repo, but covering all **features up to Dash 2.18.2**

  Quarts async capabilities are directly baked into the standard library, making it easy to inject into existing projects.

  Flash makes it possible to run **true async callbacks** and layout functions while running sync functions in a separate thread (_asyncio.run_in_executor_).

  With [dash-extensions](https://www.dash-extensions.com/) you can create native websocket components and handle server side events making your application realtime compatible.


  - [Motivation]('#motivation')
  - [Caveats](#caveats)
  - [Known Issues](#known-issues)
  - [TODO](#todo)


  One of my biggest pain points in Dash was to handle database requests, forcing me to add quite alot callbacks to first fetch a lacy component and then render the real component when the ID of the lacy copmonent appeared. Often leading to quite complex pattern matching callbacks to fetch each components data.


  Now the DB requests dont block each other and alot interaction can be outsourced to the URL. In order to enhace further responsiveness i am thinking about to add a LazyLoad compoent ([more-infos]('#TODO'))


  - background callbacks have run to sync
      - will be fixed in the future
      - sync callback gets put into a spearate exeuctor
  - dash testings - dash_duo had to be changed to a multi process runner instead of a threaded runner
  - somehow I can't turn of logs in dev mode


  - not all tests pass - detailed look in TEST_LOGS.md
      - 10 integration tests
      - 2 unit tests

  - shared callbacks / channel callbacks like [dash-devices](https://github.com/richlegrand/dash_devices) offered. Will most likly be implemented with redis PubSub

  - adding a LacyLoad component like [dash-grocery](https://github.com/IcToxi/dash-grocery), this will also increase responsiveness and overall better UI feeling


pkgId: 78ef5ed9a87678e2d4f666254f0875cc929234240e01fb801949fae3ab8af0ca
name: python-dash-functional-component
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Project Description
url: https://pypi.org/project/dash-functional-component/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-functional-component-0.0.4-1.src.rpm
checksum_type: sha256
description:
  dash functional component is a Dash component library.

  Project Description

  Get started with:
  1. Install Dash and its dependencies: https://dash.plotly.com/installation
  2. Run `python usage.py`
  3. Visit http://localhost:8050 in your web browser



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



  If you have selected install_dependencies during the prompt, you can skip this part.

  1. Install npm packages
      ```
      $ npm install
      ```
  2. Create a virtual env and activate.
      ```
      $ virtualenv venv
      $ . venv/bin/activate
      ```
      _Note: venv\Scripts\activate for windows_

  3. Install python packages required to build components.
      ```
      $ pip install -r requirements.txt
      ```
  4. Install the python packages for testing (optional)
      ```
      $ pip install -r tests/requirements.txt
      ```



  - The demo app is in `src/demo` and you will import your example component code into your demo app.
  - Test your code in a Python environment:
      1. Build your code
          ```
          $ npm run build
          ```
      2. Run and modify the `usage.py` sample dash app:
          ```
          $ python usage.py
          ```
  - Write tests for your component.
      - A sample test is available in `tests/test_usage.py`, it will load `usage.py` and you can then automate interactions with selenium.
      - Run the tests with `$ pytest tests`.
      - The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g. https://github.com/plotly/dash-core-components)
  - Add custom styles to your component by putting your custom CSS files into your distribution folder (`dash_functional_component`).
      - Make sure that they are referenced in `MANIFEST.in` so that they get properly included when you're ready to publish your component.
      - Make sure the stylesheets are added to the `_css_dist` dict in `dash_functional_component/__init__.py` so dash will serve them automatically when the component suite is requested.
  - [Review your code](./review_checklist.md)



  1. Build your code:
      ```
      $ npm run build
      ```
  2. Create a Python distribution
      ```
      $ python setup.py sdist bdist_wheel
      ```
      This will create source and wheel distribution in the generated the `dist/` folder.
      See [PyPA](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project)
      for more information.

  3. Test your tarball by copying it into a new environment and installing it locally:
      ```
      $ pip install dash_functional_component-0.0.1.tar.gz
      ```

  4. If it works, then you can publish the component to NPM and PyPI:
      1. Publish on PyPI
          ```
          $ twine upload dist/*
          ```
      2. Cleanup the dist folder (optional)
          ```
          $ rm -rf dist
          ```
      3. Publish on NPM (Optional if chosen False in `publish_on_npm`)
          ```
          $ npm publish
          ```
          _Publishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can set `serve_locally` to `False` and you may see faster load times._

  5. Share your component with the community! https://community.plotly.com/c/dash
      1. Publish this repository to GitHub
      2. Tag your GitHub repository with the plotly-dash tag so that it appears here: https://github.com/topics/plotly-dash
      3. Create a post in the Dash community forum: https://community.plotly.com/c/dash


pkgId: ef543ed81df1646b7c6fd1a2c08f89361ae5b91df8118fcc6e12756112738821
name: python-dash-high-charts
arch: src
version: 0.0.1rc0
epoch: 0
release: 1
summary: HighCharts wrapper for Plotly Dash
url: https://pypi.org/project/dash-high-charts/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-high-charts-0.0.1rc0-1.src.rpm
checksum_type: sha256
description:
  Dash HighCharts is a Dash component library with HighChartsAPI and Javascript integration.

  Use getApiSync to get the Highcharts Chart object and call HighCharts methods.

  Functions can be written as a dictionary and passed to the component for event handling.



  Get started with:
  1. Install Dash and its dependencies: https://dash.plotly.com/installation
  2. Run `python usage.py`
  3. Visit http://localhost:8050 in your web browser



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



  If you have selected install_dependencies during the prompt, you can skip this part.

  1. Install npm packages
      ```
      $ npm install
      ```
  2. Create a virtual env and activate.
      ```
      $ virtualenv venv
      $ . venv/bin/activate
      ```
      _Note: venv\Scripts\activate for windows_

  3. Install python packages required to build components.
      ```
      $ pip install -r requirements.txt
      ```
  4. Install the python packages for testing (optional)
      ```
      $ pip install -r tests/requirements.txt
      ```



  - The demo app is in `src/demo` and you will import your example component code into your demo app.
  - Test your code in a Python environment:
      1. Build your code
          ```
          $ npm run build
          ```
      2. Run and modify the `usage.py` sample dash app:
          ```
          $ python usage.py
          ```
  - Write tests for your component.
      - A sample test is available in `tests/test_usage.py`, it will load `usage.py` and you can then automate interactions with selenium.
      - Run the tests with `$ pytest tests`.
      - The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g. https://github.com/plotly/dash-core-components)
  - Add custom styles to your component by putting your custom CSS files into your distribution folder (`dash_high_charts`).
      - Make sure that they are referenced in `MANIFEST.in` so that they get properly included when you're ready to publish your component.
      - Make sure the stylesheets are added to the `_css_dist` dict in `dash_high_charts/__init__.py` so dash will serve them automatically when the component suite is requested.
  - [Review your code](./review_checklist.md)



  1. Build your code:
      ```
      $ npm run build
      ```
  2. Create a Python distribution
      ```
      $ python setup.py sdist bdist_wheel
      ```
      This will create source and wheel distribution in the generated the `dist/` folder.
      See [PyPA](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project)
      for more information.

  3. Test your tarball by copying it into a new environment and installing it locally:
      ```
      $ pip install dash_high_charts-0.0.1.tar.gz
      ```

  4. If it works, then you can publish the component to NPM and PyPI:
      1. Publish on PyPI
          ```
          $ twine upload dist/*
          ```
      2. Cleanup the dist folder (optional)
          ```
          $ rm -rf dist
          ```
      3. Publish on NPM (Optional if chosen False in `publish_on_npm`)
          ```
          $ npm publish
          ```
          _Publishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can set `serve_locally` to `False` and you may see faster load times._

  5. Share your component with the community! https://community.plotly.com/c/dash
      1. Publish this repository to GitHub
      2. Tag your GitHub repository with the plotly-dash tag so that it appears here: https://github.com/topics/plotly-dash
      3. Create a post in the Dash community forum: https://community.plotly.com/c/dash


pkgId: 3b1150a54b07263825923cf2e55c08adb8cedf23caf69a37bef6186a4d8aed26
name: python-dash-holoniq-components
arch: src
version: 0.0.19
epoch: 0
release: 1
summary: Custom components for Plotly Dash
url: https://pypi.org/project/dash-holoniq-components/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-holoniq-components-0.0.19-1.src.rpm
checksum_type: sha256
description:
  A set of house-keeping components for [Dash][dash-homepage] that make the
  implementation of forms and larger, multi-page applications a little easier.

  The following components are available:

  **Alert** The Alert component is hidden if it has no children. When children are injected the Alert
  component sets its style to become visible

  **ButtonLink** Allows you to create a clickable link within a multi-page app in
  the same way as `dcc.Link`. The standard `dcc.Button` attributes `n_clicks` and `n_clicks_timestamp` have been
  added to ButtonLink. These attributes can be used for notification that the `ButtonLink` has
  been clicked. `ButtonLink` can be enabled/disabled allowing conditional control of the link via a Dash callback

  **Form** The `Form` components normal submit action can be inhibited. The form data, as it would be
  reported by the a submit action, is available in a Dash callback via the components `form_data` attribute.

  **InputWithIcon** Adds a font awesome glyph and tooltip to the end of a standard input box

  **LayoutRouter** The children of LayoutRouter are each wrapped in a Div that is
  is hidden/shown based on the current value of the LayoutRouter 'switch' attribute.

  The advantage of `LayoutRouter` over the [standard](https://dash.plot.ly/urls) approach to
  dynamic layout is that **ALL** the applications layout is rendered, but hidden, when the
  Dash application starts. `LayoutRouter` overcomes the problem with the `standard` approach
  were callbacks linked to dynamic content are difficult to realise.

  **PageTitle** Sets the page title:

  **PasswordWithShow** Password input with a show/hide icon that can be clicked to reveal the password

  **Location** A modified version of *dash-core-components* Location component. Allows multiple instances
  to co-exist. In the *dash-core-components* version the last instance is the only one
  to get history event notifications.

  **Button**

  A modified version of *dash-core-components* Button component. The component
  has a boolean *focus* attribute that is set true when the button gains
  focus and false when it looses it. The focus attribute can be used in a dash
  callback to hide an associated dropdown whenever the user clicks
  the application background or makes a selection from the dropdown.

  *Example dropdown callback*
  ```
      @callback(Output(ids.container(MATCH), 'className'),
              Input(ids.button(MATCH), 'n_clicks'),
              Input(ids.button(MATCH), 'focus'),
              State(ids.container(MATCH), 'className'))
      def show_dropdown(button_clicks, button_focus, className):
          logging.info('show_dropdown: button_clicks=%s, className = %s', button_clicks, className)

          if not button_clicks:
              return className

          if 'show' in className and button_focus == False:
              return className.replace(' show', '')
          else:
              return className + ' show'
  ```




  You can install *dash-holoniq-components* with `pip`:

  ```
  pip install dash-holoniq-components
  ```



  Head over to the [*README*][docs-homepage] for more details.



  The source code for *dash-bootstrap-components* is available
  [on GitHub][dhc-repo]. If you find a bug or something is unclear, we encourage
  you to raise an issue. We also welcome contributions, to contribute, fork the
  repository and open a [pull request][dhc-pulls].


  [dash-homepage]: https://dash.plot.ly/
  [dhc-repo]: https://github.com/stevej2608/dash-holoniq-components
  [docs-homepage]: https://github.com/stevej2608/dash-holoniq-components/blob/master/README.md
  [dhc-pulls]: https://github.com/stevej2608/dash-holoniq-components/pulls


pkgId: 55d29c0082ff8b0fd1c149d900b6f4b80f2d560e7ed507700d51d981e51562bd
name: python-dash-html-components
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Vanilla HTML components for Dash
url: https://github.com/plotly/dash-html-components
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-html-components-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Vanilla HTML components for [Dash][]

  1. Create a virtual env and activate.
      ```
      $ virtualenv venv
      $ venv/bin/activate
      ```
      _Note: venv\Scripts\activate for Windows_
  2. Install Python packages required to build components.
      ```
      $ pip install -r dev-requirements.txt
      ```
  3. Generate components and install npm packages
      ```
      $ npm install
      ```

  The components in `src/components`, as well as the export index in
  `src/index.js` are programmatically generated from element definitions in
  `scripts/`. To regenerate:
  ```sh
  $ npm run generate-components
  ```
  The list of attributes is regenerated by scraping the
  [MDN HTML attribute reference][].
  _Note: This step will have already been done for you when you ran `npm install`_


  1. Watch for changes
          $ npm run build:watch
  2. Install module locally (after every change)
          
          $ npm run install-local
          
          $ python setup.py install
  3. Run the Dash layout you want to test
          
          $ python my_dash_layout.py

  Before publishing to PyPi, you can test installing the module locally:
  ```sh

  $ npm run install-local
  ```

  ```sh
  $ npm run uninstall-local
  ```

  See the [contributing guide](CONTRIBUTING.md) for guidelines on contributing to this project.

  1. Build your code:
      ```
      $ npm run build
      ```
  2. Create a Python tarball
      ```
      $ python setup.py sdist
      ```
      This distribution tarball will get generated in the `dist/` folder
  3. Test your tarball by copying it into a new environment and installing it locally:
      ```
      $ pip install dash-html-components-<new-version>.tar.gz
      ```
  4. If it works, then you can publish the component to NPM and PyPI:
      1. Publish on PyPI
          ```
          $ twine upload dist/*
          ```
      2. Cleanup the dist folder (optional)
          ```
          $ rm -rf dist
          ```
      3. Publish on NPM (Optional if chosen False in `publish_on_npm`)
          ```
          $ npm publish
          ```
          _Publishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash servers the component library's CSS and JS from the remote unpkg CDN, so if you haven't published the component package to NPM you'll need to set the `serve_locally` flags to `True` (unless you choose `False` on `publish_on_npm`). We will eventually make `serve_locally=True` the default, [follow our progress in this issue](https://github.com/plotly/dash/issues/284)._
  [Dash]: https://plotly.com/dash
  [MDN HTML attribute reference]: https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes
  [NPM package authors]: https://www.npmjs.com/package/dash-html-components/access
  [PyPi]: https://pypi.python.org/pypi


pkgId: 07fd827c5af47bd31bb8f81c2d9cd86e54e29baa96c8661b7cc233113d60f341
name: python-dash-iconify
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Iconify for Plotly Dash
url: https://github.com/snehilvj/dash-iconify
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-iconify-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Dash Iconify based on Iconify is a Dash component library which brings over 100,000 vector icons.



  - [Installation](#installation)
  - [Quickstart](#quickstart)
  - [Using with dmc](#using-with-dmc)
  - [Keyword Arguments](#keyword-arguments)



  ```bash
  pip install dash-iconify
  ```



  ```python
  from dash_iconify import DashIconify
  from dash import Dash

  app = Dash(__name__)

  app.layout = DashIconify(
      icon="ion:logo-github",
      width=30,
      height=30,
      rotate=1,
      flip="horizontal",
  )

  if __name__ == "__main__":
      app.run_server(debug=True)

  ```



  [Dash Mantine Components](https://github.com/snehilvj/dash-mantine-components) enables using icons natively.

  ```python
  import dash_mantine_components as dmc
  from dash_iconify import DashIconify

  button = dmc.Button("Send Mail", leftIcon=[
      DashIconify(icon="fluent:folder-mail-16-filled")
  ])
  ```



  Visit this site to browse all the available icons: <https://icon-sets.iconify.design/>

  ```git
  Keyword arguments:

  - id (string; optional):
      The ID used to identify this component in Dash callbacks.

  - color (string; optional):
      Color.

  - flip (a value equal to: "horizontal", "vertical"; optional):
      Flip the icon horizontally or vertically.

  - height (number; optional):
      Icon height.

  - icon (string; optional):
      Icon name is a string, which has 3 parts: @api-provider : icon-prefix : icon-name
      provider points to API source. Starts with "@", can be empty (empty value is used for public Iconify API).
      prefix is name of icon set.
      name is name of icon.

  - inline (boolean; optional):
      Toggles inline or block mode.

  - rotate (a value equal to: 0, 1, 2, 3; optional):
      Rotates icon, 0: 0 deg, 1: 90 deg, 2: 180 deg, 3: 270 deg.

  - style (dict; optional):
      Inline style.

  - width (number; optional):
      Icon width.
  ```


pkgId: 7c517ae2b8186157ddb39a398ffd5dd708a152c30c1793f724e9dd1d2a24c36f
name: python-dash-interactive-graphviz
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: An interactive graphviz viewer for Dash
url: https://pypi.org/project/dash-interactive-graphviz/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-interactive-graphviz-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Dash Interactive Graphviz renders the [graphviz](https://www.graphviz.org/) or dot language in a dash component.

  > Graphviz is open source graph visualization software. Graph visualization is a way of representing structural information as diagrams of abstract graphs and networks. It has important applications in networking, bioinformatics, software engineering, database and web design, machine learning, and in visual interfaces for other technical domains.

  It supports:

  - Displaying graphviz sources as a graph
  - Rendering is fully client side
  - Zooming and Panning around the graph (With a reset)
  - Selecting nodes
  - Animation between different graphs



  You can install with pip (or anything else)

  ```bash
  pip install dash_interactive_graphviz
  ```

  Usage is simple, below shows how to instantiate the component on its own.

  ```python
  import dash_interactive_graphviz

  dot_source = """
  digraph  {
    node[style="filled"]
    a ->b->d
    a->c->d
  }
  """

  dash_interactive_graphviz.DashInteractiveGraphviz(
      id="graph",
      dot_source=dot_source
  )
  ```

  When a node or edge is clicked the  `selected_node` or `selected_edge` property will change.

  **NOTE** [Pending deprecation] `selected` is replaced by `selected_node`.

  Hooks on selected graph elements allow you to change elements of your Dash app when a graph element is selected. For example:

  ```python
  @app.callback(
      Output( ..., ... ),
      [Input('graph', 'selected_node')]
  )
  def change_my_view(selected):
      
  ```
  You can see a basic example in usage.py.

  Often you may want to update the dot_source based on the selected graph element. This is supported, and you can see an example in usage_highlighting.py.

  You can change the layout engine through the `engine` prop. See
  https://github.com/magjac/d3-graphviz#graphviz_engine for more information.



  The following behaviors are enabled:

  - When the dot_source is changed the graph will smoothly animate between the two states.
  - You can click and drag the graph around
  - You can zoom in and out with the scroll wheel
  - You can reset the graph position and zoom by clicking the reset icon in teh top right corner
  - The graph pane will size to whet ever it's parents size is, the graph will re-render but the re-render is debounced so as not to overload the browser.
  - You can select a graph element (node or edge) which will fire an update to any dash callbacks that are connected.
  - You can change the layout engine


pkgId: 8af331a36307ec4dc861d2f359be20282a03793e0c17bf364915353826954c83
name: python-dash-jbrowse
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Dash components for JBrowse 2
url: https://github.com/GMOD/dash_jbrowse
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-jbrowse-1.4.2-1.src.rpm
checksum_type: sha256
description:
  [Dash](https://dash.plotly.com/introduction) is a popular open-source framework
  for building data-driven web apps. It is built on top of ReactJS, and provides a
  [toolkit](https://dash.plotly.com/plugins) for converting React components into
  dash components that can be used in Dash apps written in Python, R, Julia, F# or
  Matlab.

  Dash JBrowse's `LinearGenomeView` is a Dash component that wraps the
  [JBrowse React Linear Genome View](https://jbrowse.org/storybook/lgv/main/) and
  makes it possible to embed an interactive genome browser into any Dash
  application. Now supporting the `CircularGenomeView` as well.

  ![Dash JBrowse LGV configured with human data](https://raw.githubusercontent.com/GMOD/dash_jbrowse/main/images/demo.png)

  ![Dash JBrowse CGV configured with human data](https://raw.githubusercontent.com/GMOD/dash_jbrowse/main/images/demo2.png)



  ```
  $ pip install dash_jbrowse
  ```

  Basic linear genome view with an assembly

  ```
  import dash
  import dash_jbrowse
  from dash import html

  print(dash_jbrowse.__version__)
  app = dash.Dash(__name__)

  my_assembly = {
      "name": "GRCh38",
      "sequence": {
          "type": "ReferenceSequenceTrack",
          "trackId": "GRCh38-ReferenceSequenceTrack",
          "adapter": {
              "type": "BgzipFastaAdapter",
              "fastaLocation": {
                  "uri": "https://s3.amazonaws.com/jbrowse.org/genomes/GRCh38/fasta/GRCh38.fa.gz",
              },
              "faiLocation": {
                  "uri": "https://s3.amazonaws.com/jbrowse.org/genomes/GRCh38/fasta/GRCh38.fa.gz.fai",
              },
              "gziLocation": {
                  "uri": "https://s3.amazonaws.com/jbrowse.org/genomes/GRCh38/fasta/GRCh38.fa.gz.gzi",
              },
          },
      },
      "aliases": ["hg38"],
      "refNameAliases": {
          "adapter": {
              "type": "RefNameAliasAdapter",
              "location": {
                  "uri": "https://s3.amazonaws.com/jbrowse.org/genomes/GRCh38/hg38_aliases.txt",
              },
          },
      },
  }

  app.layout = html.Div(
      [
          dash_jbrowse.LinearGenomeView(
              id="lgv-hg38",
              assembly=my_assembly
          ),
      ],
      id='test'
  )

  if __name__ == "__main__":
      app.run_server(debug=True)
  ```

  An example of the CGV can be found in [usage_cgv.py](usage_cgv.py).





  ```
  $ pip install dash_jbrowse
  ```



  After cloning this repository, install virtualenv

  ```
  $ pip install virtualenv
  ```

  ```
  $ cd dash_jbrowse
  $ python3 -m venv ./venv
  $ source venv/bin/activate
  $ pip install -r requirements.txt
  ```

  Then you can run the example app found in usage.py

  ```
  python usage.py
  ```



  The views can be customized in many ways, but the only properties that are
  required to launch it are the id required for dash call backs and the assembly.

  - `id` (string, required): the id used for dash callbacks. A basic example of
    this component using dash callbacks can be found under the examples directory)

  - `assembly` (object, required): the configuration object of the assembly being
    used for the browser. More information about the configuration of the assembly
    can be found
    [here](https://jbrowse.org/jb2/docs/config_guide/#configuring-assemblies).

  _top level assembly config_

  ```json
  {
    "name": "assemblyName",
    "aliases": [],
    "sequence": {},
    "refNameAliases": {}
  }
  ```

  - `tracks` (list, optional) - list of track configuration objects.

  _top level track config_

  ```json
  {
    "trackId": "test-id",
    "name": "track name",
    "assemblyNames": [],
    "category": []
  }
  ```

  - `defaultSession` (object, optional) - information about the current app state
    such as what views are open

  _default session config_

  ```json
  {
    "name": "this session",
    "view": {
      "id": "linearGenomeView",
      "type": "LinearGenomeView"
    }
  }
  ```

  Note: `"type": "CircularGenomeView"` for CGV

  - `location` (string or object, optional) - initial
    [location](https://jbrowse.org/jb2/docs/user_guide/#using-the-location-search-box)
    for when the browser first loads, e.g '1:500-1000' or location object

  _location object_

  ```json
  {
    "refName": 1,
    "start": 500,
    "end": 1000
  }
  ```

  Note:

  - Use 0-based coordinates in the location object.

  - The location field is only used for LGV and not CGV.

  Checkout the storybook
  [JBrowse React Linear Genome View docs](https://jbrowse.org/storybook/lgv/main/?path=/story/default-sessions--page)
  or the
  [JBrowse React Circular Genome View docs](https://jbrowse.org/storybook/cgv/v1.5.9/?path=/story/getting-started--page)
  for more configuration examples.





  Adding text searching to the JBrowse React Linear Genome View (not currently
  available for the CGV) requires a couple of extra steps. We first need to create
  an index via the
  [JBrowse CLI tools](https://jbrowse.org/jb2/docs/cli/#jbrowse-text-index). Once
  an index is created, we can add a text search adapter to the list of aggregate
  text search adapters in this component or to the configuration object of a
  track.

  - `aggregateTextSearchAdapters` (object, optional) - configuration of an index
    used for text searching

  Aggregate text search adapter to use in the component.

  ```json
  {
    "type": "TrixTextSearchAdapter",
    "textSearchAdapterId": "adapter-id",
    "ixFilePath": {
      "uri": "url/path/to/my/ix/file",
      "locationType": "UriLocation"
    },
    "ixxFilePath": {
      "uri": "url/path/to/my/ixx/file",
      "locationType": "UriLocation"
    },
    "metaFilePath": {
      "uri": "url/path/to/my/meta.json/file",
      "locationType": "UriLocation"
    }
  }
  ```

  On a track configuration.

  ```json
  {
    "trackId": "yourtrack",
    "name": "Track name",
    "adapter": {
      "type": "Gff3TabixAdapter",
      "gffGzLocation": {
        "uri": "yourfile.gff.gz",
        "locationType": "UriLocation"
      },
      "index": {
        "location": {
          "uri": "yourfile.gff.gz.tbi",
          "locationType": "UriLocation"
        }
      }
    },
    "textSearching": {
      "textSearchAdapter": {
        "type": "TrixTextSearchAdapter",
        "textSearchAdapterId": "hg19-index",
        "ixFilePath": {
          "uri": "https://jbrowse.org/genomes/hg19/trix/hg19.ix",
          "locationType": "UriLocation"
        },
        "ixxFilePath": {
          "uri": "https://jbrowse.org/genomes/hg19/trix/hg19.ixx",
          "locationType": "UriLocation"
        },
        "metaFilePath": {
          "uri": "https://jbrowse.org/genomes/hg19/trix/meta.json",
          "locationType": "UriLocation"
        },
        "assemblyNames": ["hg19"]
      },
      "indexingAttributes": ["Name", "ID"],
      "indexingFeatureTypesToExclude": ["CDS", "exon"]
    }
  }
  ```



  - `configuration` - (object, optional) - color scheme configuration

  ```json
  {
    "theme": {
      "palette": {
        "primary": {
          "main": "#311b92"
        },
        "secondary": {
          "main": "#0097a7"
        },
        "tertiary": {
          "main": "#f57c00"
        },
        "quaternary": {
          "main": "#d50000"
        },
        "bases": {
          "A": { "main": "#98FB98" },
          "C": { "main": "#87CEEB" },
          "G": { "main": "#DAA520" },
          "T": { "main": "#DC143C" }
        }
      }
    }
  }
  ```

  !["Dash LGV component with a custom theme."](https://raw.githubusercontent.com/GMOD/dash_jbrowse/main/images/custom_theme.png)



  This package was written with funding from the [NHGRI](https://genome.gov/) as
  part of the JBrowse project. If you use it in an academic project that you
  publish, please cite the most recent JBrowse paper, which will be linked from
  [jbrowse.org](https://jbrowse.org/).



  - More information about `Dash` can be found in this
    [post](https://medium.com/plotly/dash-is-react-for-python-r-and-julia-c75822d1cc24)
  - Examples of the `LinearGenomeView` component can be found in the
    [usage.py](usage.py), and [browser.py](./examples/browser.py)
  - Examples of the `CircularGenomeView` component can be found in the
    [usage.py](usage_cgv.py)
  - [JBrowse React Linear Genome View](https://jbrowse.org/storybook/lgv/main/) -
    documentation and examples of the React LGV component.
  - [JBrowse React Circular Genome View](https://jbrowse.org/storybook/cgv/main/?path=/story/getting-started--page) -
    documentation and examples of the React CGV component.
  - [Config Guide](https://jbrowse.org/jb2/docs/config_guide/) - a guide to
    configuring assemblies, tracks, text searching and more.
  - [JBrowse CLI tools](https://jbrowse.org/jb2/docs/cli/) - installation and
    documentation
  - [TextSearching](https://jbrowse.org/jb2/docs/config_guide/#text-searching) -
    documentation of text indexing and text search adapters



  We **really** love talking to our users. Please reach out with any thoughts you
  have on what we are building!

  - Report a bug or request a feature at
    https://github.com/GMOD/dash_jbrowse/issues/new
  - Join our developers chat at https://gitter.im/GMOD/jbrowse2
  - Send an email to our mailing list at `gmod-ajax@lists.sourceforge.net`


pkgId: e9855fe5d3f724bfc8318e573f7f6c49ab0ecaf84cee119ff43f8f313d8a3f8f
name: python-dash-json-grid
arch: src
version: 0.4.2
epoch: 0
release: 1
url: https://github.com/cainmagi/dash-json-grid
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-json-grid-0.4.2-1.src.rpm
checksum_type: sha256
summary:
  Dash porting version of the react project React JSON Grid. Provide structured and nested grid table view of complicated JSON objects/arrays.

description:
  <p><img alt="Banner" src="https://repository-images.githubusercontent.com/856794016/fe6159c5-0ca5-4f8e-83d5-816a36e64ce2"></p>

  <p align="center">
    <a href="https://github.com/cainmagi/dash-json-grid/releases/latest"><img alt="GitHub release (latest SemVer)" src="https://img.shields.io/github/v/release/cainmagi/dash-json-grid?logo=github&sort=semver&style=flat-square"></a>
    <a href="https://github.com/cainmagi/dash-json-grid/releases"><img alt="GitHub all releases" src="https://img.shields.io/github/downloads/cainmagi/dash-json-grid/total?logo=github&style=flat-square"></a>
    <a href="https://github.com/cainmagi/dash-json-grid/blob/main/LICENSE"><img alt="GitHub" src="https://img.shields.io/github/license/cainmagi/dash-json-grid?style=flat-square&logo=opensourceinitiative&logoColor=white"></a>
    <a href="https://pypi.org/project/dash-json-grid"><img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/dash-json-grid?style=flat-square&logo=pypi&logoColor=white&label=pypi"></a>
  </p>
  <p align="center">
    <a href="https://github.com/cainmagi/dash-json-grid/actions/workflows/python-package.yml"><img alt="GitHub Actions (Build)" src="https://img.shields.io/github/actions/workflow/status/cainmagi/dash-json-grid/python-package.yml?style=flat-square&logo=githubactions&logoColor=white&label=build"></a>
    <a href="https://github.com/cainmagi/dash-json-grid/actions/workflows/python-publish.yml"><img alt="GitHub Actions (Release)" src="https://img.shields.io/github/actions/workflow/status/cainmagi/dash-json-grid/python-publish.yml?style=flat-square&logo=githubactions&logoColor=white&label=release"></a>
  </p>

  Dash JSON Grid is a Dash component library.

  Dash porting version of the react project [React JSON Grid :link:][git-react-json-grid]. Provide structured and nested grid table view of complicated JSON objects/arrays.

  The following two figures compare the demos of the original React version and the ported Dash version. Since this project is just a dash component wrapper on the original React component, the performance is the same.

  |        React JSON Grid        |       Dash JSON Grid        |
  | :---------------------------: | :-------------------------: |
  | ![demo-react][pic-demo-react] | ![demo-dash][pic-demo-dash] |



  Intall the **latest released version** of this package by using the PyPI source:

  ``` sh
  python -m pip install dash-json-grid
  ```

  Or use the following commands to install **the developing version** from the GitHub Source when you have already installed [Git :hammer:][tool-git], [NodeJS :hammer:][tool-nodejs], and [Yarn :hammer:][tool-yarn]:

  ```bash
  git clone https://github.com/cainmagi/dash-json-grid
  cd dash-json-grid
  python -m pip install -r requirements-dev.txt
  yarn install
  yarn build
  python -m pip install .
  ```



  The following codes provide a minimal example of using this component:

  ```python
  import dash
  import dash_json_grid as djg


  app = dash.Dash("demo")
  app.layout = djg.DashJsonGrid(
      data={
          "id": "0001",
          "type": "donut",
          "name": "Cake",
          "ppu": 1111.55,
          "batters": {
              "batter": [
                  {"id": "1001", "type": "Regular"},
                  {"id": "1002", "type": "Chocolate"},
                  {"id": "1003", "type": "Blueberry"},
                  {"id": "1004", "type": "Devil's Food"},
              ]
          },
          "topping": [
              {"id": "5001", "type": "None"},
              {"id": "5002", "type": "Glazed"},
              {"id": "5005", "type": "Sugar"},
              {"id": "5007", "type": "Powdered Sugar"},
              {"id": "5006", "type": "Chocolate with Sprinkles"},
              {"id": "5003", "type": "Chocolate"},
              {"id": "5004", "type": "Maple"},
          ],
      }
  )

  if __name__ == "__main__":
      app.run()
  ```



  Check the documentation to find more details about the examples and APIs.

  https://cainmagi.github.io/dash-json-grid/



  See [CONTRIBUTING.md :book:][link-contributing]



  See [Changelog.md :book:][link-changelog]



  - [RedHeadphone/react-json-grid :link:][git-react-json-grid]: The original React component implementation of this project.
  - [jsongrid.com :link:][link-json-grid]: Grid design and styles.
  - [kevincobain2000/json-to-html-table :link:][git-json-to-html]: React Component and project structure

  [git-react-json-grid]:https://github.com/RedHeadphone/react-json-grid
  [git-json-to-html]:https://github.com/kevincobain2000/json-to-html-table
  [link-json-grid]:https://jsongrid.com/json-grid
  [dash-pmcallback]:https://dash.plotly.com/pattern-matching-callbacks
  [tool-git]:https://git-scm.com/downloads
  [tool-nodejs]:https://nodejs.org/en/download/package-manager
  [tool-yarn]:https://yarnpkg.com/getting-started/install

  [pic-demo-react]:https://raw.githubusercontent.com/cainmagi/dash-json-grid/main/display/demo-react.png
  [pic-demo-dash]:https://raw.githubusercontent.com/cainmagi/dash-json-grid/main/display/demo-dash.png

  [link-contributing]:https://github.com/cainmagi/dash-json-grid/blob/main/CONTRIBUTING.md
  [link-changelog]:https://github.com/cainmagi/dash-json-grid/blob/main/Changelog.md


pkgId: ad460d08c1a95331c02d6a79156b0c69b6d22074f2086f1f853014c75a1fcaed
name: python-dash-keycloak
arch: src
version: 0.0.25
epoch: 0
release: 1
summary: Flask extension providing Keycloak integration via the python-keycloak package
url: https://github.com/thedirtyfew/dash-keycloak
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-keycloak-0.0.25-1.src.rpm
checksum_type: sha256
description:
  This purpose of this library is to provide seamless integration of Plotly Dash with keycloak via the python-keycloak package.



  Prior to using this library, a Keycloak server must be setup. Please refer to the official documentation,

      https://www.keycloak.org/

  After setting up the server, create a client for the application. Set "Access Type" to "confidential", set the valid redirect URIs (mandatory), and click "Save". Go to "Installation", select "Keycloak OIDC JSON" as "Format Option" and download the file.



  To run the code, a virtual environment should be setup,

      python3 -m venv venv

  After activating the environment,

      source venv/bin/activate

  The relevant packages can be installed as

      pip install -r requirements.txt



  After completing the above step, the example can be run with the command

      python3 -m flask_keycloak.examples.dash_example /path/to/keycloak.json



  Bump the version number in setup.py and run

      python3 setup.py sdist
      pip3 install twine
      twine upload dist/*


pkgId: 465590102f86ad99d24cd5181abaff730d1bc92edb885d8dc3b68c5981e43057
name: python-dash-leaflet
arch: src
version: 1.0.15
epoch: 0
release: 1
url: https://github.com/thedirtyfew/dash-leaflet
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-leaflet-1.0.15-1.src.rpm
checksum_type: sha256
summary:
  Dash Leaflet is a light wrapper around React-Leaflet. The syntax is similar to other Dash components, with naming conventions following the React-Leaflet API.

description:
  Dash Leaflet is a light wrapper around React-Leaflet. The syntax is similar to other Dash components, with naming conventions following the React-Leaflet API.



  The easiest way to get started is to install the latest version of Dash and Dash Leaflet via pip.

  ```
  pip install dash
  pip install dash-leaflet
  ```

  Once the installation is completed, paste the following lines of code into a .py file and run it.

  ````
  from dash import Dash
  import dash_leaflet as dl

  app = Dash()
  app.layout = dl.Map(dl.TileLayer(), style={'height': '50vh'}, center=[56, 10], zoom=6)

  if __name__ == '__main__':
      app.run_server()
  ````

  That's it! If you visit http://127.0.0.1:8050/ in your browser, you should see a Leaflet map.



  The documentation has been moved to [a separate page](https://dash-leaflet.com) to enable an interactive example gallery.

  NB: The 1.0.0 release contains a wide range of breaking changes, please refer to the migration guidelines



  Please ask questions on [StackOverflow](https://stackoverflow.com/) using the [`dash-leaflet` tag](https://stackoverflow.com/questions/tagged/dash-leaflet), use GitHub issues only for bug reports.



  Start by cloning this repository,

  ````
  git clone git@github.com:thedirtyfew/dash-leaflet.git
  cd dash-leaflet
  ````

  Next, create a virtual environment and install the python dependencies,

  ````
  python3 -m venv venv && . venv/bin/activate
  pip install -r requirements.txt
  ````

  Finally, install packages via npm (ignore errors) and run the build script,

  ````
  npm i --ignore-scripts
  npm run build
  ````



  [![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=Z9RXT5HVPK3B8&currency_code=DKK&source=url)


pkgId: db389dcb0a6e86b2ab9bb6caff57067b35357089d088f9d6e7cf9733675b6aab
name: python-dash-mantine-components
arch: src
version: 0.14.4
epoch: 0
release: 1
summary: Plotly Dash Components based on Mantine
url: https://github.com/snehilvj/dash-mantine-components
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-mantine-components-0.14.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://raw.githubusercontent.com/snehilvj/dash-mantine-components/master/assets/logo.png" alt="logo" width=300 >
  </p>
  <p align="center">
      <img src="https://badgen.net/pypi/license/dash-mantine-components">
      <a href="https://pypi.org/project/dash-mantine-components/">
      <img src="https://badgen.net/pypi/v/dash-mantine-components">
      </a>
      <a href="https://discord.gg/KuJkh4Pyq5">
      <img src="https://img.shields.io/badge/Chat%20on-Discord-%235865f2">
      </a>
      <img src="https://static.pepy.tech/personalized-badge/dash-mantine-components?period=total&units=international_system&left_color=grey&right_color=brightgreen&left_text=Downloads">
  </p>

  Dash Mantine Components is an extensive (90+) Dash components library based on [Mantine](https://mantine.dev/) React Components Library. It makes it easier to create good quality dashboards with very well designed components out of the box.

  [Documentation](https://dash-mantine-components.com)

  <p align="center">
      <img src="https://raw.githubusercontent.com/snehilvj/dash-mantine-components/master/assets/datepicker.gif">
  </p>



  -   [Installation](#installation)
  -   [Quickstart](#quickstart)
  -   [Sponsors](#sponsors)
  -   [Contributing](#contributing)



  ```bash
  pip install dash-mantine-components
  ```



  ```python
  from datetime import date

  import dash
  from dash import Dash, Input, Output, callback, html
  from dash.exceptions import PreventUpdate

  import dash_mantine_components as dmc

  stylesheets = ["https://unpkg.com/@mantine/dates@7/styles.css"]
  dash._dash_renderer._set_react_version('18.2.0')

  app = Dash(__name__, external_stylesheets=stylesheets)

  app.layout = dmc.MantineProvider(
      [
          dmc.DatePicker(
              id="date-picker",
              label="Start Date",
              description="You can also provide a description",
              minDate=date(2020, 8, 5),
              value=None,
              w=200
          ),
          dmc.Space(h=10),
          dmc.Text(id="selected-date"),
      ]
  )


  @callback(Output("selected-date", "children"), Input("date-picker", "value"))
  def update_output(d):
      prefix = "You have selected: "
      if d:
          return prefix + d
      else:
          raise PreventUpdate


  if __name__ == "__main__":
      app.run_server(debug=True)
  ```



  Thanks to the following people for supporting my efforts on dash-mantine-components.

  1. [Ann Marie Ward](https://github.com/AnnMarieW)
  2. [Arne Petter](https://github.com/apdcode)



  1. Join our [Discord](https://discord.gg/KuJkh4Pyq5) community.

  2. Install virtual environment:

      ```bash
      python -m venv venv
      source venv/bin/activate
      pip install -r requirements.txt
      ```

  3. Install npm dependencies

      ```bash
      npm install
      ```

  4. Add your new component in `src/lib/components`. Make sure to include it in the `src/lib/index.js` as well.

  5. Build the components with the command: `npm run build`.

  6. Raise a PR, including an example to reproduce the changes contributed by the PR.


pkgId: 4c5e5ebf48fbcfcd34c914853d2d7cbef59637da9a9f3cbc10d7dc40864c42d7
name: python-dash-mantine-components
arch: src
version: 0.15.1
epoch: 0
release: 1
summary: Plotly Dash Components based on Mantine
url: https://github.com/snehilvj/dash-mantine-components
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-mantine-components-0.15.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://raw.githubusercontent.com/snehilvj/dash-mantine-components/master/assets/logo.png" alt="logo" width=300 >
  </p>
  <p align="center">
      <img src="https://badgen.net/pypi/license/dash-mantine-components">
      <a href="https://pypi.org/project/dash-mantine-components/">
      <img src="https://badgen.net/pypi/v/dash-mantine-components">
      </a>
      <a href="https://discord.gg/KuJkh4Pyq5">
      <img src="https://img.shields.io/badge/Chat%20on-Discord-%235865f2">
      </a>
      <img src="https://static.pepy.tech/personalized-badge/dash-mantine-components?period=total&units=international_system&left_color=grey&right_color=brightgreen&left_text=Downloads">
  </p>

  Dash Mantine Components is an extensive (90+) Dash components library based on [Mantine](https://mantine.dev/) React Components Library. It makes it easier to create good quality dashboards with very well designed components out of the box.


  <p align="center">
      <img src="https://raw.githubusercontent.com/snehilvj/dash-mantine-components/master/assets/datepicker.gif">
  </p>




  ```bash
  pip install dash-mantine-components
  ```



  ```python
  from datetime import date

  import dash
  from dash import Dash, Input, Output, callback, html
  from dash.exceptions import PreventUpdate

  import dash_mantine_components as dmc

  dash._dash_renderer._set_react_version('18.2.0')

  app = Dash(__name__, external_stylesheets=dmc.styles.ALL)

  app.layout = dmc.MantineProvider(
      [
          dmc.DatePickerInput(
              id="date-picker",
              label="Start Date",
              description="You can also provide a description",
              minDate=date(2020, 8, 5),
              value=None,
              w=200
          ),
          dmc.Space(h=10),
          dmc.Text(id="selected-date"),
      ]
  )


  @callback(Output("selected-date", "children"), Input("date-picker", "value"))
  def update_output(d):
      prefix = "You have selected: "
      if d:
          return prefix + d
      else:
          raise PreventUpdate


  if __name__ == "__main__":
      app.run_server(debug=True)
  ```



  For detailed information on how to use this project, check out the [Documentation](https://dash-mantine-components.com). You'll find guides, API references, and examples to help you get started!



  We welcome all contributions! Feel free to open issues for any bugs or feature requests, and don't hesitate to
  comment on existing issues or pull requests. PRs are encouraged! For more details, please check out our [Contributing Guide.](https://github.com/snehilvj/dash-mantine-components/blob/master/CONTRIBUTING.md)

  Join our [Discord](https://discord.gg/KuJkh4Pyq5) to connect with other contributors, or visit the [Plotly Dash Community Forum](https://community.plotly.com/)
  for discussions and support.




  We :heart: contributions to our documentation! It's a fantastic opportunity for first-time contributors since the
  project is simply a Dash app built with `dash-mantine-components`. For more details, check out the [dmc-docs GitHub.](https://github.com/snehilvj/dmc-docs)




  A huge thank you to our current sponsors for supporting this project! 🙏 Your contributions help drive development and improvements.

  If you’d like to support this project and help ensure its continued success, consider [becoming a sponsor](https://github.com/sponsors/snehilvj). Your support
  is greatly appreciated and helps keep the project growing and thriving!



  If you find this project helpful, consider giving it a star on GitHub! ⭐️ It helps others discover the project and
  motivates us to keep improving it. Your support is greatly appreciated!


pkgId: 235433fc70141e3e5e4ae740e4f9c7e83022e0f9671101137c20ec302670449a
name: python-dash-material-components
arch: src
version: 2.0.9
epoch: 0
release: 1
summary: Dash Material Design components for the Noos platform.
url: https://github.com/noosenergy/dash-material-components
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-material-components-2.0.9-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/noosenergy/dash-material-components.svg?style=svg&circle-token=6388fe0ebfc51208a8aec58b00e40edbb6a60724)](https://circleci.com/gh/noosenergy/dash-material-components)



  `dash-material-components` allows to build consistently styled dashboards with complex and reactive layouts, following Google's [Material Design](https://material.io/) principles.

  The library leverages [MUI React](https://mui.com/) components for use with [Plotly Dash](https://dash.plotly.com/).

  This project has been initially boostrapped thanks to the [Dash plugin cookiecutter](https://github.com/plotly/dash-component-boilerplate).





  The python package is available from the [PyPi repository](https://pypi.org/project/dash-material-components),

  ```sh
  pip install dash-material-components
  ```



  Once installed, start using the Python components exactly like you would use other [Dash component libraries](https://dash.plotly.com/layout),

  ```python
  import dash

  import dash_material_components as dmc



  text = dmc.Typography(text="Content...", component="p", variant="body2")

  section_1 = dmc.Section(
      id="section-1",
      orientation="columns",
      children=[text, text_2],
      cards=[{"title": "Card 1a", "size": 3}, {"title": "Card 1b"}]
  )

  section_2 = dmc.Section(
      id="section-2",
      size=3,
      children=[text, text_2],
      orientation="rows",
      cards=[{"title": "Card 2a", "size": 4}, {"title": "Card 2b"}]
  )

  page = dmc.Page(orientation="columns", children=[section_1, section_2])
  navbar = dmc.NavBar(title="Custom dash")

  layout = dmc.Dashboard(children=[navbar, page])


  app = dash.Dash(__name__)
  app.layout = layout

  if __name__ == "__main__":
      app.run_server()
  ```



  As pre-requisite, install the Jupyter Lab extension [JupyterDash](https://medium.com/plotly/introducing-jupyterdash-811f1f57c02e),

  ```shell
  ~$ pip install jupyter-dash
  ```

  Then, copy the Dash snippet above into a Jupyter notebook cell and replace the `Dash` class with the `JupyterDash` class:

  ```python
  from dash import Dash

  app = Dash(__name__)
  app.layout = layout

  app.run_server(mode='jupyterlab', host="0.0.0.0", port=8001)
  ```





  ```markdown
  * project/
    * python-package/             # The python package, output folder for the bundles.
      * src/                      # The javascript source directory for the components.
        * components/             # Where to put the react component classes.
        * index.js                # The index for the components exported by the bundle.
      * package.json              # JS package build commands.
      * webpack.config.js         # The webpack configs used to generate the bundles.
      * pyproject.toml            # Python package build commands.
  ```



  The project is shipped with off-the-shelf scripts to manage node packages as well as a set of utilities for local development. If the `yarn` node package manager is installed globally, install all javascript dependencies,

  ```shell
  ~$ yarn install --frozen-lockfile
  ```

  > :warning: the Dash material components has only been tested against Node.js v18.

  And thanks to `poetry` python package manager, create a virtual environnement,

  ```shell
  ~$ poetry install
  ```



  Compose your new Dash components in `src/components` and make sure the React components are exported in your package entrypoint `src/index.js`.

  ```javascript
  import NoosComponent from './components/NoosComponent.jsx';

  export {NoosComponent};
  ```

  > :warning: the Dash material components are currently using MUI v.4, with the aim to transitionning to MUI v.5 shortly.

  The corresponding Python component API is auto-discovered from the React component declared `Props`, while the component Python docstring are automatically generated from the `Props` React docstrings.

  ```javascript
  /** Used to auto-generate the Python component and docstrings */
  const NoosComponent = (props) => {
      const {text} = props;

      return (
          <div>
              <p>{text}</p>
          </div>
      );
  }

  Box.defaultProps = {
    text: 'Sample value',
  };

  Box.propTypes = {
    /** Used to auto-generate the Python component and docstrings */
    text: PropTypes.string,
  };

  export default NoosComponent;
  ```

  > :heavy_exclamation_mark: Be careful to use the correct formatting for your docstrings for them to be properly recognized.



  Once your components have been included into your package entrypoint, run:

  * `yarn build:js`, to generate the JavaScript bundle `dash_material_components.js`
  * `yarn build:py`, to generate the Python class files for the components.
  * `yarn build`, to generate everything: the JavaScript bundles and the Python class files.

  In addition to buikld scripts, the project `package.json` offers linter, formatter and hot-reloader:

  * `yarn format`, to auto-format the React component code.
  * `yarn lint`, to check bundle compliance with ECMA standards.
  * `yarn watch`, to watch the library source directory and rebuild the JavaScript bundle.



  Included below, few resources on how to extend the Dash component library:

  * [basics on React](https://dash.plotly.com/react-for-python-developers)
  * [background on Dash components](https://dash.plotly.com/plugins)
  * [community-maintained component libraries](https://plotly.com/dash-community-components)


pkgId: 85723d350275c68b3f17bdd25e0b11566ffc9161f0e0574e80f15097c901ea56
name: python-dash-new-tab
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Dash component that opens a URL in a new tab
url: https://pypi.org/project/dash-new-tab/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-new-tab-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Dash New Tab is a Dash component library.

  Dash component that opens a URL in a new tab

  Get started with:
  1. Install Dash and its dependencies: https://dash.plotly.com/installation
  2. Run `python usage.py`
  3. Visit http://localhost:8050 in your web browser



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



  If you have selected install_dependencies during the prompt, you can skip this part.

  1. Install npm packages
      ```
      $ npm install
      ```
  2. Create a virtual env and activate.
      ```
      $ virtualenv venv
      $ . venv/bin/activate
      ```
      _Note: venv\Scripts\activate for windows_

  3. Install python packages required to build components.
      ```
      $ pip install -r requirements.txt
      ```
  4. Install the python packages for testing (optional)
      ```
      $ pip install -r tests/requirements.txt
      ```



  - The demo app is in `src/demo` and you will import your example component code into your demo app.
  - Test your code in a Python environment:
      1. Build your code
          ```
          $ npm run build
          ```
      2. Run and modify the `usage.py` sample dash app:
          ```
          $ python usage.py
          ```
  - Write tests for your component.
      - A sample test is available in `tests/test_usage.py`, it will load `usage.py` and you can then automate interactions with selenium.
      - Run the tests with `$ pytest tests`.
      - The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g. https://github.com/plotly/dash-core-components)
  - Add custom styles to your component by putting your custom CSS files into your distribution folder (`dash_new_tab`).
      - Make sure that they are referenced in `MANIFEST.in` so that they get properly included when you're ready to publish your component.
      - Make sure the stylesheets are added to the `_css_dist` dict in `dash_new_tab/__init__.py` so dash will serve them automatically when the component suite is requested.
  - [Review your code](./review_checklist.md)



  1. Build your code:
      ```
      $ npm run build
      ```
  2. Create a Python distribution
      ```
      $ python setup.py sdist bdist_wheel
      ```
      This will create source and wheel distribution in the generated the `dist/` folder.
      See [PyPA](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project)
      for more information.

  3. Test your tarball by copying it into a new environment and installing it locally:
      ```
      $ pip install dash_new_tab-0.0.1.tar.gz
      ```

  4. If it works, then you can publish the component to NPM and PyPI:
      1. Publish on PyPI
          ```
          $ twine upload dist/*
          ```
      2. Cleanup the dist folder (optional)
          ```
          $ rm -rf dist
          ```
      3. Publish on NPM (Optional if chosen False in `publish_on_npm`)
          ```
          $ npm publish
          ```
          _Publishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can set `serve_locally` to `False` and you may see faster load times._

  5. Share your component with the community! https://community.plotly.com/c/dash
      1. Publish this repository to GitHub
      2. Tag your GitHub repository with the plotly-dash tag so that it appears here: https://github.com/topics/plotly-dash
      3. Create a post in the Dash community forum: https://community.plotly.com/c/dash


pkgId: 51f61c77d6a32acbb6832966fb9578b3c20ecb531f0c8380cf1c62c6ade0c8ff
name: python-dash-oflog-components
arch: src
version: 0.0.52
epoch: 0
release: 1
summary: Dash react components for use in oflog data products
url: https://pypi.org/project/dash-oflog-components/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-oflog-components-0.0.52-1.src.rpm
checksum_type: sha256
description:
  dash_oflog_components is a Dash component library.

  Dash react components for use in oflog data products

  Get started with:
  1. Install Dash and its dependencies: https://dash.plotly.com/installation
  2. Run `python usage.py`
  3. Visit http://localhost:8050 in your web browser



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



  If you have selected install_dependencies during the prompt, you can skip this part.

  1. Install npm packages
      ```
      $ npm install
      ```
  2. Create a virtual env and activate.
      ```
      $ virtualenv venv
      $ . venv/bin/activate
      ```
      _Note: venv\Scripts\activate for windows_

  3. Install python packages required to build components.
      ```
      $ pip install -r requirements.txt
      ```
  4. Install the python packages for testing (optional)
      ```
      $ pip install -r tests/requirements.txt
      ```



  - The demo app is in `src/demo` and you will import your example component code into your demo app.
  - Test your code in a Python environment:
      1. Build your code
          ```
          $ npm run build
          ```
      2. Run and modify the `usage.py` sample dash app:
          ```
          $ python usage.py
          ```
  - Write tests for your component.
      - A sample test is available in `tests/test_usage.py`, it will load `usage.py` and you can then automate interactions with selenium.
      - Run the tests with `$ pytest tests`.
      - The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g. https://github.com/plotly/dash-core-components)
  - Add custom styles to your component by putting your custom CSS files into your distribution folder (`dash_oflog_components`).
      - Make sure that they are referenced in `MANIFEST.in` so that they get properly included when you're ready to publish your component.
      - Make sure the stylesheets are added to the `_css_dist` dict in `dash_oflog_components/__init__.py` so dash will serve them automatically when the component suite is requested.
  - [Review your code](./review_checklist.md)



  1. Build your code:
      ```
      $ npm run build
      ```
  2. Create a Python distribution
      ```
      $ python setup.py sdist bdist_wheel
      ```
      This will create source and wheel distribution in the generated the `dist/` folder.
      See [PyPA](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project)
      for more information.

  3. Test your tarball by copying it into a new environment and installing it locally:
      ```
      $ pip install dash_oflog_components-0.0.1.tar.gz
      ```

  4. If it works, then you can publish the component to NPM and PyPI:
      1. Publish on PyPI
          ```
          $ twine upload dist/*
          ```
      2. Cleanup the dist folder (optional)
          ```
          $ rm -rf dist
          ```
      3. Publish on NPM (Optional if chosen False in `publish_on_npm`)
          ```
          $ npm publish
          ```
          _Publishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can set `serve_locally` to `False` and you may see faster load times._

  5. Share your component with the community! https://community.plotly.com/c/dash
      1. Publish this repository to GitHub
      2. Tag your GitHub repository with the plotly-dash tag so that it appears here: https://github.com/topics/plotly-dash
      3. Create a post in the Dash community forum: https://community.plotly.com/c/dash


pkgId: 2fdc37313ecbec45f1f67b611f932c48c700a8fa4ea96c1fb39283b4fa6274a5
name: python-dash-pannellum
arch: src
version: 0.0.6
epoch: 0
release: 1
url: https://pypi.org/project/dash-pannellum/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-pannellum-0.0.6-1.src.rpm
checksum_type: sha256
summary:
  open source panorama viewer for the web. Built using HTML5, CSS3, JavaScript, and WebGL, it is plug-in free.

description:
  Dash Pannellum is a Dash component that integrates the Pannellum panorama viewer into your Dash applications. It allows you to display interactive 360° panoramas, including equirectangular images, cube maps, and 360° videos.


  https://github.com/pip-install-python/dash_pannellum

  ⭐️ Star this component on GitHub! Stay up to date on new releases and browse the codebase.


  - Display equirectangular panoramas
  - Support for multi-resolution panoramas
  - 360° video playback
  - Tour mode with multiple scenes and hotspots
  - Customizable controls
  - Center dot option for orientation
  - pinpoint location of where the user is within the component
  - autoload feature
  - adjustable props
  - supports keyboard controls [left arrow] [right arrow] [up arrow] [down arrow] to move, [shift] zoom in and [control] to zoom out


  `pip install dash-pannellum`


  [View the interactive docs](https://pip-install-python.com/pip/dash_pannellum)


  Here's a simple example of how to use the DashPannellum component:

  ```python
  import dash
  from dash import html
  import dash_pannellum

  app = dash.Dash(__name__)

  app.layout = html.Div([
      dash_pannellum.DashPannellum(
          id='panorama',
          tour={
              "default": {
                  "firstScene": "scene1",
                  "sceneFadeDuration": 1000
              },
              "scenes": {
                  "scene1": {
                      "title": "Example Panorama",
                      "hfov": 110,
                      "pitch": -3,
                      "yaw": 117,
                      "type": "equirectangular",
                      "panorama": "https://pannellum.org/images/from-tree.jpg"
                  }
              }
          },
          width='100%',
          height='400px',
      )
  ])

  if __name__ == '__main__':
      app.run_server(debug=True)
  ```


  - `id` (string): The ID used to identify this component in Dash callbacks.
  - `width` (string): The width of the panorama viewer.
  - `height` (string): The height of the panorama viewer.
  - `tour` (dict): Configuration object for the tour mode.
  - `multiRes` (dict): Configuration object for multi-resolution panoramas.
  - `video` (dict): Configuration object for video panoramas.
  - `customControls` (boolean): If true, enables custom controls for the panorama viewer.
  - `showCenterDot` (boolean): If true, displays a center dot in the panorama viewer.
  - `loaded` (boolean; read-only): Indicates whether the panorama has been loaded.
  - `pitch` (number; read-only): The current pitch of the panorama view.
  - `yaw` (number; read-only): The current yaw of the panorama view.
  - `currentScene` (string; read-only): The ID of the current scene in tour mode.


  ___

  ```python
  tour_config = {
      "default": {
          "firstScene": "scene1",
          "sceneFadeDuration": 1000
      },
      "scenes": {
          "scene1": {
              "title": "First Scene",
              "hfov": 110,
              "pitch": -3,
              "yaw": 117,
              "type": "equirectangular",
              "panorama": "https://pannellum.org/images/from-tree.jpg",
              "hotSpots": [
                  {
                      "pitch": -2.1,
                      "yaw": 132.9,
                      "type": "scene",
                      "text": "Go to Second Scene",
                      "sceneId": "scene2"
                  }
              ]
          },
          "scene2": {
              "title": "Second Scene",
              "hfov": 110,
              "yaw": 5,
              "type": "equirectangular",
              "panorama": "https://pannellum.org/images/bma-0.jpg",
              "hotSpots": [
                  {
                      "pitch": -0.6,
                      "yaw": 37.1,
                      "type": "scene",
                      "text": "Go to First Scene",
                      "sceneId": "scene1",
                      "targetYaw": -23,
                      "targetPitch": 2
                  }
              ]
          }
      }
  }

  dash_pannellum.DashPannellum(
      id='tour-component',
      tour=tour_config,
      width='100%',
      height='400px',
  )
  ```

  Partial panoramas can be displayed by specifying the extents of the equirectangular panorama using the haov, vaov, and vOffset parameters. These parameters define the horizontal angle of view, vertical angle of view, and vertical offset, respectively.
  ```python
  partial_panorama_config = {
      "type": "equirectangular",
      "panorama": "https://pannellum.org/images/charles-street.jpg",
      "haov": 149.87,
      "vaov": 54.15,
      "vOffset": 1.17
  }

  dash_pannellum.DashPannellum(
      id='partial-panorama-component',
      tour={"default": {"firstScene": "scene1"}, "scenes": {"scene1": partial_panorama_config}},
      width='100%',
      height='400px',
  )
  ```
  In this example:

  - `haov`: 149.87 degrees - Specifies the horizontal angle of view.
  - `vaov`: 54.15 degrees - Specifies the vertical angle of view.
  - `vOffset`: 1.17 degrees - Specifies the vertical offset of the panorama.

  These parameters allow you to display panoramas that don't cover a full 360° horizontally or 180° vertically. The vOffset parameter is particularly useful when the panorama is not centered vertically.

  ```python
  multiRes_config = {
      "basePath": "https://pannellum.org/images/multires/library",
      "path": "/%l/%s%y_%x",
      "fallbackPath": "/fallback/%s",
      "extension": "jpg",
      "tileResolution": 512,
      "maxLevel": 6,
      "cubeResolution": 8432
  }

  dash_pannellum.DashPannellum(
      id='multires-component',
      multiRes=multiRes_config,
      width='100%',
      height='400px',
  )
  ```

  ```python
  video_config = {
      "sources": [
          {"src": "https://bitmovin-a.akamaihd.net/content/playhouse-vr/progressive.mp4", "type": "video/mp4"},
      ],
      "poster": "https://bitmovin-a.akamaihd.net/content/playhouse-vr/poster.jpg"
  }

  dash_pannellum.DashPannellum(
      id='video-component',
      video=video_config,
      width='100%',
      height='400px',
  )
  ```

  You can use Dash callbacks to interact with the component. Here's an example that updates an output based on the panorama's current state:
  python
  ```python
  from dash.dependencies import Input, Output

  @app.callback(
      Output('output-div', 'children'),
      Input('panorama', 'loaded'),
      Input('panorama', 'pitch'),
      Input('panorama', 'yaw'),
      Input('panorama', 'currentScene')
  )
  def update_output(loaded, pitch, yaw, current_scene):
      if loaded and pitch is not None and yaw is not None:
          return f'Current Scene: {current_scene}, Pitch: {pitch:.2f}, Yaw: {yaw:.2f}'
      return 'Loading panorama...'
  ```

  Contributions to dash-pannellum are welcome! Please refer to the project's issues on GitHub for any feature requests or bug reports.


  This project is licensed under the MIT License.


pkgId: 762bc7eb1430e8534752470775578693ca6ded63a843dd48ff153fa846fa5d8c
name: python-dash-paperdragon
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: OpenSeaDragon and PaperJS component for Dash and the DSA
url: https://pypi.org/project/dash-paperdragon/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-paperdragon-0.1.6-1.src.rpm
checksum_type: sha256
description:
  Dash PaperDragon is a Dash component library.

  OpenSeaDragon and PaperJS component for Dash and the DSA

  Get started with:
  1. Install Dash and its dependencies: https://dash.plotly.com/installation
  2. Run `python usage.py`
  3. Visit http://localhost:8050 in your web browser



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



  If you have selected install_dependencies during the prompt, you can skip this part.

  1. Install npm packages
      ```
      $ npm install
      ```
  2. Create a virtual env and activate.
      ```
      $ virtualenv venv
      $ . venv/bin/activate
      ```
      _Note: venv\Scripts\activate for windows_

  3. Install python packages required to build components.
      ```
      $ pip install -r requirements.txt
      ```
  4. Install the python packages for testing (optional)
      ```
      $ pip install -r tests/requirements.txt
      ```



  - The demo app is in `src/demo` and you will import your example component code into your demo app.
  - Test your code in a Python environment:
      1. Build your code
          ```
          $ npm run build
          ```
      2. Run and modify the `usage.py` sample dash app:
          ```
          $ python usage.py
          ```
  - Write tests for your component.
      - A sample test is available in `tests/test_usage.py`, it will load `usage.py` and you can then automate interactions with selenium.
      - Run the tests with `$ pytest tests`.
      - The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g. https://github.com/plotly/dash-core-components)
  - Add custom styles to your component by putting your custom CSS files into your distribution folder (`dash_paperdragon`).
      - Make sure that they are referenced in `MANIFEST.in` so that they get properly included when you're ready to publish your component.
      - Make sure the stylesheets are added to the `_css_dist` dict in `dash_paperdragon/__init__.py` so dash will serve them automatically when the component suite is requested.
  - [Review your code](./review_checklist.md)



  1. Build your code:
      ```
      $ npm run build
      ```
  2. Create a Python distribution
      ```
      $ python setup.py sdist bdist_wheel
      ```
      This will create source and wheel distribution in the generated the `dist/` folder.
      See [PyPA](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project)
      for more information.

  3. Test your tarball by copying it into a new environment and installing it locally:
      ```
      $ pip install dash_paperdragon-0.0.1.tar.gz
      ```

  4. If it works, then you can publish the component to NPM and PyPI:
      1. Publish on PyPI
          ```
          $ twine upload dist/*
          ```
      2. Cleanup the dist folder (optional)
          ```
          $ rm -rf dist
          ```
      3. Publish on NPM (Optional if chosen False in `publish_on_npm`)
          ```
          $ npm publish
          ```
          _Publishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can set `serve_locally` to `False` and you may see faster load times._

  5. Share your component with the community! https://community.plotly.com/c/dash
      1. Publish this repository to GitHub
      2. Tag your GitHub repository with the plotly-dash tag so that it appears here: https://github.com/topics/plotly-dash
      3. Create a post in the Dash community forum: https://community.plotly.com/c/dash


pkgId: 5fa0012cd84b61ac2aa093bc33635e9ebfd643afeac5007220724e3828fc595d
name: python-dash-picture-annotation
arch: src
version: 0.1.1
epoch: 0
release: 1
url: https://github.com/cainmagi/dash-picture-annotation
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-picture-annotation-0.1.1-1.src.rpm
checksum_type: sha256
summary:
  Dash porting version of the React project React Picture Annotation. Provide a simple annotation window for a single picture.

description:
  <p><img alt="Banner" src="https://repository-images.githubusercontent.com/883421149/10c3593c-2d90-4eff-a3b5-761946985243"></p>

  <p align="center">
    <a href="https://github.com/cainmagi/dash-picture-annotation/releases/latest"><img alt="GitHub release (latest SemVer)" src="https://img.shields.io/github/v/release/cainmagi/dash-picture-annotation?logo=github&sort=semver&style=flat-square"></a>
    <a href="https://github.com/cainmagi/dash-picture-annotation/releases"><img alt="GitHub all releases" src="https://img.shields.io/github/downloads/cainmagi/dash-picture-annotation/total?logo=github&style=flat-square"></a>
    <a href="https://github.com/cainmagi/dash-picture-annotation/blob/main/LICENSE"><img alt="GitHub" src="https://img.shields.io/github/license/cainmagi/dash-picture-annotation?style=flat-square&logo=opensourceinitiative&logoColor=white"></a>
    <a href="https://pypi.org/project/dash-picture-annotation"><img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/dash-picture-annotation?style=flat-square&logo=pypi&logoColor=white&label=pypi"></a>
  </p>
  <p align="center">
    <a href="https://github.com/cainmagi/dash-picture-annotation/actions/workflows/python-package.yml"><img alt="GitHub Actions (Build)" src="https://img.shields.io/github/actions/workflow/status/cainmagi/dash-picture-annotation/python-package.yml?style=flat-square&logo=githubactions&logoColor=white&label=build"></a>
    <a href="https://github.com/cainmagi/dash-picture-annotation/actions/workflows/python-publish.yml"><img alt="GitHub Actions (Release)" src="https://img.shields.io/github/actions/workflow/status/cainmagi/dash-picture-annotation/python-publish.yml?style=flat-square&logo=githubactions&logoColor=white&label=release"></a>
  </p>

  Dash Picture Annotation is a Dash component library.

  Dash porting version of the React project [React Picture Annotation :link:][git-react-picture-annotation]. Provide a simple annotation window for a single picture.

  The following two figures compare the demos of the original React version and the ported Dash version. Since this project is just a dash component wrapper on the original React component, the performance is the same.

  |   React Picture Annotation    |   Dash Picture Annotation   |
  | :---------------------------: | :-------------------------: |
  | ![demo-react][pic-demo-react] | ![demo-dash][pic-demo-dash] |

  Compared to the original project, this project has the following special features that the original React project does not support:

  1. Responsive sizing: The width of the annotator can be automatically adjusted according to the parent web element.
  2. Different modes: When selecting an annotation, the modifier can be configured as an input box or a dropdown menu box.
  3. Data sanitized: The data is simply sanitized. Even if a not standardized data is passed to the annotator, it still works.
  4. Anti-mistakes: A threshold of the annotation size can be configured to prevent users create a tiny annotation item by mistake.
  5. Disabled: A flag can be configured to make the annotator disabled.
  6. Specified colors: A special color can be configured for an annotator with a specific comment. Different comments can have different colors.
  7. Dynamic colors: Without specifying colors manually, a flag can enable the colors to be automatically calculated based on the hash code of the annotation comments.

  Preview a quick video demo here:

  https://github.com/user-attachments/assets/398fa4ff-4926-4594-a9c6-9bb92d170c63



  Intall the **latest released version** of this package by using the PyPI source:

  ``` sh
  python -m pip install dash-picture-annotation
  ```

  Or use the following commands to install **the developing version** from the GitHub Source when you have already installed [Git :hammer:][tool-git], [NodeJS :hammer:][tool-nodejs], and [Yarn :hammer:][tool-yarn]:

  ```bash
  git clone https://github.com/cainmagi/dash-picture-annotation
  cd dash-picture-annotation
  python -m pip install -r requirements-dev.txt
  yarn install
  yarn build
  python -m pip install .
  ```



  The following signature shows the basic usage of this component.

  ``` python
  import dash_picture_annotation as dpa

  dpa.DashPictureAnnotation(
      id="annotator",
      style={"height": "80vh"},
      data=default_data,  # Can be `None`
      image="/assets/test_image.svg",  # Can be `None`
      options=None,
  )
  ```

  where the `data` is typed by `dpa.Annotations`. It should be formatted like this:

  ```json
  {
    "timestamp": 0,
    "data": [
      {
        "id": "N5fewQ",
        "mark": {
          "x": -224.45, "y": 62.76, "width": 125.53, "height": 125.53, "type": "RECT"
        },
        "comment": "has-a-type"
      },
      {
        "id": "ibJMdK",
        "mark": {
          "x": -36.15, "y": 62.76, "width": 125.53, "height": 125.53, "type": "RECT"
        },
      },
      {
        "id": "...",
        "...": "...",
      }
    ]
  }
  ```

  A full demo for a minimal example can be found [here :link:][link-demo-minimal].

  A full demo for an integrated application can be found [here :link:][link-demo-usage], where the basic usages are displayed.



  Check the documentation to find more details about the examples and APIs.

  https://cainmagi.github.io/dash-picture-annotation/



  See [CONTRIBUTING.md :book:][link-contributing]



  See [Changelog.md :book:][link-changelog]



  - [Kunduin/react-picture-annotation :link:][git-react-picture-annotation]: The original React component implementation of this project.

  [git-react-picture-annotation]:https://github.com/Kunduin/react-picture-annotation

  [tool-git]:https://git-scm.com/downloads
  [tool-nodejs]:https://nodejs.org/en/download/package-manager
  [tool-yarn]:https://yarnpkg.com/getting-started/install

  [pic-demo-react]:https://raw.githubusercontent.com/cainmagi/dash-picture-annotation/main/display/demo-react.png
  [pic-demo-dash]:https://raw.githubusercontent.com/cainmagi/dash-picture-annotation/main/display/demo-dash.png

  [link-contributing]:https://github.com/cainmagi/dash-picture-annotation/blob/main/CONTRIBUTING.md
  [link-changelog]:https://github.com/cainmagi/dash-picture-annotation/blob/main/Changelog.md

  [link-demo-minimal]:https://github.com/cainmagi/dash-picture-annotation/blob/main/examples/minimal.py
  [link-demo-usage]:https://github.com/cainmagi/dash-picture-annotation/blob/main/usage.py


pkgId: 7454329f5b9fc6167ba99d386f8236b8eb72aa0c2a505d70d3db03b27034cb4d
name: python-dash-player
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A Dash component for playing a variety of URLs.
url: https://github.com/plotly/dash-player
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-player-1.1.0-1.src.rpm
checksum_type: sha256
description:
  ![GitHub](https://img.shields.io/github/license/mashape/apistatus.svg)
  [![GitHub stars](https://img.shields.io/github/stars/xhlulu/dash-player.svg)](https://github.com/xhlulu/dash-player/stargazers)

  Dash Player is a Dash component for playing a variety of URLs, including file paths, YouTube, Facebook, Twitch, SoundCloud, Streamable, Vimeo, Wistia, Mixcloud, and DailyMotion. It is wrapped around the [ReactPlayer](https://github.com/cookpete/react-player) component.

  For more detailed documentation on Dash Player and how to use it, visit the official [Dash Player documentation page](https://dash.plotly.com/dash-player)

  For updates and more, please see the ongoing changes to this repository's issue tracker or the Dash community discussion on Dash Player.

  This is a custom community component, so if your organization or company is interested in sponsoring enhancements to this project, [please reach out to the Plotly Dash team](https://plot.ly/dash/pricing).



  Here are the following steps to get started with using Dash Player in your own Dash apps

  ```sh
  $ pip install dash-player
  ```



  | Prop                    | Description                                                                                                                                                                       | Default |
  | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
  | `id`                    | The ID used to identify this component in Dash callbacks.                                                                                                                         |
  | `className`             | The CSS class used to identify this component in external stylesheets.                                                                                                            |
  | `url`                   | The url of the media to be played.                                                                                                                                                |
  | `playing`               | Whether or not the media is currently playing. Can be set to `True` or `False` to play and pause the media, respectively.                                                         | `false` |
  | `loop`                  | Whether or not the media will loop once the player reaches the end. Can be set to `True` or `False` to set looping on or off, respectively.                                       | `false` |
  | `controls`              | Set to true or false to display native player controls. Vimeo, Twitch and Wistia player will always display controls.                                                             | `false` |
  | `volume`                | A number between `0` and `1` representing the volume of the player. If set to None, Dash Player ises default volume on all players.                                               | `null`  |
  | `muted`                 | Set to true or false to mute or unmute player volume, respectively. Only works if volume is set.                                                                                  | `false` |
  | `playbackRate`          | Set the playback rate of the player (only supported by YouTube, Wistia, and file paths).                                                                                          |
  | `width`                 | A number or string representing the pixel width of the player.                                                                                                                    | `640px` |
  | `height`                | A number or string representing the pixel height of the player.                                                                                                                   | `360px` |
  | `style`                 | Optional additional CSS styles. If width or height are supplied within style, then this will override the component-level width or height.                                        | `{}`    |
  | `playsinline`           | Applies the html5 playsinline attribute where supported, which allows videos to be played inline and will not automatically enter fullscreen mode when playback begins (for iOS). | `false` |
  | `currentTime`           | Returns the number of seconds that have been played                                                                                                                               |
  | `secondsLoaded`         | Returns the number of seconds that have been loaded                                                                                                                               |
  | `duration`              | Returns the duration (in seconds) of the currently playing media                                                                                                                  |
  | `intervalCurrentTime`   | Interval in milliseconds at which currentTime prop is updated.                                                                                                                    | `40`    |
  | `intervalSecondsLoaded` | Interval in milliseconds at which secondsLoaded prop is updated.                                                                                                                  | `500`   |
  | `intervalDuration`      | Interval in milliseconds at which duration prop is updated.                                                                                                                       | `500`   |
  | `seekTo`                | Seek to the given number of seconds, or fraction if amount is between `0` and `1`                                                                                                 | `null`  |



  - [Dash](https://dash.plot.ly/) - Main server and interactive components
  - [ReactPlayer](https://www.npmjs.com/package/react-player) - The react component that was wrapped by this



  Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.



  - **Xing Han** - _Initial Work_ - [@xhluca](https://github.com/xhluca)
  - **Alex Hsu** - _Maintainer/Ongoing Developer_ - [@alexshoe](https://github.com/alexshoe)
  - **Alex Johnson** - _Code Review_ - [@alexcjohnson](https://github.com/alexcjohnson)

  See also the list of [contributors](https://github.com/xhlulu/dash-player/contributors) who participated in this project.



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



  Changes to `dash-player` were sponsored by Volkswagen's Center of Excellence for Battery Systems.

  <p float="left" align="center" >
  <img src="https://user-images.githubusercontent.com/42301846/207075484-2c77d1e1-f0b5-43da-89bf-66ac73c50007.png" width=40% aspect-ratio=3/10 >
  </p>


