# packages

pkgId: b041eeb0cc800039413e842e8d11bd2b9e2d31b939aaf33e0f218657216ab0ab
name: python-dabl
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Data Analysis Baseline Library
url: https://pypi.org/project/dabl/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dabl-0.3.1-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/dabl/dabl/actions/workflows/ci.yml/badge.svg)](https://github.com/dabl/dabl/actions/workflows/ci.yml)

  The data analysis baseline library.

  - "Mr Sanchez, are you a data scientist?"
  - "I dabl, Mr president."

  Find more information on the [website](https://dabl.github.io/).



  ```
  pip install dabl
  ```

  or [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/dabl/dabl/main)


  This library is very much still under development. Current code focuses mostly on exploratory visualization and preprocessing.
  There are also drop-in replacements for GridSearchCV and RandomizedSearchCV using successive halfing.
  There are preliminary portfolios in the style of
  [POSH
  auto-sklearn](https://ml.informatik.uni-freiburg.de/papers/18-AUTOML-AutoChallenge.pdf)
  to find strong models quickly.  In essence that boils down to a quick search
  over different gradient boosting models and other tree ensembles and
  potentially kernel methods.

  Check out the [the website](https://dabl.github.io/dev/) and [example gallery](https://dabl.github.io/0.1.9/auto_examples/index.html) to get an idea of the visualizations that are available.

  Stay Tuned!




  [Lux](https://github.com/lux-org/lux) is an awesome project for easy interactive visualization of pandas dataframes within notebooks.


  [Pandas Profiling](https://github.com/pandas-profiling/pandas-profiling) can
  provide a thorough summary of the data in only a single line of code. Using the
  ```ProfileReport()``` method, you are able to access a HTML report of your data
  that can help you find correlations and identify missing data.

  `dabl` focuses less on statistical measures of individual columns, and more on
  providing a quick overview via visualizations, as well as convienient
  preprocessing and model search for machine learning.

rpm_license:
  Copyright (c) 2016, Vighnesh Birodkar All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of project-template nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: f8155c6ef00fbe463ac22d0b85f3392b62abaf9492643055be0915d59db9cabe
name: python-dace
arch: src
version: 0.16.1
epoch: 0
release: 1
summary: Data-Centric Parallel Programming Framework
url: https://github.com/spcl/dace
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dace-0.16.1-1.src.rpm
checksum_type: sha256
description:
  _Decoupling domain science from performance optimization._
  DaCe is a [fast](https://nbviewer.org/github/spcl/dace/blob/master/tutorials/benchmarking.ipynb) parallel programming
  framework that takes code in Python/NumPy and other programming languages, and maps it to high-performance
  **CPU, GPU, and FPGA** programs, which can be optimized to achieve state-of-the-art. Internally, DaCe
  uses the Stateful DataFlow multiGraph (SDFG) *data-centric intermediate
  representation*: A transformable, interactive representation of code based on
  data movement.
  Since the input code and the SDFG are separate, it is possible to optimize a
  program without changing its source, so that it stays readable. On the other
  hand, transformations are customizable and user-extensible, so they can be written
  once and reused in many applications.
  With data-centric parallel programming, we enable **direct knowledge transfer**
  of performance optimization, regardless of the application or the target processor.
  DaCe generates high-performance programs for:
   * Multi-core CPUs (tested on Intel, IBM POWER9, and ARM with SVE)
   * NVIDIA GPUs and AMD GPUs (with HIP)
   * Xilinx and Intel FPGAs
  DaCe can be written inline in Python and transformed in the command-line/Jupyter
  Notebooks or SDFGs can be interactively modified using our [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=phschaad.sdfv).


pkgId: 27c8dc0fa022520407432caaade54991e80233538f8dadaeeb9aee363a61160b
name: python-dace
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Data-Centric Parallel Programming Framework
url: https://github.com/spcl/dace
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dace-1.0.0-1.src.rpm
checksum_type: sha256
description:
  _Decoupling domain science from performance optimization._
  DaCe is a [fast](https://nbviewer.org/github/spcl/dace/blob/main/tutorials/benchmarking.ipynb) parallel programming
  framework that takes code in Python/NumPy and other programming languages, and maps it to high-performance
  **CPU, GPU, and FPGA** programs, which can be optimized to achieve state-of-the-art. Internally, DaCe
  uses the Stateful DataFlow multiGraph (SDFG) *data-centric intermediate
  representation*: A transformable, interactive representation of code based on
  data movement.
  Since the input code and the SDFG are separate, it is possible to optimize a
  program without changing its source, so that it stays readable. On the other
  hand, transformations are customizable and user-extensible, so they can be written
  once and reused in many applications.
  With data-centric parallel programming, we enable **direct knowledge transfer**
  of performance optimization, regardless of the application or the target processor.
  DaCe generates high-performance programs for:
   * Multi-core CPUs (tested on Intel, IBM POWER9, and ARM with SVE)
   * NVIDIA GPUs and AMD GPUs (with HIP)
   * Xilinx and Intel FPGAs
  DaCe can be written inline in Python and transformed in the command-line/Jupyter
  Notebooks or SDFGs can be interactively modified using our [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=phschaad.sdfv).


pkgId: 665c0fc31e817dd0078c67867eb834b31576f488e0bf93c9c72241270f5dce8c
name: python-dacite
arch: src
version: 1.8.1
epoch: 0
release: 1
summary: Simple creation of data classes from dictionaries.
url: https://github.com/konradhalas/dacite
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dacite-1.8.1-1.src.rpm
checksum_type: sha256
description:
  ![](https://user-images.githubusercontent.com/1078369/212840759-174c0f2b-d446-4c3a-b97c-67a0b912e7f6.png)



  [![Build Status](https://travis-ci.org/konradhalas/dacite.svg?branch=master)](https://travis-ci.org/konradhalas/dacite)
  [![Coverage Status](https://coveralls.io/repos/github/konradhalas/dacite/badge.svg?branch=master)](https://coveralls.io/github/konradhalas/dacite?branch=master)
  [![License](https://img.shields.io/pypi/l/dacite.svg)](https://pypi.python.org/pypi/dacite/)
  [![Version](https://img.shields.io/pypi/v/dacite.svg)](https://pypi.python.org/pypi/dacite/)
  [![Python versions](https://img.shields.io/pypi/pyversions/dacite.svg)](https://pypi.python.org/pypi/dacite/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  This module simplifies creation of data classes ([PEP 557][pep-557])
  from dictionaries.



  To install dacite, simply use `pip`:

  ```
  $ pip install dacite
  ```



  Minimum Python version supported by `dacite` is 3.6.



  ```python
  from dataclasses import dataclass
  from dacite import from_dict


  @dataclass
  class User:
      name: str
      age: int
      is_active: bool


  data = {
      'name': 'John',
      'age': 30,
      'is_active': True,
  }

  user = from_dict(data_class=User, data=data)

  assert user == User(name='John', age=30, is_active=True)
  ```



  Dacite supports following features:

  - nested structures
  - (basic) types checking
  - optional fields (i.e. `typing.Optional`)
  - unions
  - forward references
  - collections
  - custom type hooks



  Passing plain dictionaries as a data container between your functions or
  methods isn't a good practice. Of course you can always create your
  custom class instead, but this solution is an overkill if you only want
  to merge a few fields within a single object.

  Fortunately Python has a good solution to this problem - data classes.
  Thanks to `@dataclass` decorator you can easily create a new custom
  type with a list of given fields in a declarative manner. Data classes
  support type hints by design.

  However, even if you are using data classes, you have to create their
  instances somehow. In many such cases, your input is a dictionary - it
  can be a payload from a HTTP request or a raw data from a database. If
  you want to convert those dictionaries into data classes, `dacite` is
  your best friend.

  This library was originally created to simplify creation of type hinted
  data transfer objects (DTO) which can cross the boundaries in the
  application architecture.

  It's important to mention that `dacite` is not a data validation library.
  There are dozens of awesome data validation projects and it doesn't make
  sense to duplicate this functionality within `dacite`. If you want to
  validate your data first, you should combine `dacite` with one of data
  validation library.

  Please check [Use Case](#use-case) section for a real-life example.



  Dacite is based on a single function - `dacite.from_dict`. This function
  takes 3 parameters:

  - `data_class` - data class type
  - `data` - dictionary of input data
  - `config` (optional) - configuration of the creation process, instance
  of `dacite.Config` class

  Configuration is a (data) class with following fields:

  - `type_hooks`
  - `cast`
  - `forward_references`
  - `check_types`
  - `strict`
  - `strict_unions_match`

  The examples below show all features of `from_dict` function and usage
  of all `Config` parameters.



  You can pass a data with nested dictionaries and it will create a proper
  result.

  ```python
  @dataclass
  class A:
      x: str
      y: int


  @dataclass
  class B:
      a: A


  data = {
      'a': {
          'x': 'test',
          'y': 1,
      }
  }

  result = from_dict(data_class=B, data=data)

  assert result == B(a=A(x='test', y=1))
  ```



  Whenever your data class has a `Optional` field and you will not provide
  input data for this field, it will take the `None` value.

  ```python
  from typing import Optional

  @dataclass
  class A:
      x: str
      y: Optional[int]


  data = {
      'x': 'test',
  }

  result = from_dict(data_class=A, data=data)

  assert result == A(x='test', y=None)
  ```



  If your field can accept multiple types, you should use `Union`. Dacite
  will try to match data with provided types one by one. If none will
  match, it will raise `UnionMatchError` exception.

  ```python
  from typing import Union

  @dataclass
  class A:
      x: str

  @dataclass
  class B:
      y: int

  @dataclass
  class C:
      u: Union[A, B]


  data = {
      'u': {
          'y': 1,
      },
  }

  result = from_dict(data_class=C, data=data)

  assert result == C(u=B(y=1))
  ```



  Dacite supports fields defined as collections. It works for both - basic
  types and data classes.

  ```python
  @dataclass
  class A:
      x: str
      y: int


  @dataclass
  class B:
      a_list: List[A]


  data = {
      'a_list': [
          {
              'x': 'test1',
              'y': 1,
          },
          {
              'x': 'test2',
              'y': 2,
          }
      ],
  }

  result = from_dict(data_class=B, data=data)

  assert result == B(a_list=[A(x='test1', y=1), A(x='test2', y=2)])
  ```



  You can use `Config.type_hooks` argument if you want to transform the input
  data of a data class field with given type into the new value. You have to
  pass a following mapping: `{Type: callable}`, where `callable` is a
  `Callable[[Any], Any]`.

  ```python
  @dataclass
  class A:
      x: str


  data = {
      'x': 'TEST',
  }

  result = from_dict(data_class=A, data=data, config=Config(type_hooks={str: str.lower}))

  assert result == A(x='test')
  ```

  If a data class field type is a `Optional[T]` you can pass both -
  `Optional[T]` or just `T` - as a key in `type_hooks`. The same with generic
  collections, e.g. when a field has type `List[T]` you can use `List[T]` to
  transform whole collection or `T` to transform each item.



  It's a very common case that you want to create an instance of a field type
  from the input data with just calling your type with the input value. Of
  course you can use `type_hooks={T: T}` to achieve this goal but `cast=[T]` is
  an easier and more expressive way. It also works with base classes - if `T`
  is a base class of type `S`, all fields of type `S` will be also "casted".

  ```python
  from enum import Enum

  class E(Enum):
      X = 'x'
      Y = 'y'
      Z = 'z'

  @dataclass
  class A:
      e: E


  data = {
      'e': 'x',
  }

  result = from_dict(data_class=A, data=data, config=Config(cast=[E]))



  result = from_dict(data_class=A, data=data, config=Config(cast=[Enum]))

  assert result == A(e=E.X)
  ```



  Definition of forward references can be passed as a `{'name': Type}` mapping to
  `Config.forward_references`. This dict is passed to `typing.get_type_hints()` as the
  `globalns` param when evaluating each field's type.

  ```python
  @dataclass
  class X:
      y: "Y"

  @dataclass
  class Y:
      s: str

  data = from_dict(X, {"y": {"s": "text"}}, Config(forward_references={"Y": Y}))
  assert data == X(Y("text"))
  ```



  There are rare cases when `dacite` built-in type checker can not validate
  your types (e.g. custom generic class) or you have such functionality
  covered by other library and you don't want to validate your types twice.
  In such case you can disable type checking with `Config(check_types=False)`.
  By default types checking is enabled.

  ```python
  T = TypeVar('T')


  class X(Generic[T]):
      pass


  @dataclass
  class A:
      x: X[str]


  x = X[str]()

  assert from_dict(A, {'x': x}, config=Config(check_types=False)) == A(x=x)
  ```



  By default `from_dict` ignores additional keys (not matching data class field)
  in the input data. If you want change this behaviour set `Config.strict` to
  `True`. In case of unexpected key `from_dict` will raise `UnexpectedDataError`
  exception.



  `Union` allows to define multiple possible types for a given field. By default
  `dacite` is trying to find the first matching type for a provided data and it
  returns instance of this type. It means that it's possible that there are other
  matching types further on the `Union` types list. With `strict_unions_match`
  only a single match is allowed, otherwise `dacite` raises `StrictUnionMatchError`.



  Whenever something goes wrong, `from_dict` will raise adequate
  exception. There are a few of them:

  - `WrongTypeError` - raised when a type of a input value does not match
  with a type of a data class field
  - `MissingValueError` - raised when you don't provide a value for a
  required field
  - `UnionMatchError` - raised when provided data does not match any type
  of `Union`
  - `ForwardReferenceError` - raised when undefined forward reference encountered in
  dataclass
  - `UnexpectedDataError` - raised when `strict` mode is enabled and the input
  data has not matching keys
  - `StrictUnionMatchError` - raised when `strict_unions_match` mode is enabled
  and the input data has ambiguous `Union` match



  First of all - if you want to submit your pull request, thank you very much!
  I really appreciate your support.

  Please remember that every new feature, bug fix or improvement should be tested.
  100% code coverage is a must-have.

  We are using a few static code analysis tools to increase the code quality
  (`black`, `mypy`, `pylint`). Please make sure that you are not generating any
  errors/warnings before you submit your PR. You can find current configuration
  in `.github/*` directory.

  Last but not least, if you want to introduce new feature, please discuss it
  first within an issue.



  Clone `dacite` repository:

  ```
  $ git clone git@github.com:konradhalas/dacite.git
  ```

  Create and activate virtualenv in the way you like:

  ```
  $ python3 -m venv dacite-env
  $ source dacite-env/bin/activate
  ```

  Install all `dacite` dependencies:

  ```
  $ pip install -e .[dev]
  ```

  And, optionally but recommended, install pre-commit hook for black:

  ```
  $ pre-commit install
  ```

  To run tests you just have to fire:

  ```
  $ pytest
  ```



  `dacite` is a small library, but its use is potentially very extensive. Thus, it is crucial
  to ensure good performance of the library.

  We achieve that with the help of `pytest-benchmark` library, and a suite of dedicated performance tests
  which can be found in the `tests/performance` directory. The CI process runs these tests automatically,
  but they can also be helpful locally, while developing the library.

  Whenever you run `pytest` command, a new benchmark report is saved to `/.benchmarks` directory.
  You can easily compare these reports by running: `pytest-benchmark compare`, which will load all the runs
  and display them in a table, where you can compare the performance of each run.

  You can even specify which particular runs you want to compare, e.g. `pytest-benchmark compare 0001 0003 0005`.



  There are many cases when we receive "raw" data (Python dicts) as a input to
  our system. HTTP request payload is a very common use case. In most web
  frameworks we receive request data as a simple dictionary. Instead of
  passing this dict down to your "business" code, it's a good idea to create
  something more "robust".

  Following example is a simple `flask` app - it has single `/products` endpoint.
  You can use this endpoint to "create" product in your system. Our core
  `create_product` function expects data class as a parameter. Thanks to `dacite`
  we can easily build such data class from `POST` request payload.


  ```python
  from dataclasses import dataclass
  from typing import List

  from flask import Flask, request, Response

  import dacite

  app = Flask(__name__)


  @dataclass
  class ProductVariantData:
      code: str
      description: str = ''
      stock: int = 0


  @dataclass
  class ProductData:
      name: str
      price: float
      variants: List[ProductVariantData]


  def create_product(product_data: ProductData) -> None:
      pass  # your business logic here


  @app.route("/products", methods=['POST'])
  def products():
      product_data = dacite.from_dict(
          data_class=ProductData,
          data=request.get_json(),
      )
      create_product(product_data=product_data)
      return Response(status=201)

  ```

  What if we want to validate our data (e.g. check if `code` has 6 characters)?
  Such features are out of scope of `dacite` but we can easily combine it with
  one of data validation library. Let's try with
  [marshmallow](https://marshmallow.readthedocs.io).

  First of all we have to define our data validation schemas:

  ```python
  from marshmallow import Schema, fields, ValidationError


  def validate_code(code):
      if len(code) != 6:
          raise ValidationError('Code must have 6 characters.')


  class ProductVariantDataSchema(Schema):
      code = fields.Str(required=True, validate=validate_code)
      description = fields.Str(required=False)
      stock = fields.Int(required=False)


  class ProductDataSchema(Schema):
      name = fields.Str(required=True)
      price = fields.Decimal(required=True)
      variants = fields.Nested(ProductVariantDataSchema(many=True))
  ```

  And use them within our endpoint:

  ```python
  @app.route("/products", methods=['POST'])
  def products():
      schema = ProductDataSchema()
      result, errors = schema.load(request.get_json())
      if errors:
          return Response(
              response=json.dumps(errors),
              status=400,
              mimetype='application/json',
          )
      product_data = dacite.from_dict(
          data_class=ProductData,
          data=result,
      )
      create_product(product_data=product_data)
      return Response(status=201)
  ```

  Still `dacite` helps us to create data class from "raw" dict with validated data.



  `dacite` uses some LRU caching to improve its performance where possible. To use the caching utility:

  ```python
  from dacite import set_cache_size, get_cache_size, clear_cache

  get_cache_size()  # outputs the current LRU max_size, default is 2048
  set_cache_size(4096)  # set LRU max_size to 4096
  set_cache_size(None)  # set LRU max_size to None
  clear_cache()  # Clear the cache
  ```

  The caching is completely transparent from the interface perspective.



  Follow `dacite` updates in [CHANGELOG][changelog].



  Created by [Konrad Hałas][halas-homepage].

  [pep-557]: https://www.python.org/dev/peps/pep-0557/
  [halas-homepage]: https://konradhalas.pl
  [changelog]: https://github.com/konradhalas/dacite/blob/master/CHANGELOG.md


pkgId: 70fe7923ddad69c8ab4b8f9b40759f2cebe8356d527d8f29cb988e66b6eaf4fe
name: python-dacite2
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Simple creation of data classes from dictionaries (fork of dacite).
url: https://github.com/idanmiara/dacite
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dacite2-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/idanmiara/dacite.svg?branch=master)](https://travis-ci.org/idanmiara/dacite)
  [![Coverage Status](https://coveralls.io/repos/github/idanmiara/dacite/badge.svg?branch=master)](https://coveralls.io/github/idanmiara/dacite?branch=master)
  [![License](https://img.shields.io/pypi/l/dacite.svg)](https://pypi.python.org/pypi/dacite/)
  [![Version](https://img.shields.io/pypi/v/dacite.svg)](https://pypi.python.org/pypi/dacite/)
  [![Python versions](https://img.shields.io/pypi/pyversions/dacite.svg)](https://pypi.python.org/pypi/dacite/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  This is a fork of `dacite`: https://github.com/konradhalas/dacite

  This module simplifies creation of data classes ([PEP 557][pep-557])
  from dictionaries.



  To install dacite, simply use `pip`:

  ```
  $ pip install dacite2
  ```



  Minimum Python version supported by `dacite2` is 3.7.



  ```python
  from dataclasses import dataclass
  from dacite import from_dict


  @dataclass
  class User:
      name: str
      age: int
      is_active: bool


  data = {
      'name': 'John',
      'age': 30,
      'is_active': True,
  }

  user = from_dict(data_class=User, data=data)

  assert user == User(name='John', age=30, is_active=True)
  ```



  Dacite supports following features:

  - nested structures
  - (basic) types checking
  - optional fields (i.e. `typing.Optional`)
  - unions
  - forward references
  - collections
  - custom type hooks



  Passing plain dictionaries as a data container between your functions or
  methods isn't a good practice. Of course you can always create your
  custom class instead, but this solution is an overkill if you only want
  to merge a few fields within a single object.

  Fortunately Python has a good solution to this problem - data classes.
  Thanks to `@dataclass` decorator you can easily create a new custom
  type with a list of given fields in a declarative manner. Data classes
  support type hints by design.

  However, even if you are using data classes, you have to create their
  instances somehow. In many such cases, your input is a dictionary - it
  can be a payload from a HTTP request or a raw data from a database. If
  you want to convert those dictionaries into data classes, `dacite` is
  your best friend.

  This library was originally created to simplify creation of type hinted
  data transfer objects (DTO) which can cross the boundaries in the
  application architecture.

  It's important to mention that `dacite` is not a data validation library.
  There are dozens of awesome data validation projects and it doesn't make
  sense to duplicate this functionality within `dacite`. If you want to
  validate your data first, you should combine `dacite` with one of data
  validation library.

  Please check [Use Case](#use-case) section for a real-life example.



  Dacite is based on a single function - `dacite.from_dict`. This function
  takes 3 parameters:

  - `data_class` - data class type
  - `data` - dictionary of input data
  - `config` (optional) - configuration of the creation process, instance
  of `dacite.Config` class

  Configuration is a (data) class with following fields:

  - `type_hooks`
  - `cast`
  - `forward_references`
  - `check_types`
  - `strict`
  - `strict_unions_match`

  The examples below show all features of `from_dict` function and usage
  of all `Config` parameters.



  You can pass a data with nested dictionaries and it will create a proper
  result.

  ```python
  @dataclass
  class A:
      x: str
      y: int


  @dataclass
  class B:
      a: A


  data = {
      'a': {
          'x': 'test',
          'y': 1,
      }
  }

  result = from_dict(data_class=B, data=data)

  assert result == B(a=A(x='test', y=1))
  ```



  Whenever your data class has a `Optional` field and you will not provide
  input data for this field, it will take the `None` value.

  ```python
  from typing import Optional

  @dataclass
  class A:
      x: str
      y: Optional[int]


  data = {
      'x': 'test',
  }

  result = from_dict(data_class=A, data=data)

  assert result == A(x='test', y=None)
  ```



  If your field can accept multiple types, you should use `Union`. Dacite
  will try to match data with provided types one by one. If none will
  match, it will raise `UnionMatchError` exception.

  ```python
  from typing import Union

  @dataclass
  class A:
      x: str

  @dataclass
  class B:
      y: int

  @dataclass
  class C:
      u: Union[A, B]


  data = {
      'u': {
          'y': 1,
      },
  }

  result = from_dict(data_class=C, data=data)

  assert result == C(u=B(y=1))
  ```



  Dacite supports fields defined as collections. It works for both - basic
  types and data classes.

  ```python
  @dataclass
  class A:
      x: str
      y: int


  @dataclass
  class B:
      a_list: List[A]


  data = {
      'a_list': [
          {
              'x': 'test1',
              'y': 1,
          },
          {
              'x': 'test2',
              'y': 2,
          }
      ],
  }

  result = from_dict(data_class=B, data=data)

  assert result == B(a_list=[A(x='test1', y=1), A(x='test2', y=2)])
  ```



  You can use `Config.type_hooks` argument if you want to transform the input
  data of a data class field with given type into the new value. You have to
  pass a mapping of type `Mapping[Type, Callable[[Any], Any]`.

  ```python
  @dataclass
  class A:
      x: str


  data = {
      'x': 'TEST',
  }

  result = from_dict(data_class=A, data=data, config=Config(type_hooks={str: str.lower}))

  assert result == A(x='test')
  ```

  If a data class field type is a `Optional[T]` you can pass both -
  `Optional[T]` or just `T` - as a key in `type_hooks`. The same with generic
  collections, e.g. when a field has type `List[T]` you can use `List[T]` to
  transform whole collection or `T` to transform each item.

  To target all types use `Any`.  Targeting collections without their sub-types
  will target all collections of those types, such as `List` and `Dict`.

  ```python
  @dataclass
  class ShoppingCart:
      store: str
      item_ids: List[int]

  data = {
      'store': '7-Eleven',
      'item_ids': [1, 2, 3],
  }

  def print_value(value):
      print(value)
      return value

  def print_collection(collection):
      for item in collection:
          print(item)
      return collection

  result = from_dict(
      data_class=ShoppingCart,
      data=data,
      config=Config(
          type_hooks={
              Any: print_value,
              List: print_collection
          }
      )
  )
  ```

  prints

  ```
  7-Eleven
  [1, 2, 3]
  1
  2
  3
  ```

  If a data class field type is a `Optional[T]` you can pass both -
  `Optional[T]` or just `T` - as a key in `type_hooks`. The same with generic
  collections, e.g. when a field has type `List[T]` you can use `List[T]` to
  transform whole collection or `T` to transform each item.



  It's a very common case that you want to create an instance of a field type
  from the input data with just calling your type with the input value. Of
  course you can use `type_hooks={T: T}` to achieve this goal but `cast=[T]` is
  an easier and more expressive way. It also works with base classes - if `T`
  is a base class of type `S`, all fields of type `S` will be also "casted".

  ```python
  from enum import Enum

  class E(Enum):
      X = 'x'
      Y = 'y'
      Z = 'z'

  @dataclass
  class A:
      e: E


  data = {
      'e': 'x',
  }

  result = from_dict(data_class=A, data=data, config=Config(cast=[E]))



  result = from_dict(data_class=A, data=data, config=Config(cast=[Enum]))

  assert result == A(e=E.X)
  ```



  Definition of forward references can be passed as a `{'name': Type}` mapping to
  `Config.forward_references`. This dict is passed to `typing.get_type_hints()` as the
  `globalns` param when evaluating each field's type.

  ```python
  @dataclass
  class X:
      y: "Y"

  @dataclass
  class Y:
      s: str

  data = from_dict(X, {"y": {"s": "text"}}, Config(forward_references={"Y": Y}))
  assert data == X(Y("text"))
  ```



  There are rare cases when `dacite` built-in type checker can not validate
  your types (e.g. custom generic class) or you have such functionality
  covered by other library and you don't want to validate your types twice.
  In such case you can disable type checking with `Config(check_types=False)`.
  By default types checking is enabled.

  ```python
  T = TypeVar('T')


  class X(Generic[T]):
      pass


  @dataclass
  class A:
      x: X[str]


  x = X[str]()

  assert from_dict(A, {'x': x}, config=Config(check_types=False)) == A(x=x)
  ```



  By default `from_dict` ignores additional keys (not matching data class field)
  in the input data. If you want change this behaviour set `Config.strict` to
  `True`. In case of unexpected key `from_dict` will raise `UnexpectedDataError`
  exception.



  `Union` allows to define multiple possible types for a given field. By default
  `dacite` is trying to find the first matching type for a provided data and it
  returns instance of this type. It means that it's possible that there are other
  matching types further on the `Union` types list. With `strict_unions_match`
  only a single match is allowed, otherwise `dacite` raises `StrictUnionMatchError`.



  Whenever something goes wrong, `from_dict` will raise adequate
  exception. There are a few of them:

  - `WrongTypeError` - raised when a type of a input value does not match
  with a type of a data class field
  - `MissingValueError` - raised when you don't provide a value for a
  required field
  - `UnionMatchError` - raised when provided data does not match any type
  of `Union`
  - `ForwardReferenceError` - raised when undefined forward reference encountered in
  dataclass
  - `UnexpectedDataError` - raised when `strict` mode is enabled and the input
  data has not matching keys
  - `StrictUnionMatchError` - raised when `strict_unions_match` mode is enabled
  and the input data has ambiguous `Union` match



  First of all - if you want to submit your pull request, thank you very much!
  I really appreciate your support.

  Please remember that every new feature, bug fix or improvement should be tested.
  100% code coverage is a must have.

  We are using a few static code analysis tools to increase the code quality
  (`black`, `mypy`, `pylint`). Please make sure that you are not generating any
  errors/warnings before you submit your PR. You can find current configuration
  in `.travis.yml` file.

  Last but not least, if you want to introduce new feature, please discuss it
  first within an issue.



  Clone `dacite` repository:

  ```
  $ git clone git@github.com:idanmiara/dacite.git
  ```

  Create and activate virtualenv in the way you like:

  ```
  $ python3 -m venv dacite-env
  $ source dacite-env/bin/activate
  ```

  Install all `dacite` dependencies:

  ```
  $ pip install -e .[dev]
  ```

  To run tests you just have to fire:

  ```
  $ pytest
  ```




  There are many cases when we receive "raw" data (Python dicts) as a input to
  our system. HTTP request payload is a very common use case. In most web
  frameworks we receive request data as a simple dictionary. Instead of
  passing this dict down to your "business" code, it's a good idea to create
  something more "robust".

  Following example is a simple `flask` app - it has single `/products` endpoint.
  You can use this endpoint to "create" product in your system. Our core
  `create_product` function expects data class as a parameter. Thanks to `dacite`
  we can easily build such data class from `POST` request payload.


  ```python
  from dataclasses import dataclass
  from typing import List

  from flask import Flask, request, Response

  import dacite

  app = Flask(__name__)


  @dataclass
  class ProductVariantData:
      code: str
      description: str = ''
      stock: int = 0


  @dataclass
  class ProductData:
      name: str
      price: float
      variants: List[ProductVariantData]


  def create_product(product_data: ProductData) -> None:
      pass  # your business logic here


  @app.route("/products", methods=['POST'])
  def products():
      product_data = dacite.from_dict(
          data_class=ProductData,
          data=request.get_json(),
      )
      create_product(product_data=product_data)
      return Response(status=201)

  ```

  What if we want to validate our data (e.g. check if `code` has 6 characters)?
  Such features are out of scope of `dacite` but we can easily combine it with
  one of data validation library. Let's try with
  [marshmallow](https://marshmallow.readthedocs.io).

  First of all we have to define our data validation schemas:

  ```python
  from marshmallow import Schema, fields, ValidationError


  def validate_code(code):
      if len(code) != 6:
          raise ValidationError('Code must have 6 characters.')


  class ProductVariantDataSchema(Schema):
      code = fields.Str(required=True, validate=validate_code)
      description = fields.Str(required=False)
      stock = fields.Int(required=False)


  class ProductDataSchema(Schema):
      name = fields.Str(required=True)
      price = fields.Decimal(required=True)
      variants = fields.Nested(ProductVariantDataSchema(many=True))
  ```

  And use them within our endpoint:

  ```python
  @app.route("/products", methods=['POST'])
  def products():
      schema = ProductDataSchema()
      result, errors = schema.load(request.get_json())
      if errors:
          return Response(
              response=json.dumps(errors),
              status=400,
              mimetype='application/json',
          )
      product_data = dacite.from_dict(
          data_class=ProductData,
          data=result,
      )
      create_product(product_data=product_data)
      return Response(status=201)
  ```

  Still `dacite` helps us to create data class from "raw" dict with validated data.



  Follow `dacite` updates in [CHANGELOG][changelog].



  Created by [Konrad Hałas][halas-homepage].
  Maintained by [Idan Miara][miara-email].

  [pep-557]: https://www.python.org/dev/peps/pep-0557/
  [halas-homepage]: https://konradhalas.pl
  [miara-email]: idan@miara.com
  [changelog]: https://github.com/idanmiara/dacite/blob/master/CHANGELOG.md


pkgId: 809930c27258ba6b4fc8b9c89348bf88a253ce0394c7c4aacaa379d6d3f30598
name: python-dacutil
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Function Tools For Data Analytic
url: https://pypi.org/project/dacutil/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dacutil-0.4.4-1.src.rpm
checksum_type: sha256
description:
  ```bash
  pip install dacutil
  ```
  or dev
  ```bash
  pip install git+https://github.com/attapon-th/dacutil@main
  ```



  ```python
  from dacutil import (
      datediff,
      get_config,
      check_mod11,
      df_strip,
      worker,
      Addict
  )
  ```




  support file type:
  - [x] ini
  - [x] json
  - [x] yaml
  - [x] toml


  ```python
  from dacutil import get_config, Addict


  config: Addict = get_config("path/to/file.ini")

  config: Addict  = get_config("file://path/to/file.ini")


  config: Addict  = get_config("http://example.com/file.json")

  config: Addict  = get_config("https://example.com/file.json")
  ```


pkgId: 96cdf3d166c64ef1d31187f1f3dcfc73dee8ea95d6ccabcbdf1358bef6e38295
name: python-dacy
arch: src
version: 2.7.7
epoch: 0
release: 1
url: https://pypi.org/project/dacy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dacy-2.7.7-1.src.rpm
checksum_type: sha256
summary:
  A Danish pipeline trained in SpaCy that has achieved State-of-the-Art performance on all dependency parsing, NER and POS-tagging for Danish

description:
  <a href="https://github.com/centre-for-humanities-computing/Dacy"><img src="https://github.com/centre-for-humanities-computing/DaCy/raw/main/docs/_static/icon_black_text.png" width="175" height="175" align="right" /></a>


  [![PyPI](https://img.shields.io/pypi/v/dacy.svg)][pypi status]
  [![pip downloads](https://img.shields.io/pypi/dm/dacy.svg)](https://pypi.org/project/dacy/)
  [![Python Version](https://img.shields.io/pypi/pyversions/dacy)][pypi status]
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)]([ruff])
  [![documentation](https://github.com/centre-for-humanities-computing/dacy/actions/workflows/documentation.yml/badge.svg)][documentation]
  [![Tests](https://github.com/centre-for-humanities-computing/dacy/actions/workflows/tests.yml/badge.svg)][tests]

  [pypi status]: https://pypi.org/project/dacy/
  [documentation]: https://centre-for-humanities-computing.github.io/DaCy/
  [tests]: https://github.com/centre-for-humanities-computing/dacy/actions?workflow=Tests
  [ruff]: https://github.com/astral-sh/ruff


  <!-- start short-description -->
  DaCy is a Danish natural language preprocessing framework made with SpaCy. Its largest pipeline has achieved State-of-the-Art performance on Named entity recognition, part-of-speech tagging and dependency parsing for Danish. Feel free to try out the [demo](https://huggingface.co/chcaa/da_dacy_medium_trf?text=DaCy+er+en+pipeline+til+anvendelse+af+dansk+sprogteknologi+lavet+af+K.+Enevoldsen%2C+L.+Hansen+og+K.+Nielbo+fra+Center+for+Humanities+Computing.). This repository contains material for using DaCy, reproducing the results and guides on the usage of the package. Furthermore, it also contains behavioral tests for biases and robustness of Danish NLP pipelines.
  <!-- end short-description -->



  You can install `dacy` via [pip] from [PyPI]:

  ```bash
  pip install dacy
  ```


  To use the model you first have to download either the small, medium, or large model. To see a list of all available models:

  ```python
  import dacy
  for model in dacy.models():
      print(model)




  ```

  To download and load a model simply execute:
  ```python
  nlp = dacy.load("da_dacy_medium_trf-0.2.0")

  nlp = dacy.load("medium")
  ```

  To see more examples, see the [documentation].



  | Documentation              |                                                                                             |
  | -------------------------- | ------------------------------------------------------------------------------------------- |
  | 📚 **[Getting started]**    | Guides and instructions on how to use DaCy and its features.                                |
  | 🦾 **[Performance]**        | A detailed description of the performance of DaCy and comparison with similar Danish models |
  | 📰 **[News and changelog]** | New additions, changes and version history.                                                 |
  | 🎛 **[API References]**     | The detailed reference for DaCy's API. Including function documentation                     |
  | 🙋 **[FAQ]**                | Frequently asked questions                                                                  |


  [Installation]: https://centre-for-humanities-computing.github.io/DaCy/installation.html
  [Getting started]: https://centre-for-humanities-computing.github.io/DaCy/tutorials/basic.html
  [api references]: https://centre-for-humanities-computing.github.io/DaCy/
  [News and changelog]: https://centre-for-humanities-computing.github.io/DaCy/news.html
  [FAQ]: https://centre-for-humanities-computing.github.io/DaCy/faq.html
  [Performance]: https://centre-for-humanities-computing.github.io/DaCy/performance.html





  <br />

  <details>
    <summary> Training and reproduction </summary>

  The folder `training` contains a range of folders with a SpaCy project for each model version. This allows for the reproduction of the results.

  Want to learn more about how DaCy initially came to be, check out this [blog post](https://www.centre-for-humanities-computing.com/post/new-fast-and-efficient-state-of-the-art-in-danish-nlp/).

  </details>

  <br />



  To report issues or request features, please use the [GitHub Issue Tracker](https://github.com/centre-for-humanities-computing/DaCy/issues).
  Questions related to SpaCy are kindly referred to the SpaCy GitHub or forum. Otherwise, please use the Discussion Forums.

  | Type                           |                        |
  | ------------------------------ | ---------------------- |
  | 📚 **FAQ**                      | [FAQ]                  |
  | 🚨 **Bug Reports**              | [GitHub Issue Tracker] |
  | 🎁 **Feature Requests & Ideas** | [GitHub Issue Tracker] |
  | 👩‍💻 **Usage Questions**          | [GitHub Discussions]   |
  | 🗯 **General Discussion**       | [GitHub Discussions]   |

  [Documentation]: https://centre-for-humanities-computing.github.io/DaCy/
  [Installation]: https://centre-for-humanities-computing.github.io/dacy/installation.html
  [Tutorials]: https://centre-for-humanities-computing.github.io/dacy/tutorials.html
  [API Reference]: https://centre-for-humanities-computing.github.io/dacy/references.html
  [FAQ]: https://centre-for-humanities-computing.github.io/dacy/faq.html
  [github issue tracker]: https://github.com/centre-for-humanities-computing/dacy/issues
  [github discussions]: https://github.com/centre-for-humanities-computing/dacy/discussions
  [pip]: https://pypi.org/project/pip/
  [PyPI]: https://pypi.org/project/dacy/

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


pkgId: 26052e7018b8c8b75b6ebb7022a4f1c2b9652d7ccd930ff7cfd934b77be537ac
name: python-dadaptation
arch: src
version: 3.2
epoch: 0
release: 1
summary: Learning Rate Free Learning for Adam, SGD and AdaGrad
url: https://github.com/facebookresearch/dadaptation
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dadaptation-3.2-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/dadaptation)](https://pepy.tech/project/dadaptation) [![Downloads](https://static.pepy.tech/badge/dadaptation/month)](https://pepy.tech/project/dadaptation)

  Learning rate free learning for SGD, AdaGrad and Adam!

  *by Aaron Defazio and Konstantin Mishchenko [(Arxiv)](https://arxiv.org/abs/2301.07733)*

  ``` pip install dadaptation ```

  **NEW V3.0 release uses an improved algorithm that may give different results from past versions. The old version is still availiable under experimental/d_adapt_adam_preprint.**


  We have recently released the [Prodigy](https://github.com/konstmish/prodigy) method, which grows the adapted learning rate faster than D-Adaptation in theory and practice. Try it out if D-Adaptation is under-estimating the learning rate.


  If you use D-Adaptation in a publication, please cite our work as
  ```
  @ARTICLE{defazio2023dadapt,
  author = {Aaron Defazio and Konstantin Mishchenko},
  title = {Learning-Rate-Free Learning by D-Adaptation},
  journal = {The 40th International Conference on Machine Learning (ICML 2023)},
  year = {2023}
  }
  ```



  The provided Pytorch Optimizer classes are drop-in replacements, either copy into your project or use via pip with dadaptation.DAdaptSGD,  dadaptation.DAdaptAdam or dadaptation.DAdaptAdaGrad.

   - **Set the LR parameter to 1.0**. This parameter is not ignored. Setting it larger to smaller will directly scale up or down the D-Adapted learning rate estimate.
   - Different per-layer learning rates can be achieved by setting the layer_scale value in each parameter-group. It defaults to 1.0, and scales each layer's learning rate relative to the other layers.
   - **Use the same learning rate scheduler you would normally use on the problem.**
   - The Adam variant supports AdamW style weight decay, just set decouple=True. It is not turned on by default, so if you are replacing your adam implementation, make sure you use decoupled if necessary.
   - It may be necessary to use larger weight decay than you would normally use, try a factor of 2 or 4 bigger if you see overfitting. D-Adaptation uses larger learning rates than people typically hand-choose, in some cases that requires more decay.
   - Use the log_every setting to see the learning rate being used (d*lr) and the current D bound.
   - Only the AdaGrad version supports sparse gradients. It does not adapt as efficiently as the other variants and should be considered experimental.




   - Added support for layer-wise scaling to DAdaptAdam.


   - Major improvements to DAdaptAdam, improving the performance particularly on Transformer models. This variant may behave differently in practice. The old version is availiable under experimental/d_adapt_adam_preprint if you wish to continue to use it.
   - The IP variant is now the main variant of the method.
   - Added Lion. This is highly experimental. Feedback on it's performance is welcome.


   - Added Adan - should still be considered experimental.
   - Added support for PyTorch's Fully Sharded Data Parallel.
   - Improved support of edge cases such as learning rate zero.
   - Improved logging - uses Python logging rather than print statements

   

  ![vision](figures/dadapt_cifar.png)
  ![vision](figures/dadapt_cifar100.png)
  ![vision](figures/dadapt_imagenet.png)
  ![vision](figures/dadapt_vit.png)
  ![vision](figures/dadapt_lstm.png)
  ![vision](figures/dadapt_roberta.png)
  ![vision](figures/dadapt_gpt.png)
  ![vision](figures/dadapt_fastmri.png)
  ![vision](figures/dadapt_detectron.png)
  ![vision](figures/dadapt_dlrm.png)


  See the [License file](/LICENSE).


pkgId: c02fea5bbd3073c4536242a151f44b6c6cdca83162fbddde3d517a9ec49a000f
name: python-dadata
arch: src
version: 24.10.0
epoch: 0
release: 1
summary: Data cleansing and enrichment via Dadata API.
url: https://github.com/hflabs/dadata-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dadata-24.10.0-1.src.rpm
checksum_type: sha256
description:
  > Data cleansing, enrichment and suggestions via [Dadata API](https://dadata.ru/api)

  Thin Python wrapper over Dadata API.



  ```sh
  pip install dadata
  ```

  Requirements:

  -   Python 3.9+
  -   [httpx](https://pypi.org/project/httpx/)



  Import Dadata client and set API keys:

  ```python
  from dadata import Dadata

  token = "Replace with Dadata API key"
  secret = "Replace with Dadata secret key"
  ```

  Use `with Dadata()` if you want a context-managed client:

  ```python
  with Dadata(token, secret) as dadata:
      ...
  ```

  Alternatively, use `dadata.close()` if you want to close a client explicitly:

  ```python
  dadata = Dadata(token, secret)
  ...
  dadata.close()
  ```

  Call API methods as specified below.



  Import Dadata client and set API keys:

  ```python
  from dadata import DadataAsync

  token = "Replace with Dadata API key"
  secret = "Replace with Dadata secret key"
  ```

  Use `async with DadataAsync()` if you want a context-managed client:

  ```python
  async with DadataAsync(token, secret) as dadata:
      ...
  ```

  Alternatively, use `await dadata.close()` if you want to close a client explicitly:

  ```python
  dadata = DadataAsync(token, secret)
  ...
  await dadata.close()
  ```

  Call API methods as specified below (add `async` / `await` keywords where applicable).





  ```python
  >>> dadata.clean(name="address", source="мск сухонская 11 89")
  {
      'source': 'мск сухонская 11 89',
      'result': 'г Москва, ул Сухонская, д 11, кв 89',
      'postal_code': '127642',
      'country': 'Россия',
      'region': 'Москва',
      'city_area': 'Северо-восточный',
      'city_district': 'Северное Медведково',
      'street': 'Сухонская',
      'house': '11',
      'flat': '89',
      'flat_area': '34.6',
      'flat_price': '6854710',
      'fias_id': '5ee84ac0-eb9a-4b42-b814-2f5f7c27c255',
      'timezone': 'UTC+3',
      'geo_lat': '55.8782557',
      'geo_lon': '37.65372',
      'qc_geo': 0,
      'qc': 0,
      'metro': [ ... ],
      ...
  }
  ```



  Same API method as "validate and cleanse":

  ```python
  >>> dadata.clean(name="address", source="москва сухонская 11")
  {
      'source': 'мск сухонская 11 89',
      'result': 'г Москва, ул Сухонская, д 11, кв 89',
      ...
      'geo_lat': '55.8782557',
      'geo_lon': '37.65372',
      'beltway_hit': 'IN_MKAD',
      'beltway_distance': None,
      'qc_geo': 0,
      ...
  }
  ```



  ```python
  >>> dadata.geolocate(name="address", lat=55.878, lon=37.653)
  [
      { 'value': 'г Москва, ул Сухонская, д 11', ... },
      { 'value': 'г Москва, ул Сухонская, д 11А', ... },
      { 'value': 'г Москва, ул Сухонская, д 13', ... },
      ...
  ]
  ```



  ```python
  >>> dadata.iplocate("46.226.227.20")
  {
      'value': 'г Краснодар',
      'unrestricted_value': '350000, Краснодарский край, г Краснодар',
      'data': { ... }
  }
  ```



  ```python
  >>> dadata.suggest(name="address", query="самара метал")
  [
      { 'value': 'г Самара, пр-кт Металлургов', ... },
      { 'value': 'г Самара, ул Металлистов', ... },
      { 'value': 'г Самара, поселок Зубчаниновка, ул Металлургическая', ... },
      ...
  ]
  ```

  Show suggestions in English:

  ```python
  >>> dadata.suggest(name="address", query="samara metal", language="en")
  [
      { 'value': 'Russia, gorod Samara, prospekt Metallurgov', ... },
      { 'value': 'Russia, gorod Samara, ulitsa Metallistov', ... },
      { 'value': 'Russia, gorod Samara, poselok Zubchaninovka, ulitsa Metallurgicheskaya', ... },
      ...
  ]
  ```

  Constrain by city (Yuzhno-Sakhalinsk):

  ```python
  >>> locations = [{ "kladr_id": "6500000100000" }]
  >>> dadata.suggest(name="address", query="Ватутина", locations=locations)
  [
      {'value': 'г Южно-Сахалинск, ул Ватутина' ... }
  ]
  ```

  Constrain by specific geo point and radius (in Vologda city):

  ```python
  >>> geo = [{ "lat": 59.244634,  "lon": 39.913355, "radius_meters": 200 }]
  >>> dadata.suggest(name="address", query="сухонская", locations_geo=geo)
  [
      {'value': 'г Вологда, ул Сухонская' ... }
  ]
  ```

  Boost city to top (Toliatti):

  ```python
  >>> boost = [{ "kladr_id": "6300000700000" }]
  >>> dadata.suggest(name="address", query="авто", locations_boost=boost)
  [
      {'value': 'Самарская обл, г Тольятти, Автозаводское шоссе' ... },
      {'value': 'Самарская обл, г Тольятти, ул Автомобилистов' ... },
      {'value': 'Самарская обл, г Тольятти, ул Автостроителей' ... },
      ...
  ]
  ```



  ```python
  >>> dadata.find_by_id(name="address", query="9120b43f-2fae-4838-a144-85e43c2bfb29")
  [
      { 'value': 'г Москва, ул Снежная', ... }
  ]
  ```

  Find by KLADR ID:

  ```python
  >>> dadata.find_by_id(name="address", query="77000000000268400")
  ```



  Suggest postal office by address or code:

  ```python
  >>> dadata.suggest(name="postal_unit", query="дежнева 2а")
  [
      {
          'value': '127642',
          'unrestricted_value': 'г Москва, проезд Дежнёва, д 2А',
          'data': { ... }
      }
  ]
  ```

  Find postal office by code:

  ```python
  >>> dadata.find_by_id(name="postal_unit", query="127642")
  [
      {
          'value': '127642',
          'unrestricted_value': 'г Москва, проезд Дежнёва, д 2А',
          'data': { ... }
      }
  ]
  ```

  Find nearest postal office:

  ```python
  >>> dadata.geolocate(name="postal_unit", lat=55.878, lon=37.653, radius_meters=1000)
  [
      {
          'value': '127642',
          'unrestricted_value': 'г Москва, проезд Дежнёва, д 2А',
          'data': { ... }
      }
  ]
  ```



  ```python
  >>> dadata.find_by_id(name="delivery", query="3100400100000")
  [
      {
          'value': '3100400100000',
          'unrestricted_value': 'fe7eea4a-875a-4235-aa61-81c2a37a0440',
          'data': {
              ...
              'boxberry_id': '01929',
              'cdek_id': '344',
              'dpd_id': '196006461'
          }
      }
  ]
  ```



  ```python
  >>> dadata.find_by_id(name="fias", query="9120b43f-2fae-4838-a144-85e43c2bfb29")
  [
      { 'value': 'г Москва, ул Снежная', ... }
  ]
  ```



  ```python
  >>> dadata.suggest(name="country", query="та")
  [
      { 'value': 'Таджикистан', ... },
      { 'value': 'Таиланд', ... },
      { 'value': 'Тайвань', ... },
      ...
  ]
  ```





  ```python
  >>> dadata.find_by_id(name="party", query="7707083893")
  [
      {
          'value': 'ПАО СБЕРБАНК',
          'unrestricted_value': 'ПАО СБЕРБАНК',
          'data': {
              'inn': '7707083893',
              'kpp': '773601001',
              ...
          }
      },
      ...
  ]
  ```

  Find by INN and KPP:

  ```python
  >>> dadata.find_by_id(name="party", query="7707083893", kpp="540602001")
  [
      {
          'value': 'СИБИРСКИЙ БАНК ПАО СБЕРБАНК',
          'unrestricted_value': 'СИБИРСКИЙ БАНК ПАО СБЕРБАНК',
          'data': {
              'inn': '7707083893',
              'kpp': '540602001',
              ...
          }
      }
  ]
  ```



  ```python
  >>> dadata.suggest(name="party", query="сбер")
  [
      { 'value': 'ПАО СБЕРБАНК', ... },
      { 'value': 'АО "СБЕРБРОКЕР"', ... },
      { 'value': 'АО "СБЕРИНВЕСТКАПИТАЛ"', ... },
      ...
  ]
  ```

  Constrain by specific regions (Saint Petersburg and Leningradskaya oblast):

  ```python
  >>> locations = [{ "kladr_id": "7800000000000" }, { "kladr_id": "4700000000000"}]
  >>> dadata.suggest(name="party", query="сбер", locations=locations)
  ```

  Constrain by active companies:

  ```python
  >>> dadata.suggest(name="party", query="сбер", status=["ACTIVE"])
  ```

  Constrain by individual entrepreneurs:

  ```python
  >>> dadata.suggest(name="party", query="сбер", type="INDIVIDUAL")
  ```

  Constrain by head companies, no branches:

  ```python
  >>> dadata.suggest(name="party", query="сбер", branch_type=["MAIN"])
  ```



  ```python
  >>> dadata.find_affiliated("7736207543")
  [
      { 'value': 'ООО "ДЗЕН.ПЛАТФОРМА"', ... },
      { 'value': 'ООО "ЕДАДИЛ"', ... },
      { 'value': 'ООО "ЗНАНИЕ"', ... },
      ...
  ]
  ```

  Search only by manager INN:

  ```python
  >>> dadata.find_affiliated("773006366201", scope=["MANAGERS"])
  [
      { 'value': 'ООО "ЯНДЕКС"', ... },
      { 'value': 'МФ "ФОИ"', ... },
      { 'value': 'АНО ДПО "ШАД"', ... },
  ]
  ```





  ```python
  >>> dadata.find_by_id(name="bank", query="044525225")
  [
      {
          'value': 'ПАО Сбербанк',
          'unrestricted_value': 'ПАО Сбербанк',
          'data': {
              'bic': '044525225',
              'swift': 'SABRRUMM',
              'inn': '7707083893',
              ...
          }
      }
  ]
  ```

  Find by SWIFT code:

  ```python
  >>> dadata.find_by_id(name="bank", query="SABRRUMM")
  ```

  Find by INN:

  ```python
  >>> dadata.find_by_id(name="bank", query="7728168971")
  ```

  Find by INN and KPP:

  ```python
  >>> dadata.find_by_id(name="bank", query="7728168971", kpp="667102002")
  ```

  Find by registration number:

  ```python
  >>> dadata.find_by_id(name="bank", query="1481")
  ```



  ```python
  >>> dadata.suggest(name="bank", query="ти")
  [
      { 'value': 'АО «Тимер Банк»', ... },
      { 'value': 'АО «Тинькофф Банк»', ... },
      { 'value': '«Азиатско-Тихоокеанский Банк» (ПАО)', ... },
      ...
  ]
  ```





  ```python
  >>> dadata.clean(name="name", source="Срегей владимерович иванов")
  {
      'source': 'Срегей владимерович иванов',
      'result': 'Иванов Сергей Владимирович',
      ...
      'surname': 'Иванов',
      'name': 'Сергей',
      'patronymic': 'Владимирович',
      'gender': 'М',
      'qc': 1
  }
  ```



  ```python
  >>> dadata.suggest(name="fio", query="викт")
  [
      { 'value': 'Виктор', ... },
      { 'value': 'Виктория', ... },
      { 'value': 'Викторова', ... },
      ...
  ]
  ```

  Suggest female first name:

  ```python
  >>> dadata.suggest(name="fio", query="викт", parts=["NAME"], gender="FEMALE")
  [
      { 'value': 'Виктория', ... },
      { 'value': 'Викторина', ... }
  ]
  ```





  ```python
  >>> dadata.clean(name="phone", source="9168-233-454")
  {
      'source': '9168-233-454',
      'type': 'Мобильный',
      'phone': '+7 916 823-34-54',
      'provider': 'ПАО "Мобильные ТелеСистемы"',
      'country': 'Россия',
      'region': 'Москва и Московская область',
      'timezone': 'UTC+3',
      'qc': 0,
      ...
  }
  ```





  ```python
  >>> dadata.clean(name="passport", source="4509 235857")
  {
      'source': '4509 235857',
      'series': '45 09',
      'number': '235857',
      'qc': 0
  }
  ```



  ```python
  >>> dadata.suggest(name="fms_unit", query="772 053")
  [
      { 'value': 'ОВД ЗЮЗИНО Г. МОСКВЫ', ... },
      { 'value': 'ОВД РАЙОНА ЗЮЗИНО УВД ЮГО-ЗАО Г. МОСКВЫ', ... },
      { 'value': 'ПАСПОРТНО-ВИЗОВЫМ ОТДЕЛЕНИЕМ ОВД РАЙОНА ЗЮЗИНО Г. МОСКВЫ', ... },
      ...
  ]
  ```





  ```python
  >>> dadata.clean(name="email", source="serega@yandex/ru")
  {
      'source': 'serega@yandex/ru',
      'email': 'serega@yandex.ru',
      'local': 'serega',
      'domain': 'yandex.ru',
      'type': 'PERSONAL',
      'qc': 4
  }
  ```



  ```python
  >>> dadata.suggest(name="email", query="maria@")
  [
      { 'value': 'maria@mail.ru', ... },
      { 'value': 'maria@gmail.com', ... },
      { 'value': 'maria@yandex.ru', ... },
      ...
  ]
  ```





  ```python
  >>> dadata.find_by_id(name="fns_unit", query="5257")
  [
      {
          'value': 'Инспекция ФНС России по Канавинскому району г.Нижнего Новгорода',
          'unrestricted_value': 'Инспекция ФНС России по Канавинскому району г.Нижнего Новгорода',
          'data': {
              'code': '5257'
              'oktmo': '22701000',
              'inn': '5257046101',
              'kpp': '525701001',
              ...
          }
      }
  ]
  ```



  ```python
  >>> dadata.suggest(name="region_court", query="таганско")
  [
      { 'value': 'Судебный участок № 371 Таганского судебного района г. Москвы', ... },
      { 'value': 'Судебный участок № 372 Таганского судебного района г. Москвы', ... },
      { 'value': 'Судебный участок № 373 Таганского судебного района г. Москвы', ... },
      ...
  ]
  ```



  ```python
  >>> dadata.suggest(name="metro", query="алек")
  [
      { 'value': 'Александровский сад', ... },
      { 'value': 'Алексеевская', ... },
      { 'value': 'Площадь Александра Невского 1', ... },
      ...
  ]
  ```

  Constrain by city (Saint Petersburg):

  ```python
  >>> filters = [{ "city": "Санкт-Петербург" }]
  >>> dadata.suggest(name="metro", query="алек", filters=filters)
  [
      { 'value': 'Площадь Александра Невского 1', ... },
      { 'value': 'Площадь Александра Невского 2', ... }
  ]
  ```



  ```python
  >>> dadata.suggest(name="car_brand", query="фо")
  [
      { 'value': 'Volkswagen', ... },
      { 'value': 'Ford', ... },
      { 'value': 'Foton', ... }
  ]
  ```



  ```python
  >>> dadata.suggest(name="currency", query="руб")
  [
      { 'value': 'Белорусский рубль', ... },
      { 'value': 'Российский рубль', ... }
  ]
  ```



  ```python
  >>> dadata.suggest(name="okved2", query="космических")
  [
      { 'value': 'Производство космических аппаратов (в том числе спутников), ракет-носителей', ... },
      { 'value': 'Производство автоматических космических аппаратов', ... },
      { 'value': 'Деятельность космических лабораторий', ... },
      ...
  ]
  ```



  ```python
  >>> dadata.suggest(name="okpd2", query="калоши")
  [
      { 'value': 'Услуги по обрезинованию валенок (рыбацкие калоши)', ... }
  ]
  ```



  Balance:

  ```python
  >>> dadata.get_balance()
  150.00
  ```

  Usage stats:

  ```python
  >>> dadata.get_daily_stats()
  {
      'date': '2024-10-10',
      'services': {
          'clean': 200,
          'company': 0,
          'company_similar': 0,
          'merging': 0,
          'suggestions': 15000,
      },
      'remaining': {
          'clean': 800,
          'company': 50,
          'company_similar': 0,
          'merging': 15000,
          'suggestions': 185000
      }
  }
  ```

  Dataset versions:

  ```python
  >>> dadata.get_versions()
  {
      'dadata': { 'version': 'stable (9048:bf33b2acc8ba)' },
      'factor': {
          'resources': { ... },
          'version': '20.06 (eb70078e)'
      },
      'suggestions': {
          'resources': { ... },
          'version': '20.5 (b55eb7c4)'
      }
  }
  ```



  ```sh
  $ python3 -m venv env
  $ . env/bin/activate
  $ make deps
  $ tox
  ```



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

  Make sure to add or update tests as appropriate.

  Use [Black](https://black.readthedocs.io/en/stable/) for code formatting and [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0-beta.4/) for commit messages.



  This library uses [CalVer](https://calver.org/) with YY.MM.MICRO schema. See changelog for details specific to each release.



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


pkgId: 0cc54bfee6ca5448d03914bf51451a21f7e58fc74c0b1fea6ff05906ac147c6e
name: python-dadude
arch: src
version: 0.2.11
epoch: 0
release: 1
summary: Lakehouse management and orchestration tool.
url: https://pypi.org/project/dadude/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dadude-0.2.11-1.src.rpm
checksum_type: sha256
description:
  Lakehouse management and orchestration tool.



  - The ultimate target lakehouse is the unity catalog, which is to provide benefits from both `deltalake` and `iceberg`.
  - To support writing data to the lakehouse, we currently use the `deltalake-rs` python bindings.
  - For testing purposes, we use the `minio` instance at `http://192.168.18.206:9000`.



  This package is published to the PyPI repository, so you can install it using `pip` anywhere:
  ```bash
  pip install dadude
  ```



  First export the following environment variables:
  ```bash
  export STORAGE_ACCESS_KEY_ID=xxx STORAGE_SECRET_ACCESS_KEY=xxx STORAGE_ENDPOINT_URL=http://192.168.18.206:9000
  ```

  Then you can use the `dadude` module CLI to interact with the lakehouse:
  ```bash
  python -m dadude.cli.read_table staging <table_name> --save_dir <save_dir>
  python -m dadude.cli.write_table write_json_table --local_json_file_path data/silver/xxx.json
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Xu Zhangda  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: 1155d9c3fd4734918e87fc5c1db0102855c68e06b3b6e3edaacabbc50822d2da
name: python-daemail
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Daemonize a command and e-mail the results
url: https://pypi.org/project/daemail/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daemail-0.7.1-1.src.rpm
checksum_type: sha256
description:
  ``daemail`` requires Python 3.8 or higher.  Just use `pip
  <https://pip.pypa.io>`_ for Python 3 (You have pip, right?) to install
  ``daemail`` and its dependencies::
      python3 -m pip install daemail


pkgId: b27b74433adf8fa05327cd880e4d330b2522ea1d90fa319af6d02787f1437aeb
name: python-daemoniker
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Cross-platform daemonization tools.
url: https://github.com/Muterra/py_daemoniker
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daemoniker-0.2.3-1.src.rpm
checksum_type: sha256
description:
  Daemoniker provides a cross-platform (including Windows),
  pure-Python API for creating daemons and communicating with them
  via signals and signal handlers.


pkgId: 2c29dd29cb2f5097178a701229e843f4e6114b3a70ab89d4ce6cf54a787288e9
name: python-daemonocle
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: A Python library for creating super fancy Unix daemons
url: http://github.com/jnrbsn/daemonocle
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daemonocle-1.2.3-1.src.rpm
checksum_type: sha256
description:
  To install via pip::
      pip install daemonocle
  Or download the source code and install manually::
      git clone https://github.com/jnrbsn/daemonocle.git
      cd daemonocle/
      python setup.py install


pkgId: c8e8ba501a350ffd739ebce382d173635a6b98e046681d131bbf01c86c46ecb0
name: python-daff
arch: src
version: 1.3.46
epoch: 0
release: 1
summary: Diff and patch tables
url: https://github.com/paulfitz/daff
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daff-1.3.46-1.src.rpm
checksum_type: sha256
description:
  This is a library for comparing tables, producing a summary of their
  differences, and using such a summary as a patch file.  It is
  optimized for comparing tables that share a common origin, in other
  words multiple versions of the "same" table.
  For a live demo, see:
  > http://paulfitz.github.com/daff/
  Install the library for your favorite language:
  ````sh
  npm install daff -g  # node/javascript
  pip install daff     # python
  gem install daff     # ruby
  composer require paulfitz/daff-php  # php
  install.packages('daff') # R wrapper by Edwin de Jonge
  bower install daff   # web/javascript
  ````
  Other translations are available here:
  > https://github.com/paulfitz/daff/releases
  Or use the library to view csv diffs on github via a chrome extension:
  > https://github.com/theodi/csvhub
  The diff format used by `daff` is specified here:
  > http://paulfitz.github.io/daff-doc/spec.html
  This library is a stripped down version of the coopy toolbox (see
  http://share.find.coop).  To compare tables from different origins,
  or with automatically generated IDs, or other complications, check out
  the coopy toolbox.


pkgId: d0a92f823b7c158901326e1f7216eb1ab408f3169125da9b497a1c711ab944d6
name: python-dafin
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Finance Data
url: https://github.com/mkareshk/dafin
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dafin-0.0.3-1.src.rpm
checksum_type: sha256
description:
  dafin is an open-source Python package designed for collecting, storing, and visualizing financial data from any source. It offers user-friendly APIs that present data in Pandas dataframes, making it easy to visualize with standard Matplotlib methods.



  dafin is available on [PyPI](https://pypi.org/), so you can install it by running the following command:

  ```bash
  pip install dafin
  ```





  The `ReturnsData` class is designed for managing and retrieving asset return data. It allows users to initialize the data with asset symbols, specify a column for price data, and provide a cache path. The class also offers a method to retrieve daily return data for a specific date range.



  You can initialize the `ReturnsData` class by passing a list of asset symbols or a single asset symbol as a string. You can also specify the column name for price data and the path where cache files will be stored.

  Here is an example of how to create an instance of the `ReturnsData` class:

  ```python
  from dafin import ReturnsData


  data_instance = ReturnsData(['AAPL', 'GOOGL'], col_price="Close")


  print(isinstance(data_instance, ReturnsData))  # This should print: True
  ```



  - `assets`: A list of asset symbols or a single asset symbol as a string. This parameter is required.
  - `col_price`: The name of the column for price data. This parameter is optional and defaults to "Adj Close".
  - `path_cache`: The path where cache files are stored. This parameter is optional and defaults to DEFAULT_CACHE_DIR.



  The `get_returns` method allows you to retrieve the daily returns data for a specified date range. If no date range is provided, it will return all available data.

  Here is an example of how to use the `get_returns` method:

  ```python



  returns_data = data_instance.get_returns('2022-01-01', '2022-01-10')


  print(returns_data)  # This will print the DataFrame with the daily returns data between '2022-01-01' and '2022-01-10'
  ```



  - `date_start`: The start date as a string or `datetime.datetime` object. This parameter is optional and defaults to None, in which case all available data will be returned.
  - `date_end`: The end date as a string or `datetime.datetime` object. This parameter is optional and defaults to None, in which case all available data will be returned.



  ```python
  from pathlib import Path

  from dafin import Performance, ReturnsData


  def main():
      """
      Fetch returns data for assets, risk-free assets, and benchmark. Then compute and print the performance summary.
      """

      
      assets = ["AAPL", "AMZN", "SPY"]
      assets_rf = ["BND"]
      assets_benchmark = ["SPY"]

      
      date_start = "2015-01-01"
      date_end = "2019-12-31"

      
      path = Path("experiments")

      
      returns = ReturnsData(assets=assets).get_returns(
          date_start=date_start, date_end=date_end
      )
      returns_rf = ReturnsData(assets=assets_rf).get_returns(
          date_start=date_start, date_end=date_end
      )
      returns_benchmark = ReturnsData(assets=assets_benchmark).get_returns(
          date_start=date_start, date_end=date_end
      )

      
      performance = Performance(
          returns_assets=returns,
          returns_rf=returns_rf,
          returns_benchmark=returns_benchmark,
      )

      
      performance.save_figs(path)
      performance.save_data(path)
      performance.save_results(path)

      
      print(performance.summary)


  if __name__ == "__main__":
      main()
  ```


pkgId: 29083bb3ce7cf9d6a3c69742040b72e8cd254ea92ff688a0013c0e718315f85a
name: python-dafni-cli
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A CLI to access the DAFNI APIs from the command line
url: https://pypi.org/project/dafni-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dafni-cli-1.1.0-1.src.rpm
checksum_type: sha256
description:
  ![Test status](https://github.com/dafnifacility/cli/actions/workflows/test.yml/badge.svg?branch=main) [![codecov](https://codecov.io/gh/dafnifacility/cli/branch/main/graph/badge.svg?token=3T8AQWHSWA)](https://codecov.io/gh/dafnifacility/cli)


  This package provides a command line interface for the [DAFNI platform](https://www.dafni.ac.uk/).



  With python and [pip](https://pip.pypa.io/en/stable/getting-started/) installed and available on the command line use the following to install the CLI.

  ```bash
  pip install dafni-cli
  ```

  Once installed all commands will be accessible via `dafni`. For example you can use

  ```bash
  dafni --help
  ```

  to view a list of all of the available sub commands. Use `--help` on any unfamiliar command to receive more information about it.

  For further documentation on usage [see the page here](https://github.com/dafnifacility/cli/blob/main/docs/dafni_cli.md).


pkgId: f6561fdcf0650012ab651186b074b8f2e08bb4456aff7e363a06fbb4a0955c29
name: python-daft
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: PGM rendering at its finest
url: http://daft-pgm.org
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daft-0.1.2-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://raw.github.com/dfm/daft/master/images/logo.png

  **Daft** is a Python package that uses `matplotlib <http://matplotlib.org/>`_
  to render pixel-perfect *probabilistic graphical models* for publication
  in a journal or on the internet. With a short Python script and an intuitive
  model-building syntax you can design directed and undirected graphs and save
  them in any formats that matplotlib supports.

  Get more information at: `docs.daft-pgm.org <https://docs.daft-pgm.org>`_
  *************************************************************************


pkgId: 8ed8d2958e4b7265709bc3532f47bd6c9027fe82ec6556f7d2c31ef3c1f04de7
name: python-daftlistings
arch: src
version: 2.0.4
epoch: 0
release: 1
url: https://github.com/AnthonyBloomer/daftlistings
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daftlistings-2.0.4-1.src.rpm
checksum_type: sha256
summary:
  A library that enables programmatic interaction with daft.ie. Daft.ie has nationwide coverage and contains about 80% of the total available properties in Ireland.

description:
  [![Build Status](https://travis-ci.org/AnthonyBloomer/daftlistings.svg?branch=master)](https://travis-ci.org/AnthonyBloomer/daftlistings)
  [![codecov](https://codecov.io/gh/AnthonyBloomer/daftlistings/branch/master/graph/badge.svg)](https://codecov.io/gh/AnthonyBloomer/daftlistings)

  A library that enables programmatic interaction with [Daft.ie](https://daft.ie). Daft.ie has nationwide coverage and contains about 80% of the total available properties in Ireland.




  Daftlistings is available on the [Python Package Index (PyPI)](https://pypi.org/project/daftlistings/). You can install daftlistings using pip.

  ``` bash
  virtualenv env
  source env/bin/activate
  pip install daftlistings
  ```

  To install the development version, run:

  ``` bash
  pip install https://github.com/AnthonyBloomer/daftlistings/archive/dev.zip
  ```



  ``` python
  from daftlistings import Daft

  daft = Daft()
  listings = daft.search()

  for listing in listings:
      print(listing.title)
      print(listing.price)
      print(listing.daft_link)
      
  ```

  By default, the Daft search function iterates over each page of results and appends each Listing object to the array that is returned. If you wish to limit the number of results that are returned you can use the `max_pages` argument.

  ```python
  daft.search(max_pages=1)
  ```



  Search for apartments for rent in Dublin.

  ```python
  from daftlistings import Daft, Location, SearchType, PropertyType

  daft = Daft()
  daft.set_location(Location.DUBLIN)
  daft.set_search_type(SearchType.RESIDENTIAL_RENT)
  daft.set_property_type(PropertyType.APARTMENT)

  listings = daft.search()

  for listing in listings:
      print(listing.title)
      print(listing.price)
      print(listing.daft_link)
  ```

  Search for houses for sale in Dublin between 400 and 500k.

  ```python
  from daftlistings import Daft, Location, SearchType, PropertyType

  daft = Daft()
  daft.set_location(Location.DUBLIN)
  daft.set_search_type(SearchType.RESIDENTIAL_SALE)
  daft.set_property_type(PropertyType.HOUSE)
  daft.set_min_price(400000)
  daft.set_max_price(500000)

  listings = daft.search()

  for listing in listings:
      print(listing.title)
      print(listing.price)
      print(listing.daft_link)
  ```

  Search for student accomodation near Dundalk IT.

  ```python
  from daftlistings import Daft, Location, SearchType

  daft = Daft()
  daft.set_location(Location.DUNDALK_INSTITUTE_OF_TECHNOLOGY_LOUTH)
  daft.set_search_type(SearchType.STUDENT_ACCOMMODATION)

  listings = daft.search()

  for listing in listings:
      print(listing.title)
      print(listing.price)
      print(listing.daft_link)
  ```

  Search for commercial listings.

  ```python
  from daftlistings import Daft, SearchType

  daft = Daft()
  daft.set_search_type(SearchType.COMMERCIAL_SALE)

  listings = daft.search()

  for listing in listings:
      print(listing.title)
      print(listing.price)
      print(listing.daft_link)
      print()
  ```

  Search properties according to criteria then sort by nearness to Dublin Castle

  ```python
  from daftlistings import Daft, SearchType

  daft = Daft()

  daft.set_location("Dublin City")
  daft.set_search_type(SearchType.RESIDENTIAL_RENT)
  daft.set_min_price(1000)
  daft.set_max_price(1500)

  listings = daft.search(max_pages=1)

  dublin_castle_coords = [53.3429, -6.2674]
  listings.sort(key=lambda x: x.distance_to(dublin_castle_coords))

  for listing in listings:
      print(f'{listing.title}')
      print(f'{listing.daft_link}')
      print(f'{listing.price}')
      print(f'{listing.distance_to(dublin_castle_coords):.3}km')
      print('')

  ```

  Search properties within 10kms of Dublin city centre

  ```python
  from daftlistings import Daft, SearchType

  daft = Daft()

  daft.set_location("Dublin City Centre", Distance.KM10)
  daft.set_search_type(SearchType.RESIDENTIAL_RENT)

  listings = daft.search(max_pages=1)

  for listing in listings:
      print(f'{listing.title}')
      print(f'{listing.daft_link}')
      print(f'{listing.price}')
      print('')

  ```

  Search rental properties in Dublin with monthly rent lower than 1500 euros and visualize it on a map

  ```python
  import pandas as pd
  from daftlistings import Daft, Location, SearchType, PropertyType, SortType, MapVisualization


  daft = Daft()
  daft.set_location(Location.DUBLIN)
  daft.set_search_type(SearchType.RESIDENTIAL_RENT)
  daft.set_sort_type(SortType.PRICE_ASC)
  daft.set_max_price(1500)

  listings = daft.search()


  with open("result.txt", "w") as fp:
      fp.writelines("%s\n" % listing.as_dict_for_mapping() for listing in listings)


  with open("result.txt") as fp:
    lines = fp.readlines()

  properties = []
  for line in lines:
    properties.append(eval(line))

  df = pd.DataFrame(properties)
  print(df)

  dublin_map = MapVisualization(df)
  dublin_map.add_markers()
  dublin_map.add_colorbar()
  dublin_map.save("ireland_rent.html")
  print("Done, please checkout the html file")
  ```

  Search for apartments for rent in Dublin with an alarm and parking.

  ```python
  from daftlistings import Daft, Location, SearchType, PropertyType, Facility

  daft = Daft()
  daft.set_location(Location.DUBLIN)
  daft.set_search_type(SearchType.RESIDENTIAL_RENT)
  daft.set_property_type(PropertyType.APARTMENT)
  daft.set_facility(Facility.PARKING)
  daft.set_facility(Facility.ALARM)

  listings = daft.search()

  for listing in listings:
      print(listing.title)
      print(listing.price)
      print(listing.daft_link)
      print()
  ```



  The Python unittest module contains its own test discovery function, which you can run from the command line:

  ```
  python -m unittest discover tests/
  ```




    - Fork the project and clone locally.
    - Create a new branch for what you're going to work on.
    - Push to your origin repository.
    - Create a new pull request in GitHub.

  Note: We use (Black)[https://github.com/psf/black] for code formatting. After making any changes to the code, it is important for you to ensure that it passes Black's lint check.


pkgId: 39b663b4e46d3ba2f2e16f478887f4b3e45249eb112511732fea1abbe0831303
name: python-dag-cbor
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Python implementation of the DAG-CBOR codec.
url: https://github.com/hashberg-io/dag-cbor
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dag-cbor-0.3.3-1.src.rpm
checksum_type: sha256
description:
  This is a fully compliant Python implementation of the `DAG-CBOR codec <https://ipld.io/specs/codecs/dag-cbor/spec/>`_, a subset of the `Concise Binary Object Representation (CBOR) <https://cbor.io/>`_ supporting the `IPLD Data Model <https://ipld.io/docs/data-model/>`_ and enforcing a unique (strict) encoded representation of items.


pkgId: 5dcb7a76617de24e2d8203706b471e930812d43622cc37f2cf7e4e8e16208fe8
name: python-dag-craft
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Dag Factory para o Airflow
url: https://github.com/MurilloSSJ/airflow-dag-factory
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dag-craft-0.0.4-1.src.rpm
checksum_type: sha256
description:
  This package is designed to provide a streamlined and efficient way to create and manage Airflow DAGs using the concept of a DAG factory. With the Airflow DAG Factory, you can easily define and configure your DAGs in a modular and reusable manner, reducing duplication and improving maintainability. Whether you are a beginner or an experienced Airflow user, this package will help you accelerate your DAG development process and enhance your workflow automation capabilities.

  Key Features:
  - Modular DAG definition using Python classes
  - Automatic generation of DAGs based on dict tasks
  - Support for dynamic DAG creation based on templates
  - Seamless integration with Airflow's scheduling and execution framework

  Get started with the Airflow DAG Factory today and experience the power of efficient and scalable DAG management in your Airflow workflows.


pkgId: ad2ff32ce84443537a1dee62e3669b41473c482408d3ad22943ec45b049ec75c
name: python-dagdog
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A lightweight DAG system for data analysis dev ops
url: https://pypi.org/project/dagdog/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagdog-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Lightweight DAGs for data analysis dev ops. By the time you finish a project with this lil puppy, you'll never want to use a Jupyter notebook again because
  - you will have wasted less time waiting for your notebook to rerun, by iterating rapidly on modular components instead of rerunning your entire analysis after every code update.
  - your code will already be closer to production-ready, as well as more understandable and reliable.

  Note that this is NOT a replacement for tools like [dagster](https://github.com/dagster-io/dagster) or [prefect](https://github.com/PrefectHQ/prefect). Those tools emphasize production and monitoring, while `dagdog` is strictly a dev-ops tool, allowing a user to rapidly sketch out an analysis pipeline without worrying about production considerations. This allows proofs-of-concept to grow faster (and fail faster).



  See [the demo](https://github.com/zkurtz/dagdog/tree/main/demo). In brief, here's how to work with `dagdog`:
  - Structure your data analysis pipeline as a collection of python modules, with each module defining exactly one task.
  - Within each module, implement the task using a method named `__run__`, with no arguments. (You might choose to call `__run__` from under `if __name__ == "main":`, but `dagdog` does not care about that and will access `__run__` directly.)
  - Create a project entrypoint script, imitating `demo/project.py` to define the execution order of your tasks.
  - Call your project entrypoint, dropping you into an interactive python session, where you can finally call any of the various execution and introspection methods on the `dog` DAG object.




  Install [pyenv and its virtualenv plugin](https://github.com/pyenv/pyenv-virtualenv). Then:
  ```
  pyenv install 3.11.4
  pyenv global 3.11.4
  pyenv virtualenv 3.11.4 dagdog
  pyenv activate dagdog
  ```

  Install poetry:
  ```
  curl -sSL https://install.python-poetry.org | python3 -
  ```

  Set up git hooks:
  ```
  pre-commit install
  ```



  - Easiest-possible usage of a DAG to coordinate execution of a collection of tasks during data analysis dev ops.
  - Flexible commands for execution of the DAG, including running a task in isolation, running only upstream tasks, or running only downstream tasks, etc.
  - All configurations managed natively in python -- users don't need to mess with yaml or json files.
  - Prioritize simplicity above feature-completeness.


pkgId: 21ab270a88ad46b903b41e5bc03b3e37a1fc47ed349c7c3e75e137deb4378ef4
name: python-dageo
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Data Assimilation in Geosciences
url: https://tuda-geo.github.io/dageo
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dageo-1.0.3-1.src.rpm
checksum_type: sha256
description:
  Data Assimilation in Geosciences is, for now, a simple 2D reservoir simulator
  and a straight-forward implementation of the basic *Ensemble smoother with
  multiple data assimilation* (ESMDA) algorithm as presented by Emerick and
  Reynolds, 2013. However, more DA methods and examples might be added in the
  future.
  - **Documentation:** https://tuda-geo.github.io/dageo
  - **Source Code:** https://github.com/tuda-geo/dageo
  - **Bug reports:** https://github.com/tuda-geo/dageo/issues
  Available through pip and conda:
  ``pip install dageo`` / ``conda install -c conda-forge dageo``.

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


pkgId: e4eecd110dce1b4954fb5915c3d11b7781bde8625413b7bb700d653e4f23e50f
name: python-dagger-io
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: A client package for running Dagger pipelines in Python.
url: https://dagger.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagger-io-0.14.0-1.src.rpm
checksum_type: sha256
description:
                               \
                                \
                                  ^__^
                                  (oo)\_______
                                  (__)\       )\/\
                                      ||----w |
                                      ||     ||
  ```
  > **Note**
  > It may take a while for it to finish, especially on first run with cold cache.
  If you need to debug, you can stream the logs from the engine with the `log_output`  config:
  ```python
  config = dagger.Config(log_output=sys.stderr)
  async with dagger.connection(config):
  ```

  - [Documentation](https://docs.dagger.io/sdk/python)
  - [API Reference](https://dagger-io.readthedocs.org)
  - [Source code](https://github.com/dagger/dagger/tree/main/sdk/python)

  The SDK is managed with a Dagger module in `./dev`. To see which tasks are
  available run:
  ```shell
  dagger call -m dev
  ```

  Run pytest in supported Python versions:
  ```shell
  dagger call -m dev test default
  ```
  Check for linting violations:
  ```shell
  dagger call -m dev lint
  ```
  Re-format code following common styling conventions:
  ```shell
  dagger call -m dev format export --path=.
  ```
  Update pinned development dependencies:
  ```shell
  uv lock -U
  ```
  Build and preview the reference documentation:
  ```shell
  dagger call -m dev docs preview up
  ```
  Add `--help` to any command to check all the available options.


pkgId: 4fafc485e41d7d769ff74a2acda6448a57f2c9fd9129cf31884521f318075800
name: python-dagpipe
arch: src
version: 0.2.21
epoch: 0
release: 1
summary: Package that allows user to define lazy evaluated dag pipeline.
url: https://github.com/WojciechBogobowicz/dagpipe
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagpipe-0.2.21-1.src.rpm
checksum_type: sha256
description:
  - [Overview](#overview)
  - [Setup](#setup)
  - [Tutorial](#tutorial)
    - [Quick start](#quick-start)
    - [Functionality overview](#functionality-overview)
      - [Task](#task)
      - [Pipeline](#pipeline)
      - [Visualization](#visualization)
      - [Output split](#output-split)
      - [Set name](#set-name)
      - [Sequential pipe](#sequential-pipe)
      - [conditional\_stops](#conditional_stops)
      - [StoppingTaskHolder](#stoppingtaskholder)
    - [Dig deeper](#dig-deeper)



  *dagpipe - ducktape on your data flow!*

  Package that allows the user to define lazily evaluated DAG (directed acyclic graph) pipeline.


  1. This library uses Graphviz library for visualization. If you want to plot created pipes, [install it on your computer](https://graphviz.org/download/). If not, rest of the functionalities works without it.
  2. Install package via pip with visualization (note: you still have to do step 1):
  ```
  pip install dagpipe[viz]
  ```
  or without it (that version is written in pure python so no additional dependencies would be added during installation process)
  ```
  pip install dagpipe
  ```



  Create pipeline task with task decorators:


  ```python
  import dagpipe


  @dagpipe.task()
  def run_a(param):
      return f"Output of A with {param}"

  @dagpipe.task()
  def run_b(a):
      return f"Output of B with {a}"

  @dagpipe.task()
  def run_c(b):
      return f"Output of C with {b}"
  ```

  Link them:


  ```python
  a = run_a(param="Initial input for A")
  b = run_b(a)
  c = run_c(b)
  ```

  Define pipeline:


  ```
  simple_pipeline = dagpipe.Pipeline(
    input=a,
    outputs=[c]
  )
  ```

  Visualize:


  *Note: This step would only works if you will have properly installed Graphviz on your computer.*


  ```python
  dagpipe.visualize(simple_pipeline)
  ```
  ![png](https://raw.githubusercontent.com/WojciechBogobowicz/dagpipe/master/resources/tutorial_7_0.png)

  Run the whole pipeline
  ```
  simple_pipeline.run()
  ```

      >>>> ['Output of C with Output of B with Output of A with Initial input for A']







  Two types of tasks are supported:
  1. Function task defined with `task` decorator


  ```python
  @dagpipe.task()
  def A(param):
      return f"Output of A with {param}"

  @dagpipe.task()
  def B(a):
      return f"Output of B with {a}"

  @dagpipe.task()
  def C(b):
      return f"Output of C with {b}"

  @dagpipe.task()
  def D(a, c):
      return f"Output of D with {a} and {c}"
  ```

  2. Method tasks defined with `method_task` decorator


  ```python
  class ExampleClass:
      @dagpipe.method_task()
      def E(self, d):
          return f"Output of E with {d}"

      @dagpipe.method_task()
      def F(self, e):
          return f"Output of F with {e}"

      @dagpipe.method_task()
      def G(self, inp):
          return f"Output of G with {inp}"

      @dagpipe.method_task()
      def __call__(self, inp):
          return f"Output from Exampleclass with {inp}"
  ```

  Tasks flow is defined in very intuitive way (like normal functions execution).
  Note that:
  1. You can mix tasks and method tasks in a single pipeline.
  2. You can use more than one task as an input to single task (as shown for d task).


  ```python
  example = ExampleClass()

  a = A(param="Initial input for A")
  b = B(a)
  c = C(b)
  d = D(a, c)
  e = example.E(d)
  f = example.F(e)
  g = example.G(c)
  ec = example(g)
  ```


  To define a pipeline simply pass input and outputs to the Pipeline.
  You can define as many outputs as you want, but only one input.



  ```python
  pipeline = dagpipe.Pipeline(input=a, outputs=[f, ec])
  ```

  You can run the same pipeline with different parameters. Your result would be a list with values for each defined output.


  ```python
  result = pipeline.run()
  print(result)

  new_result = pipeline.run(param="## New input for A ##")
  print(new_result)

  new_result2 = pipeline.run(param="@@ New input for A @@")
  print(new_result2)
  ```
      >>>> ['Output of F with Output of E with Output of D with Output of A with Initial input for A and Output of C with Output of B with Output of A with Initial input for A', 'Output from Exampleclass with Output of G with Output of C with Output of B with Output of A with Initial input for A']

      >>>> ['Output of F with Output of E with Output of D with Output of A with ## New input for A ## and Output of C with Output of B with Output of A with ## New input for A ##', 'Output from Exampleclass with Output of G with Output of C with Output of B with Output of A with ## New input for A ##']

      >>>> ['Output of F with Output of E with Output of D with Output of A with @@ New input for A @@ and Output of C with Output of B with Output of A with @@ New input for A @@', 'Output from Exampleclass with Output of G with Output of C with Output of B with Output of A with @@ New input for A @@']

  But be aware, that when you run it again without parameters it will use last defined parameter


  ```python
  result = pipeline.run()
  print(result)
  ```

      >>>> ['Output of F with Output of E with Output of D with Output of A with @@ New input for A @@ and Output of C with Output of B with Output of A with @@ New input for A @@', 'Output from Exampleclass with Output of G with Output of C with Output of B with Output of A with @@ New input for A @@']



  `visualize` function creates `matplotlib` plot that you can customize.

  Alternatively you can save visualization fo file instead of plotting, by specifying parameter to_file: `dagpipe.visualize(pipeline, to_file="path/to/file")`


  Tasks are named with theirs functions names. Method tasks like `ClassName.function_name`, but there is one special case: `__call__` method is named only with class name.


  ```python
  import matplotlib.pyplot as plt


  dagpipe.visualize(pipeline)
  plt.gcf().set_size_inches(4, 6)
  ```



  ![png](https://raw.githubusercontent.com/WojciechBogobowicz/dagpipe/master/resources/tutorial_22_0.png)


  You can change displaying name in visualization in decorator Task instance name property (eg `a.name = "AAA"`).

  ```python
  pipeline.tasks[0].name = "AAA"
  dagpipe.visualize(pipeline)
  ```
  ![png](https://raw.githubusercontent.com/WojciechBogobowicz/dagpipe/master/resources/tutorial_20_0.png)




  You have to specify `outputs_num` in Task decorator if you want to return more than one output


  ```python
  from typing import Any

  @dagpipe.task()
  def do_nothing(inp):
      return inp

  @dagpipe.task(outputs_num=2)
  def split(inp):
      print("runnin")
      return inp[0], inp[1]

  @dagpipe.task()
  def duplicate(inp):
      return inp*2

  @dagpipe.task()
  def concat(inp1, inp2):
      return inp1 + inp2

  x1 = do_nothing(Any)
  x2, x3 = split(x1)
  x5 = duplicate(x3)
  x6 = concat(x2, x5)

  p = dagpipe.Pipeline(x1, [x6])

  dagpipe.visualize(p)
  p.run(["*first element*", "@second element@"])
  ```

      >>>> runnin
      >>>> ['*first element*@second element@@second element@']





  ![png](https://raw.githubusercontent.com/WojciechBogobowicz/dagpipe/master/resources/tutorial_27_2.png)




  you can set name during flow definition with `set_name` Task method. If you need to name more than one task, just pass list of names.


  ```python
  x1 = do_nothing(Any).set_name("Input Node")
  x2, x3 = split(x1).set_name(["Split - left side", "Split - right side"])
  x5 = duplicate(x3)
  x6 = concat(x2, x5)

  p = dagpipe.Pipeline(x1, [x6])

  dagpipe.visualize(p)
  ```



  ![png](https://raw.githubusercontent.com/WojciechBogobowicz/dagpipe/master/resources/tutorial_29_0.png)




  if your flow is really straightforward you can define it as `sequence`


  ```python
  p = dagpipe.Pipeline.sequential([
      do_nothing,
      duplicate,
      duplicate,
  ])

  dagpipe.visualize(p)
  ```



  ![png](https://raw.githubusercontent.com/WojciechBogobowicz/dagpipe/master/resources/tutorial_31_0.png)




  You can stop pipeline execution conditionally at any step if you specify `conditional_stops` argument in pipeline definition. It is a dict where key is `Task.name` and value is function that would take Task output and will convert it to boolean value. If True returned pipeline execution would be stopped and given task output returned with `StoppingTaskHolder` as second list element.


  ```python

  ```


  ```python
  def is_string(x):
      return isinstance(x, str)

  p = dagpipe.Pipeline.sequential(
      tasks_sequence=[do_nothing, duplicate, duplicate],
      conditional_stops={"do_nothing": is_string}
  )

  print("noramlr run", p.run(5))
  print("stopped run", p.run("5"))


  dagpipe.visualize(p)
  ```

      >>>> noramlr run [20]
      >>>> stopped run ['5', STOPPED AT do_nothing]




  ![png](https://raw.githubusercontent.com/WojciechBogobowicz/dagpipe/master/resources/tutorial_34_1.png)




  you can easily filter out runs that stopped early with `StoppingTaskHolder.in_` method.


  ```python
  outputs = p.run("5")
  if dagpipe.StoppingTaskHolder.in_(outputs):
      print("wrong input format")
  ```

      >>>> wrong input format




  `dagpipe.task` decorator changes function behavior so that when it is called it saves the base function with its arguments to `Task` object instead of calling it.


  ```python
  @dagpipe.task
  def foo(x):
    return x

  x = 1
  print(f"x type before foo processing - {type(x)}")
  x = foo(x)
  print(f"x type after  foo processing - {type(x)}")
  ```

      >>>> x type before foo processing - <class 'int'>
      >>>> x type after  foo processing - <class 'dagpipe.task_core.Task'>


  You can check values that are stored by Task x:


  ```python
  print("Stored function:", x.func)
  print("Stored args: \t", x.args)
  print("Stored kwargs: \t", x.kwargs)
  ```

      Stored function: <function foo at 0x000001CBE13D7B50>
      Stored args: 	 (1,)
      Stored kwargs: 	 {}


  If you want to run stored function, it is possible with `run` method, but normally `Pipeline` object would do it for you.


  ```python
  x.run()
  ```

      1



  Task stores information about input arguments that that are provided to it, so when you put another Task as input to your task, it will have information about the function that should be run before.


  ```python
  @dagpipe.task
  def foo2(x):
    return x

  inp = 1
  x = foo(inp)
  x2 = foo2(x)

  print(f"input arg for x2 is '{x2.args[0]}' which type is {type(x2.args[0])}")
  ```

      input arg for x2 is 'foo' which type is <class 'dagpipe.task_core.Task'>


  Basically, the (*task*, *task argument*) tuple is an edge of directional computing graph. `dagpipe.Pipeline` collects information about all edges, and sorts them in right execution order. After that you can run whole pipeline.


  ```python
  pipeline = dagpipe.Pipeline(input=x, outputs=[x2])
  pipeline.run()
  ```




      [1]


pkgId: 091b1e32369e464b508d04ed40ad5c8e4b94e7eef3a39d697a3b2dbde883930d
name: python-dagshub
arch: src
version: 0.3.39
epoch: 0
release: 1
summary: DagsHub client libraries
url: https://github.com/DagsHub/client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagshub-0.3.39-1.src.rpm
checksum_type: sha256
description:
  To improve your experience, we collect analytics on client usage. If you want to disable analytics collection,
  set the `DAGSHUB_DISABLE_ANALYTICS` environment variable to any value.
  Made with 🐶 by [DagsHub](https://dagshub.com/).


pkgId: 9785c24029d0843c5c194357e069eacf1370f8893ac3380cbdbd2a9281839084
name: python-dagshub-annotation-converter
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Annotation converter between different formats
url: https://pypi.org/project/dagshub-annotation-converter/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagshub-annotation-converter-0.1.2-1.src.rpm
checksum_type: sha256
description:
  This package is intended to be a multi-type importer/exporter/converter
  between different annotation formats.

  This package is currently in development and has not that many features implemented.
  The API is not stable and is subject to change.

  The package consists of the Intermediary Representation (IR) annotation format in Python Objects,
  and importers/exporters for different annotation formats.



  ```bash
  pip install dagshub-annotation-converter
  ```


  - [YOLO BBox, Segmentation, Poses](dagshub_annotation_converter/converters/yolo.py#L81)
  - [Label Studio](dagshub_annotation_converter/formats/label_studio/task.py#L72) (Only task schema implemented, importing from a project is left up to user):
  ```python
  from dagshub_annotation_converter.formats.label_studio.task import LabelStudioTask
  task_obj = LabelStudioTask.from_json("path/to/label_studio_task.json")

  annotations = task_obj.to_ir_annotations()
  ```
  - [CVAT Image](dagshub_annotation_converter/converters/cvat.py#L46)


  - [YOLO BBox, Segmentation, Poses](dagshub_annotation_converter/converters/yolo.py#L126)
  - [Label Studio](dagshub_annotation_converter/formats/label_studio/task.py#L225) (Again, only task schema, uploading the task to the project is left to the user)


pkgId: c3a0726f400defb2e36e43a6bb563d91c893918a0108ac77957ccdff2989f424
name: python-dagster
arch: src
version: 1.8.10
epoch: 0
release: 1
url: https://dagster.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-1.8.10-1.src.rpm
checksum_type: sha256
summary:
  Dagster is an orchestration platform for the development, production, and observation of data assets.

description:
  <div align="center">
    <!-- Note: Do not try adding the dark mode version here with the `picture` element, it will break formatting in PyPI -->
    <a target="_blank" href="https://dagster.io" style="background:none">
      <img alt="dagster logo" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/dagster-readme-header.svg" width="auto" height="100%">
    </a>
    <a target="_blank" href="https://github.com/dagster-io/dagster" style="background:none">
      <img src="https://img.shields.io/github/stars/dagster-io/dagster?labelColor=4F43DD&color=163B36&logo=github">
    </a>
    <a target="_blank" href="https://github.com/dagster-io/dagster/blob/master/LICENSE" style="background:none">
      <img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg?label=license&labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://pypi.org/project/dagster/" style="background:none">
      <img src="https://img.shields.io/pypi/v/dagster?labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://pypi.org/project/dagster/" style="background:none">
      <img src="https://img.shields.io/pypi/pyversions/dagster?labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://twitter.com/dagster" style="background:none">
      <img src="https://img.shields.io/badge/twitter-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=twitter" />
    </a>
    <a target="_blank" href="https://dagster.io/slack" style="background:none">
      <img src="https://img.shields.io/badge/slack-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=slack" />
    </a>
    <a target="_blank" href="https://linkedin.com/showcase/dagster" style="background:none">
      <img src="https://img.shields.io/badge/linkedin-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=linkedin" />
    </a>
  </div>

  **Dagster is a cloud-native data pipeline orchestrator for the whole development lifecycle, with integrated lineage and observability, a declarative programming model, and best-in-class testability.**

  It is designed for **developing and maintaining data assets**, such as tables, data sets, machine learning models, and reports.

  With Dagster, you declare—as Python functions—the data assets that you want to build. Dagster then helps you run your functions at the right time and keep your assets up-to-date.

  Here is an example of a graph of three assets defined in Python:

  ```python
  from dagster import asset
  from pandas import DataFrame, read_html, get_dummies
  from sklearn.linear_model import LinearRegression

  @asset
  def country_populations() -> DataFrame:
      df = read_html("https://tinyurl.com/mry64ebh")[0]
      df.columns = ["country", "pop2022", "pop2023", "change", "continent", "region"]
      df["change"] = df["change"].str.rstrip("%").str.replace("−", "-").astype("float")
      return df

  @asset
  def continent_change_model(country_populations: DataFrame) -> LinearRegression:
      data = country_populations.dropna(subset=["change"])
      return LinearRegression().fit(get_dummies(data[["continent"]]), data["change"])

  @asset
  def continent_stats(country_populations: DataFrame, continent_change_model: LinearRegression) -> DataFrame:
      result = country_populations.groupby("continent").sum()
      result["pop_change_factor"] = continent_change_model.coef_
      return result
  ```

  The graph loaded into Dagster's web UI:

  <p align="center">
    <img width="100%" alt="An example asset graph as rendered in the Dagster UI" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/example-lineage.png">
  </p>

  Dagster is built to be used at every stage of the data development lifecycle - local development, unit tests, integration tests, staging environments, all the way up to production.



  If you're new to Dagster, we recommend reading about its [core concepts](https://docs.dagster.io/concepts) or learning with the hands-on [tutorial](https://docs.dagster.io/tutorial).

  Dagster is available on PyPI and officially supports Python 3.8 through Python 3.12.

  ```bash
  pip install dagster dagster-webserver
  ```

  This installs two packages:

  - `dagster`: The core programming model.
  - `dagster-webserver`: The server that hosts Dagster's web UI for developing and operating Dagster jobs and assets.

  Running on a Mac with an Apple silicon chip? Check the [install details here](https://docs.dagster.io/getting-started/install#installing-dagster-into-an-existing-python-environment).



  You can find the full Dagster documentation [here](https://docs.dagster.io), including the ['getting started' guide](https://docs.dagster.io/getting-started).

  <hr/>



    <p align="center">
      <img width="100%" alt="image" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/key-features-cards.svg">
    </p>



  Identify the key assets you need to create using a declarative approach, or you can focus on running basic tasks. Embrace CI/CD best practices from the get-go: build reusable components, spot data quality issues, and flag bugs early.



  Put your pipelines into production with a robust multi-tenant, multi-tool engine that scales technically and organizationally.



  Maintain control over your data as the complexity scales. Centralize your metadata in one tool with built-in observability, diagnostics, cataloging, and lineage. Spot any issues and identify performance improvement opportunities.

  <hr />



  Dagster provides a growing library of integrations for today’s most popular data tools. Integrate with the tools you already use, and deploy to your infrastructure.

  <br/>
  <p align="center">
      <a target="_blank" href="https://dagster.io/integrations" style="background:none">
          <img width="100%" alt="image" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/integrations-bar-for-readme.png">
      </a>
  </p>



  Connect with thousands of other data practitioners building with Dagster. Share knowledge, get help,
  and contribute to the open-source project. To see featured material and upcoming events, check out
  our [Dagster Community](https://dagster.io/community) page.

  Join our community here:

  - 🌟 [Star us on GitHub](https://github.com/dagster-io/dagster)
  - 📥 [Subscribe to our Newsletter](https://dagster.io/newsletter-signup)
  - 🐦 [Follow us on Twitter](https://twitter.com/dagster)
  - 🕴️ [Follow us on LinkedIn](https://linkedin.com/showcase/dagster)
  - 📺 [Subscribe to our YouTube channel](https://www.youtube.com/@dagsterio)
  - 📚 [Read our blog posts](https://dagster.io/blog)
  - 👋 [Join us on Slack](https://dagster.io/slack)
  - 🗃 [Browse Slack archives](https://discuss.dagster.io)
  - ✏️ [Start a GitHub Discussion](https://github.com/dagster-io/dagster/discussions)



  For details on contributing or running the project for development, check out our [contributing
  guide](https://docs.dagster.io/community/contributing/).



  Dagster is [Apache 2.0 licensed](https://github.com/dagster-io/dagster/blob/master/LICENSE).


pkgId: c1743be4d11f1bbdc71f6280fdc6f78a12bffbdefc9cd83956bc08814f2d388d
name: python-dagster
arch: src
version: 1.9.2
epoch: 0
release: 1
url: https://dagster.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-1.9.2-1.src.rpm
checksum_type: sha256
summary:
  Dagster is an orchestration platform for the development, production, and observation of data assets.

description:
  <div align="center">
    <!-- Note: Do not try adding the dark mode version here with the `picture` element, it will break formatting in PyPI -->
    <a target="_blank" href="https://dagster.io" style="background:none">
      <img alt="dagster logo" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/dagster-readme-header.svg" width="auto" height="100%">
    </a>
    <a target="_blank" href="https://github.com/dagster-io/dagster" style="background:none">
      <img src="https://img.shields.io/github/stars/dagster-io/dagster?labelColor=4F43DD&color=163B36&logo=github">
    </a>
    <a target="_blank" href="https://github.com/dagster-io/dagster/blob/master/LICENSE" style="background:none">
      <img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg?label=license&labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://pypi.org/project/dagster/" style="background:none">
      <img src="https://img.shields.io/pypi/v/dagster?labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://pypi.org/project/dagster/" style="background:none">
      <img src="https://img.shields.io/pypi/pyversions/dagster?labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://twitter.com/dagster" style="background:none">
      <img src="https://img.shields.io/badge/twitter-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=twitter" />
    </a>
    <a target="_blank" href="https://dagster.io/slack" style="background:none">
      <img src="https://img.shields.io/badge/slack-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=slack" />
    </a>
    <a target="_blank" href="https://linkedin.com/showcase/dagster" style="background:none">
      <img src="https://img.shields.io/badge/linkedin-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=linkedin" />
    </a>
  </div>

  **Dagster is a cloud-native data pipeline orchestrator for the whole development lifecycle, with integrated lineage and observability, a declarative programming model, and best-in-class testability.**

  It is designed for **developing and maintaining data assets**, such as tables, data sets, machine learning models, and reports.

  With Dagster, you declare—as Python functions—the data assets that you want to build. Dagster then helps you run your functions at the right time and keep your assets up-to-date.

  Here is an example of a graph of three assets defined in Python:

  ```python
  from dagster import asset
  from pandas import DataFrame, read_html, get_dummies
  from sklearn.linear_model import LinearRegression

  @asset
  def country_populations() -> DataFrame:
      df = read_html("https://tinyurl.com/mry64ebh")[0]
      df.columns = ["country", "pop2022", "pop2023", "change", "continent", "region"]
      df["change"] = df["change"].str.rstrip("%").str.replace("−", "-").astype("float")
      return df

  @asset
  def continent_change_model(country_populations: DataFrame) -> LinearRegression:
      data = country_populations.dropna(subset=["change"])
      return LinearRegression().fit(get_dummies(data[["continent"]]), data["change"])

  @asset
  def continent_stats(country_populations: DataFrame, continent_change_model: LinearRegression) -> DataFrame:
      result = country_populations.groupby("continent").sum()
      result["pop_change_factor"] = continent_change_model.coef_
      return result
  ```

  The graph loaded into Dagster's web UI:

  <p align="center">
    <img width="100%" alt="An example asset graph as rendered in the Dagster UI" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/example-lineage.png">
  </p>

  Dagster is built to be used at every stage of the data development lifecycle - local development, unit tests, integration tests, staging environments, all the way up to production.



  If you're new to Dagster, we recommend reading about its [core concepts](https://docs.dagster.io/concepts) or learning with the hands-on [tutorial](https://docs.dagster.io/tutorial).

  Dagster is available on PyPI and officially supports Python 3.9 through Python 3.12.

  ```bash
  pip install dagster dagster-webserver
  ```

  This installs two packages:

  - `dagster`: The core programming model.
  - `dagster-webserver`: The server that hosts Dagster's web UI for developing and operating Dagster jobs and assets.

  Running on a Mac with an Apple silicon chip? Check the [install details here](https://docs.dagster.io/getting-started/install#installing-dagster-into-an-existing-python-environment).



  You can find the full Dagster documentation [here](https://docs.dagster.io), including the ['getting started' guide](https://docs.dagster.io/getting-started).

  <hr/>



    <p align="center">
      <img width="100%" alt="image" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/key-features-cards.svg">
    </p>



  Identify the key assets you need to create using a declarative approach, or you can focus on running basic tasks. Embrace CI/CD best practices from the get-go: build reusable components, spot data quality issues, and flag bugs early.



  Put your pipelines into production with a robust multi-tenant, multi-tool engine that scales technically and organizationally.



  Maintain control over your data as the complexity scales. Centralize your metadata in one tool with built-in observability, diagnostics, cataloging, and lineage. Spot any issues and identify performance improvement opportunities.

  <hr />



  Dagster provides a growing library of integrations for today’s most popular data tools. Integrate with the tools you already use, and deploy to your infrastructure.

  <br/>
  <p align="center">
      <a target="_blank" href="https://dagster.io/integrations" style="background:none">
          <img width="100%" alt="image" src="https://raw.githubusercontent.com/dagster-io/dagster/master/.github/integrations-bar-for-readme.png">
      </a>
  </p>



  Connect with thousands of other data practitioners building with Dagster. Share knowledge, get help,
  and contribute to the open-source project. To see featured material and upcoming events, check out
  our [Dagster Community](https://dagster.io/community) page.

  Join our community here:

  - 🌟 [Star us on GitHub](https://github.com/dagster-io/dagster)
  - 📥 [Subscribe to our Newsletter](https://dagster.io/newsletter-signup)
  - 🐦 [Follow us on Twitter](https://twitter.com/dagster)
  - 🕴️ [Follow us on LinkedIn](https://linkedin.com/showcase/dagster)
  - 📺 [Subscribe to our YouTube channel](https://www.youtube.com/@dagsterio)
  - 📚 [Read our blog posts](https://dagster.io/blog)
  - 👋 [Join us on Slack](https://dagster.io/slack)
  - 🗃 [Browse Slack archives](https://discuss.dagster.io)
  - ✏️ [Start a GitHub Discussion](https://github.com/dagster-io/dagster/discussions)



  For details on contributing or running the project for development, check out our [contributing
  guide](https://docs.dagster.io/community/contributing/).



  Dagster is [Apache 2.0 licensed](https://github.com/dagster-io/dagster/blob/master/LICENSE).


pkgId: e15b25603f5dcafe380413596a518e48556e75cd2b97f14b2f09d8f15ec20173
name: python-dagster-airlift
arch: src
version: 0.0.27
epoch: 0
release: 1
summary: Tooling to assist with migrating from Airflow to Dagster.
url: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-airlift
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-airlift-0.0.27-1.src.rpm
checksum_type: sha256
description:
  Airlift is a toolkit for observing Airflow instances from within Dagster and for accelerating the migration of Airflow DAGs to Dagster assets.



  - Observe Airflow DAGs and their execution history with no changes to Airflow code
  - Model and observe assets orchestrated by Airflow with no changes to Airflow code
  - Enable a migration process that
    - Can be done task-by-task in any order with minimal coordination
    - Has task-by-task rollback to reduce risk
    - That retains Airflow DAG structure and execution history during the migration



  - **Peer**
    - Observe an Airflow instance from within a Dagster Deployment via the Airflow REST API.
    - This loads every Airflow DAG as an asset definition and creates a sensor that polls Airflow for execution history.
  - **Observe**
    - Add a mapping that maps the Airflow DAG and task id to a basket of definitions that you want to observe. (e.g. render the full lineage the dbt models an Airflow task orchestrates)
    - The sensor used for peering also polls for task execution history, and adds materializations to an observed asset when its corresponding task successfully executes
  - **Migrate**
    - Selectively move execution of Airflow tasks to Dagster Software Defined Assets





  Airlift depends on the the availability of Airflow’s REST API. Airflow’s REST API was made stable in its 2.0 release (Dec 2020) and was introduced experimentally in 1.10 in August 2018. Currently Airflow requires the availability of the REST API.

  - **OSS:** Stable as of 2.00
  - **MWAA**
    - Note: only available in Airflow 2.4.3 or later on MWAA.
  - **Cloud Composer:** No limitations as far as we know.
  - **Astronomer:** No limitations as far as we know.



  We've provided a tutorial to help get you started with airlift tooling and process, which can be found [here](https://github.com/dagster-io/airlift-tutorial).


pkgId: 8928dbe97bd3784348acee5c09e846f1f4cbdc32a90c9133ae09f844aa848556
name: python-dagster-airlift
arch: src
version: 0.0.28
epoch: 0
release: 1
summary: Tooling to assist with migrating from Airflow to Dagster.
url: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-airlift
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-airlift-0.0.28-1.src.rpm
checksum_type: sha256
description:
  Airlift is a toolkit for observing Airflow instances from within Dagster and for accelerating the migration of Airflow DAGs to Dagster assets.



  - Observe Airflow DAGs and their execution history with no changes to Airflow code
  - Model and observe assets orchestrated by Airflow with no changes to Airflow code
  - Enable a migration process that
    - Can be done task-by-task in any order with minimal coordination
    - Has task-by-task rollback to reduce risk
    - That retains Airflow DAG structure and execution history during the migration



  - **Peer**
    - Observe an Airflow instance from within a Dagster Deployment via the Airflow REST API.
    - This loads every Airflow DAG as an asset definition and creates a sensor that polls Airflow for execution history.
  - **Observe**
    - Add a mapping that maps the Airflow DAG and task id to a basket of definitions that you want to observe. (e.g. render the full lineage the dbt models an Airflow task orchestrates)
    - The sensor used for peering also polls for task execution history, and adds materializations to an observed asset when its corresponding task successfully executes
  - **Migrate**
    - Selectively move execution of Airflow tasks to Dagster Software Defined Assets





  Airlift depends on the the availability of Airflow’s REST API. Airflow’s REST API was made stable in its 2.0 release (Dec 2020) and was introduced experimentally in 1.10 in August 2018. Currently Airflow requires the availability of the REST API.

  - **OSS:** Stable as of 2.00
  - **MWAA**
    - Note: only available in Airflow 2.4.3 or later on MWAA.
  - **Cloud Composer:** No limitations as far as we know.
  - **Astronomer:** No limitations as far as we know.



  We've provided a tutorial to help get you started with airlift tooling and process, which can be found [here](https://github.com/dagster-io/airlift-migration-tutorial).


pkgId: 6fb5ca88458610c31437a5dde03f8d11c9fac669b49b6c62144eac731fb86bfe
name: python-dagster-cloud
arch: src
version: 1.8.10
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://dagster.io/cloud
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-cloud-1.8.10-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a target="_blank" href="https://dagster.io/cloud" style="background:none">
      <img src="https://github.com/dagster-io/dagster-cloud/raw/main/assets/dagster-cloud-logo.png" width="auto"/>
    </a>
    <br /><br />
    <a target="_blank" href="https://twitter.com/dagster" style="background:none">
      <img src="https://img.shields.io/badge/twitter-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=twitter" />
    </a>
    <a target="_blank" href="https://dagster.io/slack" style="background:none">
      <img src="https://img.shields.io/badge/slack-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=slack" />
    </a>
    <a target="_blank" href="https://linkedin.com/showcase/dagster" style="background:none">
      <img src="https://img.shields.io/badge/linkedin-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=linkedin" />
    </a>
    <a target="_blank" href="https://github.com/dagster-io/dagster" style="background:none">
      <img src="https://img.shields.io/github/stars/dagster-io/dagster?labelColor=4F43DD&color=163B36&logo=github">
    </a>
    <br />
    <a target="_blank" href="https://pypi.org/project/dagster-cloud/" style="background:none">
      <img src="https://img.shields.io/pypi/v/dagster-cloud?labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://pypi.org/project/dagster-cloud/" style="background:none">
      <img src="https://img.shields.io/pypi/pyversions/dagster-cloud?labelColor=4F43DD&color=163B36">
    </a>
  </p>



  The enterprise orchestration platform that puts developer experience first, with fully serverless or hybrid deployments, native branching, and out-of-the-box CI/CD.



  The complete Dagster Cloud feature set can be found on our [website](https://dagster.io/cloud). You
  can [sign up for Dagster Cloud](https://dagster.cloud/signup) and get started with a free 30 day
  trial.



  The Dagster Cloud Agent is available on PyPI and officially supports Python 3.8.

  ```
  pip install dagster-cloud
  ```



  You can find the full Dagster Cloud documentation on our
  [website](https://docs.dagster.io/dagster-cloud).



  Connect with thousands of other data practitioners building with Dagster. Share knowledge, get help,
  and contribute to the open-source project. To see featured material and upcoming events, check out
  our [Dagster Community](https://dagster.io/community) page.

  Join our community here:

  - 🌟 [Star us on Github](https://github.com/dagster-io/dagster)
  - 📥 [Subscribe to our Newsletter](https://dagster.io/newsletter-signup)
  - 🐦 [Follow us on Twitter](https://twitter.com/dagster)
  - 🕴️ [Follow us on LinkedIn](https://linkedin.com/showcase/dagster)
  - 📺 [Subscribe to our YouTube channel](https://www.youtube.com/channel/UCfLnv9X8jyHTe6gJ4hVBo9Q)
  - 📚 [Read our blog posts](https://dagster.io/blog)
  - 👋 [Join us on Slack](https://dagster.io/slack)
  - 🗃 [Browse Slack archives](https://discuss.dagster.io)
  - ✏️ [Start a Github Discussion](https://github.com/dagster-io/dagster/discussions)


pkgId: c843d6f7853688bad65dfb07e8b888b1d6d53a015dd47b87b38df22fb2e8ec41
name: python-dagster-dingtalk
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: A dagster plugin for the DingTalk
url: https://pypi.org/project/dagster-dingtalk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-dingtalk-0.1.15-1.src.rpm
checksum_type: sha256
description:
  该资源允许定义单个钉钉自定义机器人的 Webhook 端点，以便于发送文本、Markdown、Link、 ActionCard、FeedCard 消息，消息具体样式可参考
  [钉钉开放平台 | 自定义机器人发送消息的消息类型](https://open.dingtalk.com/document/orgapp/custom-bot-send-message-type)。

  - **access_token** (str):
          机器人 Webhook 地址中的 access_token 值。
  - **secret** (str, optional):
      如使用加签安全配置，则需传签名密钥。默认值为 None。
  - **alias** (str, optional):
      别名，仅用作标记。默认值为 None。
  - **base_url** (str, optional):
      通用地址，一般无需更改。默认值为 “https://oapi.dingtalk.com/robot/send”。

  ```python
  from dagster_dingtalk import DingTalkWebhookResource
  from dagster import op, In, OpExecutionContext, job, Definitions
  @op(required_resource_keys={"dingtalk_webhook"}, ins={"text": In(str)})
  def op_send_text(context:OpExecutionContext, text:str):
      dingtalk_webhook:DingTalkWebhookResource = context.resources.dingtalk_webhook
      dingtalk_webhook.send_text(text)
  @job
  def job_send_text():
      op_send_text()
  defs = Definitions(
      jobs=[job_send_text],
      resources={"dingtalk_webhook": DingTalkWebhookResource(access_token = "<access_token>", secret = "<secret>")}
  )
  ```

  如果你事先不确定会用到哪个 webhook 机器人，或是需要根据代码逻辑动态选择 webhook ，dagster 提供了一种 [在运行时配置资源](https://docs.dagster.io/concepts/resources#configuring-resources-at-launch-time)
  的原生支持。以下是示例：
  ```python
  from dagster_dingtalk import DingTalkWebhookResource
  from dagster import op, In, OpExecutionContext, job, Definitions, schedule, RunRequest, RunConfig
  @op(required_resource_keys={"dingtalk_webhook"}, ins={"text": In(str)})
  def op_send_text(context:OpExecutionContext, text:str):
      dingtalk_webhook:DingTalkWebhookResource = context.resources.dingtalk_webhook
      dingtalk_webhook.send_text(text)
  @job
  def job_send_text():
      op_send_text()
  dingtalk_webhooks = {
      "Group1" : DingTalkWebhookResource(access_token="<access_token>", secret="<secret>", alias="Group1"),
      "Group2" : DingTalkWebhookResource(access_token="<access_token>", secret="<secret>", alias="Group2")
  }
  defs = Definitions(
      jobs=[job_send_text],
      resources={"dingtalk_webhook": DingTalkWebhookResource.configure_at_launch()}
  )
  @schedule(cron_schedule="20 9 * * *", job=job_send_text)
  def schedule_user_info():
      return RunRequest(run_config=RunConfig(
          ops={"op_send_text": {"inputs": {"text": "This a test text."}}},
          resources={"dingtalk": dingtalk_webhooks["Group1"]},
      ))
  ```


pkgId: d94998593a56d0711b9e0bbf0e6603af9fc8a940a13a769e57f60a68bcc64217
name: python-dagster-hex
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Dagster library for Hex
url: https://github.com/hex-inc/dagster-hex
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-hex-0.1.3-1.src.rpm
checksum_type: sha256
description:
  To install the library, use pip alongside your existing Dagster environment.

  ```bash
  pip install dagster-hex
  ```



  First, you'll need to specify your Hex API Token key as a resource.

  ```python

  from dagster_hex.resources import hex_resource
  import os

  API_KEY = os.getenv['DAGSTER_PROD_API']
  my_resource = hex_resource.configured({'api_key': API_KEY})
  ```



  The `hex_project_op` will call the Hex API to run a project until it completes.

  ```python
  from dagster_hex.resources import hex_resource
  from dagster import job
  from dagster_hex.ops import hex_project_op

  API_KEY = 'abc123'
  PROJ_ID = 'i-love-uuids'

  my_resource = hex_resource.configured({'api_key': API_KEY})
  run_hex_op = hex_project_op.configured({"project_id": PROJ_ID},
                                         name='run_job')

  @job(resource_defs={"hex": my_resource})
  def hex_job():
      run_hex_op()
  ```



  Ops will return an `AssetMaterialization`  with the following keys:

  ```
  run_url
  run_status_url
  trace_id
  run_id
  elapsed_time
  ```


pkgId: 74ac492ea8aa91433d4ad99b62cbc028bacc3a1371b4aa95305de2bf48ef260c
name: python-dagster-hightouch
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Dagster library for Hightouch
url: https://github.com/hightouchio/dagster-hightouch
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-hightouch-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Publish](https://github.com/hightouchio/dagster-hightouch/actions/workflows/pypi-publish.yml/badge.svg?branch=main)](https://github.com/hightouchio/dagster-hightouch/actions/workflows/pypi-publish.yml)



  A Dagster library for triggering syncs in Hightouch.



  To install the library, use pip alongside your existing Dagster environment.

  ```bash
  pip install dagster_hightouch
  ```



  First, you'll need to specify your [Hightouch API](https://hightouch.com/docs/developer-tools/api-guide/) key as a resource.

  ```python

  from dagster_hightouch.resources import ht_resource as hightouch_resource

  ht_resource = hightouch_resource.configured(
      {"api_key": "555555-4444-3333-2222-1111111111"},
  )
  ```



  The `hightouch_sync_op` will call the Hightouch API to trigger
  a sync and monitor it until it completes.

  ```python
  from dagster import ScheduleDefinition, get_dagster_logger, job
  from dagster_hightouch.ops import hightouch_sync_op
  from .resources import ht_resource





  HT_WS = "23620"
  HT_ORG = "39619"


  run_ht_sync_workspaces = hightouch_sync_op.configured(
      {"sync_id": HT_WS}, name="hightouch_sfdc_workspaces"
  )
  run_ht_sync_orgs = hightouch_sync_op.configured(
      {"sync_id": HT_ORG}, name="hightouch_sfdc_organizations"
  )


  @job(
      resource_defs={
          "hightouch": ht_resource,
      }
  )
  def ht_sfdc_job():

      ht_orgs = run_ht_sync_orgs(start_after=ht_contacts)
      run_ht_sync_workspaces(start_after=ht_orgs)


  every_30_schedule = ScheduleDefinition(job=ht_sfdc_job, cron_schedule="*/30 * * * *")
  ```


pkgId: 2e3bcbf80bda90c30af64b221e2fe389101473f351a992ea08ef4bdba2201712
name: python-dagster-insights
arch: src
version: 0.0.20
epoch: 0
release: 1
summary: Latest pre-release patches for dagster_cloud.dagster_insights.
url: https://pypi.org/project/dagster-insights/
rpm_license: Released under the same license as dagster-cloud: https://pypi.org/project/dagster-cloud/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-insights-0.0.20-1.src.rpm
checksum_type: sha256
description:
  This package contains pre-release fixes and optimizations for the official `dagster_cloud.dagster_insights` module included in the [dagster-cloud](https://pypi.org/project/dagster-cloud/) package. To use the official version, run `pip install dagster-cloud` and import it as follows:

  ```
  from dagster_cloud import dagster_insights
  ```

  To enable the pre-release patches from this package, run `pip install dagster-insights` and import this module before importing `dagster_cloud.dagster_insights`:

  ```
  import dagster_insights_prerelease  # Patches dagster_cloud.dagster_insights
  from dagster_cloud import dagster_insights
  ```

  This allows testing against a pre-release version of `dagster_insights` and provides a faster turnaround time for fixes and optimizations. All reliable fixes are eventually merged into `dagster_cloud.dagster_insights` and available in the official release.


pkgId: 9c5f34fe6066e42916e0c707324957c27c44b1ca0c3ffc2ac2f073d4a7fbcee7
name: python-dagster-meltano
arch: src
version: 1.5.5
epoch: 0
release: 1
summary: A dagster plugin that allows you to run your Meltano project inside Dagster.
url: https://pypi.org/project/dagster-meltano/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-meltano-1.5.5-1.src.rpm
checksum_type: sha256
description:
  A dagster plugin that allows you to run Meltano using Dagster.

  [![Downloads](https://pepy.tech/badge/dagster-meltano/month)](https://pepy.tech/project/dagster-meltano)



  You can install using `pip install dagster-meltano`.



  An example of automatically loading all jobs and schedules from your Meltano project.

  ```python
  from dagster import repository
  from dagster_meltano import load_jobs_from_meltano_project

  meltano_jobs = load_jobs_from_meltano_project("<path-to-meltano-root>")

  @repository
  def repository():
      return [meltano_jobs]
  ```

  An example of running an abitrary `meltano run` command.

  ```python
  from dagster import repository, job
  from dagster_meltano import meltano_resource, meltano_run_op

  @job(resource_defs={"meltano": meltano_resource})
  def meltano_run_job():
      tap_done = meltano_run_op("tap-1 target-1")()
      meltano_run_op("tap-2 target-2")(tap_done)

  @repository()
  def repository():
      return [meltano_run_job]
  ```

  You can inject Meltano config with the following Dagster config.

  ```yaml
  ops:
    tap_smoke_test_target_jsonl:
      config:
        env:
          TAP_SMOKE_TEST_STREAMS: '[{"stream_name": "new-stream", "input_filename": "demo.json"}]'
  ```

  An example of running an arbitrary Meltano command.

  ```python
  from dagster import repository, job
  from dagster_meltano import meltano_resource, meltano_command_op

  @job(resource_defs={"meltano": meltano_resource})
  def meltano_command_job():
      meltano_command_op("install loader tap-smoke-test")()

  @repository()
  def repository():
      return [meltano_command_job]
  ```



  1. Open this repository in Visual Studio Code.
  2. Install the [Remote - Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) plugin for Visual Studio Code.
  3. Go to the example Meltano project root `cd meltano_project`
  4. Install all plugins `meltano install`
  5. Start dagit `meltano invoke dagster:start`
  6. Visit `localhost:3000` to access Dagit.


pkgId: 9f9a2122a7d45aa363e96f44137aa5ee9d762147527c081cc14fabe63fbc3531
name: python-dagster-odp
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A configuration-driven framework for building Dagster pipelines
url: https://pypi.org/project/dagster-odp/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-odp-0.1.2-1.src.rpm
checksum_type: sha256
description:
  dagster-odp simplifies data pipeline development by enabling teams to build Dagster pipelines through configuration rather than code. It reduces the learning curve for Dagster while promoting standardization and faster development of data workflows.



  - **Configuration-Driven Development**: Build data pipelines using YAML/JSON instead of Python code

  - **Pre-built Tasks**:
    - **Google Cloud Operations**: Transfer and export data between GCS and BigQuery, with support for GCS file downloads.
    - **DuckDB Operations**: Load files into DuckDB, execute SQL queries, and export table contents to files.
    - **Utility Operations**: Execute shell commands with configurable environments and working directories.

  - **Extensible Framework**: Create custom tasks, sensors, and resources that can be used directly in configuration files

  - **Enhanced Modern Data Stack Integration**:
    - **DLT+**: Extended integration with automatic asset creation and granular object handling
    - **DBT+**: Simplified variable management and external source configuration
    - **Soda**: Configuration-driven data quality checks

  - **Enhanced Asset Management**:
    - Standardized materialization metadata
    - Simplified dependency management
    - External source handling

  - **Flexible Automation**: Configuration-based jobs, schedules, sensors, and partitioning




  Here's a simple pipeline that downloads data and loads it into DuckDB:

  ```yaml

  assets:
    - asset_key: raw_data
      task_type: url_file_download
      params:
        source_url: https://example.com/data.parquet
        destination_file_path: ./data/raw.parquet

    - asset_key: analyzed_data
      task_type: file_to_duckdb
      depends_on: [raw_data]
      params:
        source_file_uri: "{{raw_data.destination_file_path}}"
        destination_table_id: analyzed_table
  ```



  ```bash
  pip install dagster-odp
  ```



  1. Create a new project using the Dagster CLI:
  ```bash
  dagster project scaffold --name my-odp-project
  cd my-odp-project
  ```

  2. Create the ODP configuration directories:
  ```bash
  mkdir -p odp_config/workflows
  ```

  3. Update your definitions.py:
  ```python
  from dagster_odp import build_definitions
  defs = build_definitions("odp_config")
  ```

  4. Start building pipelines in your workflows directory using YAML/JSON configuration.

  Check out our [Quickstart Guide](https://runodp.github.io/dagster-odp/getting-started/quickstart/) for a complete walkthrough.



  - **Data Teams** seeking to standardize pipeline creation
  - **Data Analysts/Scientists** who want to create pipelines without extensive coding
  - **Data Engineers** looking to reduce boilerplate code and maintenance overhead
  - **Organizations** adopting Dagster who want to accelerate development



  [Comprehensive documentation](https://runodp.github.io/dagster-odp/) is available, including:

  - [Tutorials](https://runodp.github.io/dagster-odp/tutorials/tutorials/)
  - [Concepts Guide](https://runodp.github.io/dagster-odp/concepts/concepts/)
  - [Integration Guides](https://runodp.github.io/dagster-odp/integrations/integrations/)
  - [Reference Documentation](https://runodp.github.io/dagster-odp/reference/reference/)



  Contributions are welcome! Please read our [Contributing Guidelines](CONTRIBUTING.md) for details on how to submit pull requests, report issues, and contribute to the project.



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

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


pkgId: 382e6249944834ba6ee4b4d92919959b9a2ca8e8944ee36921968d1ea6e5e3cb
name: python-dagster-pandas
arch: src
version: 0.24.10
epoch: 0
release: 1
url: https://github.com/dagster-io/dagster
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-pandas-0.24.10-1.src.rpm
checksum_type: sha256
summary:
  Utilities and examples for working with pandas and dagster, an opinionated framework for expressing data pipelines

description:
  The docs for `dagster-pandas` can be found
  [here](https://docs.dagster.io/_apidocs/libraries/dagster-pandas).


pkgId: a270c2902b88536df117240be5399fcc8cdbc3e8cc282957d99018dd3cd3db40
name: python-dagster-ray
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Dagster integration library for Ray
url: https://pypi.org/project/dagster-ray/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-ray-0.0.10-1.src.rpm
checksum_type: sha256
description:
  [Ray](https://github.com/ray-project/ray) integration for [Dagster](https://github.com/dagster-io/dagster).
  `dagster-ray` allows orchestrating distributed Ray compute from Dagster pipelines. It includes:
  - `RayRunLauncher` - a `RunLauncher` which submits Dagster runs as isolated Ray jobs (in cluster mode) to a Ray cluster.
  - `ray_executor` - an `Executor` which submits individual Dagster steps as isolated Ray jobs (in cluster mode) to a Ray cluster.
  - `RayIOManager` - an `IOManager` which stores intermediate values in Ray's object store. Ideal in conjunction with `RayRunLauncher` and `ray_executor`.
  - `PipesRayjobClient`, a [Dagster Pipes](https://docs.dagster.io/concepts/dagster-pipes) client for launching and monitoring Ray jobs on remote clusters. Typically used with external Pythons scripts. Allows receiving rich logs, events and metadata from the job. Doesn't handle cluster management, can be used with any Ray cluster.
  - `PipesKubeRayJobClient`, a [Dagster Pipes](https://docs.dagster.io/concepts/dagster-pipes) client for launching and monitoring [KubeRay](https://github.com/ray-project/kuberay)'s `RayJob` CR on Kubernetes. Typically used with external Pythons scripts. Allows receiving rich logs, events and metadata from the job.
  - `RayResource`, a resource representing a Ray cluster. Interactions with Ray are performed in **client mode** (requires stable persistent connection), so it's most suitable for relatively short-lived jobs. It has implementations for `KubeRay` and local (mostly for testing) backends. `dagster_ray.RayResource` defines the common interface shared by all backends and can be used for backend-agnostic type annotations.
  - Miscellaneous utilities like `@op`, `@job` and `@schedule` for managing `KubeRay` clusters
  `dagster-ray` is tested across multiple versions of Python, Ray, Dagster, and KubeRay Operator. It integrates with [Dagster+](https://dagster.io/plus) where possible.
  Documentation can be found below.
  > [!NOTE]
  > This project is in early development. APIs are unstable and can change at any time. Contributions are very welcome! See the [Development](#development) section below.

  There are different options available for running Dagster code on Ray. The following table summarizes the features of each option:
  | Feature | `RayRunLauncher` | `ray_executor` | `PipesRayJobClient` | `PipesKubeRayJobClient` | `KubeRayCluster` |
  | --- | --- | --- | --- | --- | --- |
  | Creates Ray cluster | ❌ | ❌ | ❌ | ✅ | ✅ |
  | Submits jobs in cluster mode | ✅ | ✅ | ✅ | ✅ | ❌ |
  | For long-running jobs | ✅ | ✅ | ✅ | ✅ | ❌ |
  | Enabled per-asset  | ❌ | ❌ | ✅ | ✅ | ✅ |
  | Configurable per-asset | ❌ | ✅ | ✅ | ✅ | ✅ |
  | Doesn't need an external script | ✅ | ✅ | ❌ | ❌ | ✅ |
  | Ray cluster doesn't need access to Dagster's metadata DB and logs storage | ❌ | ❌ | ✅ | ✅ | ✅ |

  See the [examples](examples) directory.

  ```shell
  pip install dagster-ray
  ```
  To install with extra dependencies for a particular backend (like `kuberay`), run:
  ```shell
  pip install 'dagster-ray[kuberay]'
  ```


  > [!WARNING]
  > The `RayRunLauncher` is a work in progress
  ```shell
  pip install dagster-ray[run_launcher]
  ```
  The `RayRunLauncher` can be configured via `dagster.yaml`:
  ```yaml
  run_launcher:
    module: dagster_ray
    class: RayRunLauncher
    config:
      ray:
        num_cpus: 1
        num_gpus: 0
  ```
  Individual Runs can **override** Ray configuration:
  ```python
  from dagster import job
  @job(
      tags={
          "dagster-ray/config": {
              "num_cpus": 16,
              "num_gpus": 1,
          }
      }
  )
  def my_job():
      return my_op()
  ```

  > [!WARNING]
  > The `ray_executor` is a work in progress
  ```shell
  pip install dagster-ray[executor]
  ```
  The `ray_executor` can be used to execute Dagster steps on an existing remote Ray cluster.
  The executor submits steps as Ray jobs. They are started directly in the Ray cluster. Example:
  ```python
  from dagster import job, op
  from dagster_ray import ray_executor
  @op(
      tags={
          "dagster-ray/config": {
              "num_cpus": 8,
              "num_gpus": 2,
              "runtime_env": {"pip": {"packages": ["torch"]}},
          }
      }
  )
  def my_op():
      import torch
      
      result = ...
      return result
  @job(executor_def=ray_executor.configured({"ray": {"num_cpus": 1}}))
  def my_job():
      return my_op()
  ```
  Fields in the `dagster-ray/config` tag **override** corresponding fields in the Executor config.

  `RayIOManager` allows storing and retrieving intermediate values in Ray's object store. Most useful in conjunction with `RayRunLauncher` and `ray_executor`.
  It works by storing Dagster step keys in a global Ray actor. This actor contains a mapping between step keys and Ray `ObjectRef`s. It can be used with any pickable Python objects.
  ```python
  from dagster import asset, Definitions
  from dagster_ray import RayIOManager
  @asset(io_manager_key="ray_io_manager")
  def upstream() -> int:
      return 42
  @asset
  def downstream(upstream: int):
      return 0
  definitions = Definitions(
      assets=[upstream, downstream], resources={"ray_io_manager": RayIOManager()}
  )
  ```
  It supports partitioned assets.
  ```python
  from dagster import (
      asset,
      Definitions,
      StaticPartitionsDefinition,
      AssetExecutionContext,
  )
  from dagster_ray import RayIOManager
  partitions_def = StaticPartitionsDefinition(["a", "b", "c"])
  @asset(io_manager_key="ray_io_manager", partitions_def=partitions_def)
  def upstream(context: AssetExecutionContext):
      return context.partition_key
  @asset(partitions_def=partitions_def)
  def downstream(context: AssetExecutionContext, upstream: str) -> None:
      assert context.partition_key == upstream
  ```
  It supports partition mappings. When loading **multiple** upstream partitions, they should be annotated with a `Dict[str, ...]`, `dict[str, ...]`, or `Mapping[str, ...]` type hint.
  ```python
  from dagster import (
      asset,
      Definitions,
      StaticPartitionsDefinition,
      AssetExecutionContext,
  )
  from dagster_ray import RayIOManager
  partitions_def = StaticPartitionsDefinition(["A", "B", "C"])
  @asset(io_manager_key="ray_io_manager", partitions_def=partitions_def)
  def upstream(context: AssetExecutionContext):
      return context.partition_key.lower()
  @asset
  def downstream_unpartitioned(upstream: Dict[str, str]) -> None:
      assert upstream == {"A": "a", "B": "b", "C": "c"}
  ```


  A general-purpose Ray job client that can be used to submit Ray jobs and receive logs and Dagster events from them. It doesn't manage the cluser lifecycle and can be used with any Ray cluster.
  Examples:
  In Dagster code, import `PipesRayJobClient` and invoke it inside an `@op` or an `@asset`:
  ```python
  from dagster import AssetExecutionContext, Definitions, asset
  from dagster_ray import PipesRayJobClient
  from ray.job_submission import JobSubmissionClient
  @asset
  def my_asset(context: AssetExecutionContext, pipes_ray_job_client: PipesRayJobClient):
      pipes_ray_job_client.run(
          context=context,
          submit_job_params={
              "entrypoint": "python /app/my_script.py",
          },
          extra={"param": "value"},
      )
  definitions = Definitions(
      resources={"pipes_ray_job_client": PipesRayJobClient(client=JobSubmissionClient())},
      assets=[my_asset],
  )
  ```
  In the Ray job, import `dagster_pipes` (must be provided as a dependency) and emit regular Dagster events such as logs or asset materializations:
  ```python
  from dagster_pipes import open_dagster_pipes
  with open_dagster_pipes() as context:
      assert context.get_extra("param") == "value"
      context.log.info("Hello from Ray Pipes!")
      context.report_asset_materialization(
          metadata={"some_metric": {"raw_value": 57, "type": "int"}},
          data_version="alpha",
      )
  ```
  A convenient way to provide `dagster-pipes` to the Ray job is [runtime_env](https://docs.ray.io/en/latest/ray-core/handling-dependencies.html):
  ```python
  submit_job_params = {
      "entrypoint": "python /app/my_script.py",
      "runtime_env": {"pip": ["dagster-pipes"]},
  }
  ```
  Events emitted by the Ray job will be captured by `PipesRayJobClient` and will become available in the Dagster event log. Standard output and standard error streams will be forwarded to the standard output of the Dagster process.


  A dummy resource which is useful for testing and development.
  It doesn't do anything, but provides the same interface as the other `*Ray` resources.
  Examples:
  Using the `LocalRay` resource
  ```python
  from dagster import asset, Definitions
  from dagster_ray import LocalRay, RayResource
  import ray
  @asset
  def my_asset(
      ray_cluster: RayResource,  # RayResource is only used as a type annotation
  ):  # this type annotation only defines the interface
      return ray.get(ray.put(42))
  definitions = Definitions(resources={"ray_cluster": LocalRay()}, assets=[my_asset])
  ```
  Conditionally using the `LocalRay` resource in development and `KubeRayCluster` in production:
  ```python
  from dagster import asset, Definitions
  from dagster_ray import LocalRay, RayResource
  from dagster_ray.kuberay import KubeRayCluster
  import ray
  @asset
  def my_asset(
      ray_cluster: RayResource,  # RayResource is only used as a type annotation
  ):  # this type annotation only defines the interface
      return ray.get(ray.put(42))
  IN_K8s = ...
  definitions = Definitions(
      resources={"ray_cluster": KubeRayCluster() if IN_K8s else LocalRay()},
      assets=[my_asset],
  )
  ```

  ```shell
  pip install dagster-ray[kuberay]
  ```
  This backend requires a Kubernetes cluster with `KubeRay Operator` installed.
  Integrates with [Dagster+](https://dagster.io/plus) by injecting environment variables such as `DAGSTER_CLOUD_DEPLOYMENT_NAME` and tags such as `dagster/user` into default configuration values and Kubernetes labels.
  To run `ray` code in client mode (from the Dagster Python process directly), use the `KubeRayClient` resource (see the [KubeRayCluster](#KubeRayCluster) section).
  To run `ray` code in job mode, use the `PipesKubeRayJobClient` with Dagster Pipes (see the [Pipes](#pipes) section).
  The public objects can be imported from `dagster_ray.kuberay` module.


  `dagster-ray` provides the `PipesKubeRayJobClient` which can be used to execute remote Ray jobs on Kubernetes and receive Dagster events and logs from them.
  [RayJob](https://docs.ray.io/en/latest/cluster/kubernetes/getting-started/rayjob-quick-start.html) will manage the lifecycle of the underlying `RayCluster`, which will be cleaned up after the specified entrypoint exits. Doesn't require a persistent connection to the Ray cluster.
  Examples:
  In Dagster code, import `PipesKubeRayJobClient` and invoke it inside an `@op` or an `@asset`:
  ```python
  from dagster import AssetExecutionContext, Definitions, asset
  from dagster_ray.kuberay import PipesKubeRayJobClient
  @asset
  def my_asset(
      context: AssetExecutionContext, pipes_kube_rayjob_client: PipesKubeRayJobClient
  ):
      pipes_kube_rayjob_client.run(
          context=context,
          ray_job={
              
              
              "metadata": {
                  
                  "namespace": "ray"
              },
              "spec": {
                  "entrypoint": "python /app/my_script.py",
                  
                  "rayClusterSpec": {
                      "headGroupSpec": {...},
                      "workerGroupSpecs": [...],
                  },
              },
          },
          extra={"param": "value"},
      )
  definitions = Definitions(
      resources={"pipes_kube_rayjob_client": PipesKubeRayJobClient()}, assets=[my_asset]
  )
  ```
  In the Ray job, import `dagster_pipes` (must be provided as a dependency) and emit regular Dagster events such as logs or asset materializations:
  ```python
  from dagster_pipes import open_dagster_pipes
  with open_dagster_pipes() as context:
      assert context.get_extra("param") == "value"
      context.log.info("Hello from Ray Pipes!")
      context.report_asset_materialization(
          metadata={"some_metric": {"raw_value": 57, "type": "int"}},
          data_version="alpha",
      )
  ```
  A convenient way to provide `dagster-pipes` to the Ray job is with `runtimeEnvYaml` field:
  ```python
  import yaml
  ray_job = {"spec": {"runtimeEnvYaml": yaml.safe_dump({"pip": ["dagster-pipes"]})}}
  ```
  Events emitted by the Ray job will be captured by `PipesKubeRayJobClient` and will become available in the Dagster event log. Standard output and standard error streams will be forwarded to the standard output of the Dagster process.
  **Running locally**
  When running locally, the `port_forward` option has to be set to `True` in the `PipesKubeRayJobClient` resource in order to interact with the Ray job. For convenience, it can be set automatically with:
  ```python
  from dagster_ray.kuberay.configs import in_k8s
  pipes_kube_rayjob_client = PipesKubeRayJobClient(..., port_forward=not in_k8s)
  ```


  `KubeRayCluster` can be used for running Ray computations on Kubernetes in client (interactive) mode. Requires stable persistent connection through the duration of the Dagster step.
  When added as resource dependency to an `@op/@asset`, the `KubeRayCluster`:
   - Starts a dedicated `RayCluster` for it
   - Connects  to the cluster in client mode with `ray.init()` (unless `skip_init` is set to `True`)
   - Tears down the cluster after the step is executed (unless `skip_cleanup` is set to `True`)
  `RayCluster` comes with minimal default configuration, matching `KubeRay` defaults.
  Examples:
  Basic usage (will create a single-node, non-scaling `RayCluster`):
  ```python
  from dagster import asset, Definitions
  from dagster_ray import RayResource
  from dagster_ray.kuberay import KubeRayCluster
  import ray
  @asset
  def my_asset(
      ray_cluster: RayResource,  # RayResource is a backend-agnostic type annotation
  ):
      return ray.get(ray.put(42))  # interact with the Ray cluster!
  definitions = Definitions(
      resources={"ray_cluster": KubeRayCluster()}, assets=[my_asset]
  )
  ```
  Larger cluster with auto-scaling enabled:
  ```python
  from dagster_ray.kuberay import KubeRayCluster, RayClusterConfig
  ray_cluster = KubeRayCluster(
      ray_cluster=RayClusterConfig(
          enable_in_tree_autoscaling=True,
          worker_group_specs=[
              {
                  "groupName": "workers",
                  "replicas": 2,
                  "minReplicas": 1,
                  "maxReplicas": 10,
                  
              }
          ],
      )
  )
  ```

  This resource can be used to interact with the Kubernetes API Server.
  Examples:
  Listing currently running `RayClusters`:
  ```python
  from dagster import op, Definitions
  from dagster_ray.kuberay import KubeRayClient
  @op
  def list_ray_clusters(
      kube_ray_client: KubeRayClient,
  ):
      return kube_ray_client.client.list(namespace="kuberay")
  ```


  This `job` can be used to delete `RayClusters` from a given list of names.

  This `job` can be used to delete old `RayClusters` which no longer correspond to any active Dagster Runs.
  They may be left behind if the automatic cluster cleanup was disabled or failed.

  Cleanup schedules can be trivially created using the `cleanup_old_ray_clusters` or `delete_kuberay_clusters` jobs.

  `dagster-ray` provides an example daily cleanup schedule.

  ```shell
  uv sync --all-extras
  uv run pre-commit install
  ```

  ```shell
  uv run pytest
  ```

  Required tools:
  - `docker`
  - `kubectl`
  - `helm`
  - `minikube`
  Running `pytest` will **automatically**:
   - build an image with the local `dagster-ray` code
   - start a `minikube` Kubernetes cluster
   - load the built `dagster-ray` and loaded `kuberay-operator` images into the cluster
   - install `KubeRay Operator` into the cluster with `helm`
   - run the tests
  Thus, no manual setup is required, just the presence of the tools listed above. This makes testing a breeze!
  > [!NOTE]
  > Specifying a comma-separated list of `KubeRay Operator` versions in the `PYTEST_KUBERAY_VERSIONS` environment variable will spawn a new test for each version.
  > [!NOTE]
  > it may take a while to download `minikube` and `kuberay-operator` images and build the local `dagster-ray` image during the first tests invocation


pkgId: 02b85f5d149f99c8624e8f839e2c662495affce58df597aa56f34e7dd02ee92a
name: python-dagster-snowflake-pyspark
arch: src
version: 0.24.12
epoch: 0
release: 1
summary: Package for integrating Snowflake and PySpark with Dagster.
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-snowflake-pyspark-0.24.12-1.src.rpm
checksum_type: sha256
url:
  https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-snowflake-pyspark


pkgId: abb8965e65881513b80009a0b468c1e2d4def0cd3bd1fa62240396b2618d8f5b
name: python-dagster-sqlmesh
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/dagster-sqlmesh/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagster-sqlmesh-0.2.0-1.src.rpm
checksum_type: sha256
description:
  _WARNING: THIS IS A WORK IN PROGRESS_

  SQLMesh library for dagster integration.



  * A `@sqlmesh_assets` decorator akin to `dagster-dbt`'s `@dbt_assets` decorator.
  * A `SQLMeshResource` that allows you to call sqlmesh from inside an asset
    (likely one defined by the `@sqlmesh_assets` decorator)
  * A `SQLMeshDagsterTranslator` that allows customizing the translation of
    sqlmesh models into dagster assets.



  This dagster sqlmesh adapter is intended to work in a similar pattern to that of
  `dagster-dbt` in the most basic case by using the `@sqlmesh_assets`

  Assuming that your sqlmesh project is located in a directory `/home/foo/sqlmesh_project`, this is how you'd setup your dagster assets:

  ```python
  from dagster import (
      AssetExecutionContext,
      Definitions,
  )
  from dagster_sqlmesh import sqlmesh_assets, SQLMeshContextConfig, SQLMeshResource

  sqlmesh_config = SQLMeshContextConfig(path="/home/foo/sqlmesh_project", gateway="name-of-your-gateway")

  @sqlmesh_assets(config=sqlmesh_config)
  def sqlmesh_project(context: AssetExecutionContext, sqlmesh: SQLMeshResource):
      yield from sqlmesh.run(context)

  defs = Definitions(
      assets=[sqlmesh_project],
      resources={
          "sqlmesh": SQLMeshResource(config=sqlmesh_config),
      },
  )
  ```




  _We are very open to contributions!_

  In order to build the project you'll need the following:

  * python 3.11 or 3.12
  * node 18+
  * pnpm 8+

  _Note: this is a python project but some of our dependent tools are in typescript. As such all this is needed_



  To install everything you need for development just do the following:

  ```bash
  poetry install
  pnpm install
  ```



  We have tests that should work entirely locally. You may see a `db.db` file appear in the root of the repository when these tests are run. It can be safely ignored or deleted.

  We run tests with `pytest` like so:

  ```bash
  poetry run pytest
  ```



  In the `sample/dagster_project` directory, is a minimal dagster project with the
  accompanying sqlmesh project from `sample/sqlmesh_project` configured as an
  asset. To run the sample dagster project deployment with a UI:

  ```bash
  poetry run dagster dev -h 0.0.0.0 -f sample/dagster_project/definitions.py
  ```

  If you'd like to materialize the dagster assets quickly on the CLI:

  ```bash
  dagster asset materialize -f sample/dagster_project/definitions.py --select '*'
  ```

  _Note: The sqlmesh project that is in the sample folder has a dependency on a
  table that doesn't exist by default within the defined duckdb database. You'll
  notice there's a `test_source` asset in the dagster project. This asset will
  automatically populate that table in duckdb so that the sqlmesh project can be
  run properly. Before you run any materializations against the sqlmesh related
  assets in dagster, ensure that you've run the `test_source` at least once._



  * Create a new "loader" for sqlmesh and dagster definitions to allow for
    automatic creation of administrative jobs for sqlmesh (e.g. migrations).
    Additionally, we may want to have this generate assets outside of the
    `multi_asset` paradigm within dagster such that assets can have independent
    partitions. There is an existing issue for this in [dagster
    itself](https://github.com/dagster-io/dagster/issues/14228).


pkgId: 35c5a709f8e58ee13d14b945b38afcea4781b0196ee9de9387ac035b272bdef3
name: python-dagviz
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Visualization for DAGs
url: https://github.com/WimYedema/dagviz.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagviz-0.4.0-1.src.rpm
checksum_type: sha256
description:
  DAGVIZ offers a "git log"-like visualization for DAGs represented in networkx.



  DAGVIZ can be installed with `pip`:

  ```bash
  pip install dagviz
  ```



  Documentation is available at https://wimyedema.github.io/dagviz/.


  DAGVIZ relies on networkx for the representation and manipulation of the
  DAG. An SVG file can be generated as follows:

  ```py
      import dagviz
      import networkx as nx
      
      G = nx.DiGraph()
      for i in range(5):
          G.add_node(f"n{i}")
      G.add_edge(f"n0", f"n1")
      G.add_edge(f"n0", f"n2")
      G.add_edge(f"n0", f"n4")
      G.add_edge(f"n1", f"n3")
      G.add_edge(f"n2", f"n3")
      G.add_edge(f"n3", f"n4")
      
      r = dagviz.render_svg(G)
      with open("simple.svg", "wt") as fs:
          fs.write(r)
  ```


pkgId: 9830ff0d89bfc4b714700fd310b67febf1d5269db6a9ab05badc0c1a267fe8c6
name: python-dagworks-sdk
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: DAGWorks SDK.
url: https://www.dagworks.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dagworks-sdk-0.6.1-1.src.rpm
checksum_type: sha256
description:
  Welcome to using the DAGWorks Platform!

  Here are instructions on how to get started with tracking, and managing your Hamilton
  DAGs with the DAGWorks Platform.



  For the latest documentation, please consult our
  [DAGWorks Platform documentation](https://docs.dagworks.io/).

  For a quick overview of Hamilton, we suggest [tryhamilton.dev](https://www.tryhamilton.dev/).



  First, you'll need to install the DAGWorks SDK package. Assuming you're using pip, you
  can do this with:

  ```bash

  pip install dagworks-sdk


  python -c "from dagworks import driver"
  ```

  Next, you'll need to modify your Hamilton driver. You'll only need to use one line of code to
  replace your driver with ours:

  ```python
  from dagworks import driver

  ...
  dr = driver.Driver(
      your_config,  # standard hamilton config
      *your_modules,  # standard hamilton modules
      adapter=your_adapter, # Optional. Standard hamilton adapter.
      
      project_id=1, # The ID of your project. Create one in the UI first if you don't have one.
      api_key="safely_load_your_api_key", # e.g. os.environ["DAGWORKS_API_KEY"]
      username="your_email_address",
      dag_name="name_of_your_dag",
      tags={"tag1": "value1", "tag2": "value2"}, # Optional
  )
  ```
  *Project ID*: You'll need a project ID. Grab one from https://app.dagworks.io/dashboard/projects.
  Create a project if you don't have one, and take the ID from that.

  *API Key*: You'll need an API key. Create one here https://app.dagworks.io/dashboard/settings.

  *username*: This is the email address you used to sign up for the DAGWorks Platform.

  *dag_name*: for a project, the DAG name is the top level way to group DAGs.
  E.g. ltv_model, us_sales, etc.

  *tags*: these are optional are string key value paris. They allow you to filter and curate
  various DAG runs.

  Then run Hamilton as normal! Each DAG run will be tracked, and you'll have access to it in the
  DAGWorks Platform. Visit https://app.dagworks.io/dashboard/projects to see your projects & DAGs.


  There are several starter projects that you can use to get started with the DAGWorks Platform.

  Starter Projects:

  * hello_world: a simple hello world DAG.
  * data_processing: a simple data processing DAG, pulling from CSVs and normalizing the data.
  * machine_learning: a simple machine learning DAG using the iris dataset.
  * time_series_feature_engineering: a simple time series feature engineering DAG.

  To use the starter project, run the dagworks CLI:

  ```bash
  dagworks init \
        --api-key API_KEY_HERE \
        --username EMAIL_HERE \
        --project-id PROJECT_ID_FROM_DAGWORKS_PLATFORM \
        --template STARTER_PROJECT_NAME \
        --location LOCATION
  ```
  Where:

  * *API_KEY_HERE*: is your DAGWorks Platform API Key. Create one here
  https://app.dagworks.io/dashboard/settings.
  * *EMAIL_HERE*: is the email address you signed up for the DAGWorks Platform with.
  * *PROJECT_ID_FROM_DAGWORKS_PLATFORM*: is the project ID you want to use. Create one here
  https://app.dagworks.io/dashboard/projects.
  * *STARTER_PROJECT_NAME*: is the name of the starter project you want to use. Your options
  are hello_world, data_processing, machine_learning, time_series_feature_engineering.
  * *LOCATION*: is the location you want to create the project in. This is a local directory.


  The use of this software is governed by the "The DAGWorks Enterprise license".
  Email support@dagworks.io for more information.


pkgId: 5274a40884a0c3d4a18c129d36cc4e1640fb1bc632b2ae720798a3bd9cfb981a
name: python-dailalib
arch: src
version: 3.10.2
epoch: 0
release: 1
url: https://github.com/mahaloz/DAILA
rpm_license: BSD 2 Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dailalib-3.10.2-1.src.rpm
checksum_type: sha256
summary:
  The Decompiler Artificial Intelligence Language Assistant (DAILA) is a tool for adding AI to decompilers.

description:
  The Decompiler Artificial Intelligence Language Assistant (DAILA) is a unified interface for AI systems to be used in decompilers.
  Using DAILA, you can utilize various AI systems, like local and remote LLMs, all in the same scripting and GUI interfaces across many decompilers.
  DAILA was featured in the keynote talk at [HITCON CMT 2023](https://youtu.be/HbrebQiFLDs?si=TJhKSju85jTLSsiT).

  ![](./assets/ida_daila.png)


  DAILA interacts with the decompiler abstractly through the [LibBS](https://github.com/binsync/libbs) library.
  This allows DAILA to support the following decompilers:
  - IDA Pro: **>= 8.4**
  - Ghidra: **>= 11.1**
  - Binary Ninja: **>= 2.4**
  - angr-management: **>= 9.0**

  DAILA supports any LLM supported in [LiteLLM](https://github.com/BerriAI/litellm), such as:
  - ChatGPT
  - Claude
  - Llama2
  - Gemini
  - and more...

  DAILA also supports local models of different types, like [VarBERT](https://github.com/binsync/varbert_api), a local model for renaming variables in decompilation published in S&P 2024.


  Install our library backend through pip and our decompiler plugin through our installer:
  ```bash
  pip3 install dailalib && daila --install
  ```

  This is the light mode. **If you want to use VarBERT, you must install the full version**:
  ```bash
  pip3 install 'dailalib[full]' && daila --install
  ```

  This will also download the VarBERT models for you through the [VarBERT API](https://github.com/binsync/varbert_api).
  If you happen to be installing DAILA on a machine that won't have internet access, like a secure network, you can use our Docker image in the [Docker Container](#docker-container) section.


  You need to do a few extra steps to get Ghidra working.
  Next, enable the DAILA plugin:
  1. Start Ghidra and open a binary
  2. Goto the `Windows > Script Manager` menu
  3. Search for `daila` and enable the script

  You must have `python3` in your path for the Ghidra version to work. We quite literally call it from inside Python 2.
  You may also need to enable the `$USER_HOME/ghidra_scripts` as a valid scripts path in Ghidra.


  If the above fails, you will need to manually install.
  To manually install, first `pip3 install dailalib` on the repo, then copy the [daila_plugin.py](./dailalib/daila_plugin.py) file to your decompiler's plugin directory.



  DAILA is designed to be used in two ways:
  1. As a decompiler plugin with a GUI
  2. As a scripting library in your decompiler


  With the exception of Ghidra (see below), when you start your decompiler you will have a new context menu
  which you can access when you right-click anywhere in a function:

  <img src="./assets/ida_daila.png" style="width: 50%;" alt="DAILA context menu"/>

  If you are using Ghidra, go to `Tools->DAILA->Start DAILA Backend` to start the backend server.
  After you've done this, you can use the context menu as shown above.


  You can use DAILA in your own scripts by importing the `dailalib` package.
  Here is an example using the OpenAI API:

  ```python
  from dailalib import LiteLLMAIAPI
  from libbs.api import DecompilerInterface

  deci = DecompilerInterface.discover()
  ai_api = LiteLLMAIAPI(decompiler_interface=deci)
  for function in deci.functions:
      summary = ai_api.summarize_function(function)
  ```


  If you are attempting to install DAILA for a one-shot install that will not use the internet after install, like on a secure network, you can use our Docker container.
  You should either build the container yourself, save the image to a tarball, and then load it on the target machine, or you can use our pre-built image.
  You can build the container yourself by running `docker build -t daila .` in the root of this repo.
  You can also download our pre-built image by running `docker pull binsync/daila:latest` (the image is for x86_64 Linux).
  The container contains DAILA and a copy of Ghidra.

  Now you need to foward X11 to the container so that you can see the GUI.
  To do this, you need to run the container with the following flags:
  ```bash
  docker run -it --rm -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix binsync/daila:latest
  ```

  In the container, you can launch ghidra from `/tools/ghidra_10.4_PUBLIC/ghidraRun`.
  Now follow the [Ghidra Extra Steps](#ghidra-extra-steps) to enable the DAILA plugin and you're good to go!



  DAILA supports the LiteLLM API, which in turn supports various backends like OpenAI.
  To use a commercial LLM API, you must provide your own API key.
  As an example, to use the OpenAI API, you must have an OpenAI API key.
  If your decompiler does not have access to the `OPENAI_API_KEY` environment variable, then you must use the decompiler option from
  DAILA to set the API key.

  Currently, DAILA supports the following prompts:
  - Summarize a function
  - Rename variables
  - Rename function
  - Identify the source of a function
  - Find potential vulnerabilities in a function
  - Summarize the man page of a library call
  - Free prompting... just type in your own prompt!


  VarBERT is a local BERT model from the S&P 2024 paper [""Len or index or count, anything but v1": Predicting Variable Names in Decompilation Output with Transfer Learning"]().
  VarBERT is for renaming variables (both stack, register, and arguments) in decompilation.
  To understand how to use VarBERT as a library, please see the [VarBERT API](https://github.com/binsync/varbert_api) documentation.
  Using it in DAILA is a simple as using the GUI context-menu when clicking on a function.


  You can find a demo of VarBERT running inside DAILA below:

  [![VarBERT Demo](https://img.youtube.com/vi/nUazQm8sFL8/0.jpg)](https://youtu.be/nUazQm8sFL8 "DAILA v2.1.4: Renaming variables with local VarBERT model")



  - IDA
  ![](./assets/ida_daila.png)

  - Binja
  ![](./assets/binja_daila.png)

  - Ghidra
  ![](./assets/ghidra_daila.png)

  - angr management
  ![](./assets/am_daila.png)


pkgId: e8c0da29177d388f0b42cf14ecc7efaa44f861d6a1cc668bef40dfdee5cfd78b
name: python-dailalib
arch: src
version: 3.12.0
epoch: 0
release: 1
url: https://github.com/mahaloz/DAILA
rpm_license: BSD 2 Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dailalib-3.12.0-1.src.rpm
checksum_type: sha256
summary:
  The Decompiler Artificial Intelligence Language Assistant (DAILA) is a tool for adding AI to decompilers.

description:
  The Decompiler Artificial Intelligence Language Assistant (DAILA) is a unified interface for AI systems to be used in decompilers.
  Using DAILA, you can utilize various AI systems, like local and remote LLMs, all in the same scripting and GUI interfaces across many decompilers.
  DAILA was featured in the keynote talk at [HITCON CMT 2023](https://youtu.be/HbrebQiFLDs?si=TJhKSju85jTLSsiT).

  ![](./assets/ida_daila.png)

  **Join our discord below for more online help** (hosted on the BinSync server):

  [![Discord](https://img.shields.io/discord/900841083532087347?label=Discord&style=plastic)](https://discord.gg/wZSCeXnEvR)



  DAILA interacts with the decompiler abstractly through the [LibBS](https://github.com/binsync/libbs) library.
  This allows DAILA to support the following decompilers:
  - IDA Pro: **>= 8.4**
  - Ghidra: **>= 11.1**
  - Binary Ninja: **>= 2.4**
  - angr-management: **>= 9.0**

  DAILA supports any LLM supported in [LiteLLM](https://github.com/BerriAI/litellm), such as:
  - ChatGPT
  - Claude
  - Llama2
  - Gemini
  - and more...

  DAILA also supports local models of different types, like [VarBERT](https://github.com/binsync/varbert_api), a local model for renaming variables in decompilation published in S&P 2024.


  Install our library backend through pip and our decompiler plugin through our installer:
  ```bash
  pip3 install dailalib && daila --install
  ```

  This is the light mode. **If you want to use VarBERT, you must install the full version**:
  ```bash
  pip3 install 'dailalib[full]' && daila --install
  ```

  This will also download the VarBERT models for you through the [VarBERT API](https://github.com/binsync/varbert_api).
  If you happen to be installing DAILA on a machine that won't have internet access, like a secure network, you can use our Docker image in the [Docker Container](#docker-container) section.


  You need to do a few extra steps to get Ghidra working.
  Next, enable the DAILA plugin:
  1. Start Ghidra and open a binary
  2. Goto the `Windows > Script Manager` menu
  3. Search for `daila` and enable the script

  You must have `python3` in your path for the Ghidra version to work. We quite literally call it from inside Python 2.
  You may also need to enable the `$USER_HOME/ghidra_scripts` as a valid scripts path in Ghidra.


  If the above fails, you will need to manually install.
  To manually install, first `pip3 install dailalib` on the repo, then copy the [daila_plugin.py](./dailalib/daila_plugin.py) file to your decompiler's plugin directory.



  DAILA is designed to be used in two ways:
  1. As a decompiler plugin with a GUI
  2. As a scripting library in your decompiler


  With the exception of Ghidra (see below), when you start your decompiler you will have a new context menu
  which you can access when you right-click anywhere in a function:

  <img src="./assets/ida_daila.png" style="width: 50%;" alt="DAILA context menu"/>

  If you are using Ghidra, go to `Tools->DAILA->Start DAILA Backend` to start the backend server.
  After you've done this, you can use the context menu as shown above.


  You can use DAILA in your own scripts by importing the `dailalib` package.
  Here is an example using the OpenAI API:

  ```python
  from dailalib import LiteLLMAIAPI
  from libbs.api import DecompilerInterface

  deci = DecompilerInterface.discover()
  ai_api = LiteLLMAIAPI(decompiler_interface=deci)
  for function in deci.functions:
      summary = ai_api.summarize_function(function)
  ```


  If you are attempting to install DAILA for a one-shot install that will not use the internet after install, like on a secure network, you can use our Docker container.
  You should either build the container yourself, save the image to a tarball, and then load it on the target machine, or you can use our pre-built image.
  You can build the container yourself by running `docker build -t daila .` in the root of this repo.
  You can also download our pre-built image by running `docker pull binsync/daila:latest` (the image is for x86_64 Linux).
  The container contains DAILA and a copy of Ghidra.

  Now you need to foward X11 to the container so that you can see the GUI.
  To do this, you need to run the container with the following flags:
  ```bash
  docker run -it --rm -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix binsync/daila:latest
  ```

  In the container, you can launch ghidra from `/tools/ghidra_10.4_PUBLIC/ghidraRun`.
  Now follow the [Ghidra Extra Steps](#ghidra-extra-steps) to enable the DAILA plugin and you're good to go!



  DAILA supports the LiteLLM API, which in turn supports various backends like OpenAI.
  To use a commercial LLM API, you must provide your own API key.
  As an example, to use the OpenAI API, you must have an OpenAI API key.
  If your decompiler does not have access to the `OPENAI_API_KEY` environment variable, then you must use the decompiler option from
  DAILA to set the API key.

  Currently, DAILA supports the following prompts:
  - Summarize a function
  - Rename variables
  - Rename function
  - Identify the source of a function
  - Find potential vulnerabilities in a function
  - Summarize the man page of a library call
  - Free prompting... just type in your own prompt!


  VarBERT is a local BERT model from the S&P 2024 paper [""Len or index or count, anything but v1": Predicting Variable Names in Decompilation Output with Transfer Learning"]().
  VarBERT is for renaming variables (both stack, register, and arguments) in decompilation.
  To understand how to use VarBERT as a library, please see the [VarBERT API](https://github.com/binsync/varbert_api) documentation.
  Using it in DAILA is a simple as using the GUI context-menu when clicking on a function.


  You can find a demo of VarBERT running inside DAILA below:

  [![VarBERT Demo](https://img.youtube.com/vi/nUazQm8sFL8/0.jpg)](https://youtu.be/nUazQm8sFL8 "DAILA v2.1.4: Renaming variables with local VarBERT model")



  - IDA
  ![](./assets/ida_daila.png)

  - Binja
  ![](./assets/binja_daila.png)

  - Ghidra
  ![](./assets/ghidra_daila.png)

  - angr management
  ![](./assets/am_daila.png)


pkgId: 22440419f1b1b145a5687da1b6d4900b5d0f9d58f5ceabfbce872da4923df001
name: python-dailalib
arch: src
version: 3.15.0
epoch: 0
release: 1
url: https://github.com/mahaloz/DAILA
rpm_license: BSD 2 Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dailalib-3.15.0-1.src.rpm
checksum_type: sha256
summary:
[cell repeats an earlier one in this file: 105 characters]

description:
  The Decompiler Artificial Intelligence Language Assistant (DAILA) is a unified interface for AI systems to be used in decompilers.
  Using DAILA, you can utilize various AI systems, like local and remote LLMs, all in the same scripting and GUI interfaces across many decompilers.
  DAILA was featured in the keynote talk at [HITCON CMT 2023](https://youtu.be/HbrebQiFLDs?si=TJhKSju85jTLSsiT).

  ![](./assets/ida_daila.png)

  **Join our discord below for more online help** (hosted on the BinSync server):

  [![Discord](https://img.shields.io/discord/900841083532087347?label=Discord&style=plastic)](https://discord.gg/wZSCeXnEvR)



  DAILA interacts with the decompiler abstractly through the [LibBS](https://github.com/binsync/libbs) library.
  This allows DAILA to support the following decompilers:
  - IDA Pro: **>= 8.4**
  - Ghidra: **>= 11.1**
  - Binary Ninja: **>= 2.4**
  - angr-management: **>= 9.0**

  DAILA supports any LLM supported in [LiteLLM](https://github.com/BerriAI/litellm), such as:
  - ChatGPT
  - Claude
  - Llama2
  - Gemini
  - and more...

  DAILA also supports local models of different types, like [VarBERT](https://github.com/binsync/varbert_api), a local model for renaming variables in decompilation published in S&P 2024.


  Install our library backend through pip and our decompiler plugin through our installer:
  ```bash
  pip3 install dailalib && daila --install
  ```

  This is the light mode. **If you want to use VarBERT, you must install the full version**:
  ```bash
  pip3 install 'dailalib[full]' && daila --install
  ```

  This will also download the VarBERT models for you through the [VarBERT API](https://github.com/binsync/varbert_api).
  If you happen to be installing DAILA on a machine that won't have internet access, like a secure network, you can use our Docker image in the [Docker Container](#docker-container) section.


  You need to do a few extra steps to get Ghidra working.
  Next, enable the DAILA plugin:
  1. Start Ghidra and open a binary
  2. Goto the `Windows > Script Manager` menu
  3. Search for `daila` and enable the script

  You must have `python3` in your path for the Ghidra version to work. We quite literally call it from inside Python 2.
  You may also need to enable the `$USER_HOME/ghidra_scripts` as a valid scripts path in Ghidra.


  If the above fails, you will need to manually install.
  To manually install, first `pip3 install dailalib` on the repo, then copy the [daila_plugin.py](./dailalib/daila_plugin.py) file to your decompiler's plugin directory.



  DAILA is designed to be used in two ways:
  1. As a decompiler plugin with a GUI
  2. As a scripting library in your decompiler


  With the exception of Ghidra (see below), when you start your decompiler you will have a new context menu
  which you can access when you right-click anywhere in a function:

  <img src="./assets/ida_daila.png" style="width: 50%;" alt="DAILA context menu"/>

  If you are using Ghidra, go to `Tools->DAILA->Start DAILA Backend` to start the backend server.
  After you've done this, you can use the context menu as shown above.


  You can use DAILA in your own scripts by importing the `dailalib` package.
  Here is an example using the OpenAI API:

  ```python
  from dailalib import LiteLLMAIAPI
  from libbs.api import DecompilerInterface

  deci = DecompilerInterface.discover()
  ai_api = LiteLLMAIAPI(decompiler_interface=deci)
  for function in deci.functions:
      summary = ai_api.summarize_function(function)
  ```


  If you are attempting to install DAILA for a one-shot install that will not use the internet after install, like on a secure network, you can use our Docker container.
  You should either build the container yourself, save the image to a tarball, and then load it on the target machine, or you can use our pre-built image.
  You can build the container yourself by running `docker build -t daila .` in the root of this repo.
  You can also download our pre-built image by running `docker pull binsync/daila:latest` (the image is for x86_64 Linux).
  The container contains DAILA and a copy of Ghidra.

  Now you need to foward X11 to the container so that you can see the GUI.
  To do this, you need to run the container with the following flags:
  ```bash
  docker run -it --rm -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix binsync/daila:latest
  ```

  In the container, you can launch ghidra from `/tools/ghidra_10.4_PUBLIC/ghidraRun`.
  Now follow the [Ghidra Extra Steps](#ghidra-extra-steps) to enable the DAILA plugin and you're good to go!



  DAILA supports the LiteLLM API, which in turn supports various backends like OpenAI.
  To use a commercial LLM API, you must provide your own API key.
  As an example, to use the OpenAI API, you must have an OpenAI API key.
  If your decompiler does not have access to the `OPENAI_API_KEY` environment variable, then you must use the decompiler option from
  DAILA to set the API key.

  In `Settings`, you can also add/use any OpenAI-based LLM endpoint, like using Llama2.

  Currently, DAILA supports the following prompts:
  - Summarize a function
  - Rename variables
  - Rename function
  - Identify the source of a function
  - Find potential vulnerabilities in a function
  - Summarize the man page of a library call
  - Free prompting... just type in your own prompt!


  VarBERT is a local BERT model from the S&P 2024 paper [""Len or index or count, anything but v1": Predicting Variable Names in Decompilation Output with Transfer Learning"]().
  VarBERT is for renaming variables (both stack, register, and arguments) in decompilation.
  To understand how to use VarBERT as a library, please see the [VarBERT API](https://github.com/binsync/varbert_api) documentation.
  Using it in DAILA is a simple as using the GUI context-menu when clicking on a function.


  You can find a demo of VarBERT running inside DAILA below:

  [![VarBERT Demo](https://img.youtube.com/vi/nUazQm8sFL8/0.jpg)](https://youtu.be/nUazQm8sFL8 "DAILA v2.1.4: Renaming variables with local VarBERT model")



  - IDA
  ![](./assets/ida_daila.png)

  - Binja
  ![](./assets/binja_daila.png)

  - Ghidra
  ![](./assets/ghidra_daila.png)

  - angr management
  ![](./assets/am_daila.png)


pkgId: 5f6dfae5196252c88c747d0071b0777709adb826a47c23dcb5e1bf057f97b0f1
name: python-daily-python
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Daily Client SDK for Python
url: https://pypi.org/project/daily-python/
rpm_license: BSD 2-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daily-python-0.11.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/daily-python)](https://pypi.org/project/daily-python)
  [![Docs](https://img.shields.io/badge/API-docs-00CC00)](https://reference-python.daily.co/)



  The Daily client SDK for Python allows you to build video and audio calling into your native desktop and server applications.

  ![daily-python](https://github.com/daily-co/daily-python/blob/main/daily-python.gif?raw=true)

  This SDK is well suited to build AI applications on the server side as it can be
  easily integrated with well-known Python libraries such as
  [OpenAI](https://github.com/openai/openai-python),
  [Deepgram](https://github.com/deepgram/deepgram-python-sdk),
  [YOLOv5](https://github.com/ultralytics/yolov5), [PyTorch](https://pytorch.org),
  [OpenCV](https://opencv.org/) and much more.

  The SDK's core features include:

  - Joining a Daily meeting as a participant
  - As a meeting participant, configuring inputs, publishing, and subscription settings
  - Receiving video frames from other participants
  - Receiving raw audio from all participants in the meeting
  - Sending video into a meeting
  - Sending raw audio into a meeting

  This functionality can be applied to several AI use cases, including:

  - Performing object or face detection on the server side
  - Processing audio from a Speech-To-Text platform into a meeting
  - Sending audio from a Text-To-Speech platform into a meeting
  - Sending video and audio tracks to a content moderation platform
  - Using generative AI to inject video content into a meeting



  See the [Daily Python API docs](https://reference-python.daily.co/index.html).

  For demos on how to use `daily-python`, refer to the [demos](https://github.com/daily-co/daily-python/tree/main/demos) directory.



  `daily-python` can be easily installed using `pip`:

  ```bash
     pip install daily-python
  ```

  To upgrade:

  ```bash
     pip install -U daily-python
  ```



  - Python 3.7 or newer



  For usage details, visit Daily's [Python SDK getting start guide](https://docs.daily.co/guides/products/ai-toolkit).



  Need help or have feedback? You can reach out through our [developer community](https://community.daily.co/) or [chat](https://www.daily.co/company/contact/support/) with our support engineers.


pkgId: 459cd31eff6392b108b869889199af78ed561c6b87bad7d619fff0fa94c7ebdc
name: python-daily-summary
arch: src
version: 0.1.29
epoch: 0
release: 1
summary: A package to generate daily development reports
url: https://github.com/jdriscoll98/daily-summary
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daily-summary-0.1.29-1.src.rpm
checksum_type: sha256
description:
  Generate a summary of your commit history for the day.


  export OPENAI_API_KEY=your-api-key

  daily-summary --repo relative/path/to/your/repo --author "Author Name" --model <model-name>

  --model is an optional argument that specifies the OpenAI model to be used. Defaults to "gpt-4" if not provided.
  --date is optional but lets you create reports for different dates than today

    "Author Name" should match your git commit author name



  Build the package:

  python3 publish.py

  OR

  python3 setup.py sdist bdist_wheel
  Update the version number in setup.py
  pip install twine
  twine upload dist/*
  username = \___token__
  password = PYPI_TOKEN


pkgId: ac252be2a7e1c21d4bd69325c3c3feae0dc4179f736360863651dba82ad23c1c
name: python-dailycovid
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: U.S.A daily covid information.
url: https://github.com/Fitzy1293/daily-covid
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dailycovid-1.3.0-1.src.rpm
checksum_type: sha256
description:
  `pip3 install dailycovid`






  `dailycovid --plot -s statecode`



  You can now use an arbitrary number of arguments with `-s` or `-sc`.

  `dailycovid -sc ny-albany ca-orange "California-Los Angeles"`

  `dailycovid -s DELAWARE MA`


  Here are three ways to do the same thing.

  `dailycovid -sc "California-Los Angeles"`

  `dailycovid -s CA -c "Los Angeles"`

  `dailycovid --state CA --county "Los Angeles"`



  Use `--plot` or `-p` to make the plots.



  On the first run it will download a csv file containing the most recent data.

  Use `dailycovid -g` to update the cache.




  '![image](https://raw.githubusercontent.com/Fitzy1293/daily-covid/master/examples/plots_LOS-ANGELES_CA.png)'

  ![image](https://raw.githubusercontent.com/Fitzy1293/daily-covid/master/examples/plots_SUFFOLK_MA.png)

  ![image](https://raw.githubusercontent.com/Fitzy1293/daily-covid/master/examples/plots_NEW-YORK-CITY_NY.png)


pkgId: fcb67cfee23accdcde9456a199d6391a759bcbadec86f316f8ffc713c7a1b53f
name: python-daindex
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Deterioration Allocation Index Framework
url: https://github.com/knowlab/daindex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daindex-0.3.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/daindex)](https://www.python.org/downloads/)
  [![PyPI - Package Status](https://img.shields.io/pypi/status/daindex)](https://pypi.org/project/daindex/)
  [![PyPI - Latest Release](https://img.shields.io/pypi/v/daindex)](https://pypi.org/project/daindex/)
  [![PyPI - Wheel](https://img.shields.io/pypi/wheel/daindex)](https://pypi.org/project/daindex/)
  [![PyPI - License](https://img.shields.io/pypi/l/daindex)](https://github.com/knowlab/daindex/blob/master/LICENSE)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

  ![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/HarrisonWilde/980a5940c78997c3c75164953475a0dc/raw/coverage.json)
  ![Tests Passing](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/HarrisonWilde/980a5940c78997c3c75164953475a0dc/raw/tests.json)
  ![Lines of Code](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/HarrisonWilde/980a5940c78997c3c75164953475a0dc/raw/loc.json)
  ![Percentage Comments](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/HarrisonWilde/980a5940c78997c3c75164953475a0dc/raw/comments.json)
  [![Snyk Package Health](https://snyk.io/advisor/python/daindex/badge.svg)](https://snyk.io/advisor/python/daindex)

  This repository implements a **DA-AUC** (deterioration-allocation area under curve) metric for quantifying **inequality** between patient groups (a) embedded in datasets; or (b) induced by statistical / ML / AI models. This is analogous to ROC-AUC for assessing performance of prediction models.



  We define and quantify health inequalities in a generic resource allocation scenario using a novel deterioration-allocation framework. The basic idea is to define two indices: a **deterioration** index and an **allocation** index. The allocation index is to be derived from the model of interest.

  Conceptually, models used in real-world contexts can be abstracted and thought of as **resource allocators**, predicting for example the probability of Intensive Care Unit (ICU) admission. Note that the models do not need to be particularly designed to allocate resources, for example, risk prediction of cardiovascular disease (CVD) among people with diabetes is also a valid index for downstream resource allocation. Essentially, a resource allocator is a computational model that takes patient data as input and outputs a (normalised) score between 0 and 1. We call this score the allocation index.

  The deterioration index is a score between 0 and 1 to measure the deterioration status of patients. It can be derived from an objective measurement for disease prognosis (i.e., *a marker of prognosis* in epidemiology terminology), such as extensively used comorbidity scores or biomarker measurements like those for CVDs.

  ![Figure 1](imgs/fig1.png)

  Once we have defined the two indices, each patient can then be represented as a point in a two-dimensional space of <*allocation index*, *deterioration index*>. A sample of the group of patients is then translated into a set of points in the space, for which a regression model can be fitted to approximate a curve in the space.

  The **area** between the two curves is then the deterioration difference between their corresponding patient groups, quantifying the inequalities induced by the `allocator`, i.e., the model that produces the allocation index. The curve with the larger area under it represents the patient group which would be unfairly treated if the allocation index was to be used in allocating resources or services: *a patient from this group would be deemed healthier than a patient from another group who is equally ill*.

  See the paper for more details: [Quantifying Health Inequalities Induced by Data and AI Models](https://doi.org/10.24963/ijcai.2022/721).




  ```bash
  pip install daindex
  ```



  After cloning the repository, you can install the package in a development `venv` using [`poetry`](https://python-poetry.org/docs/):

  ```bash
  poetry install --with dev
  pre-commit install
  ```



  1. Create sample data for testing
     ```python
     import pandas as pd
     import numpy as np
     n_size = 100

     
     female_mm = [int(m) for m in np.random.normal(3.2, .5, size=n_size)]
     df_female = pd.DataFrame(dict(mm=female_mm, gender=['f'] * n_size))
     df_female.head()

     
     male_mm = [int(m) for m in np.random.normal(3, .5, size=n_size)]
     df_male = pd.DataFrame(dict(mm=male_mm, gender=['m'] * n_size))
     df_male.head()

     
     df = pd.concat([df_female, df_male], ignore_index=True)
     ```
  2. Import the `compare_two_groups` function:
      ```python
      from daindex.util import compare_two_groups
      ```

  3. Run inequality analysis between the female and male groups:
     ```python
     compare_two_groups(
        df[df.gender=='f'], df[df.gender=='m'], 'mm',
        'female', 'male', '#Multimorbidity', 3, is_discrete=True
     )
     ```

     You will see something similar to.
     ```python
     ({'overall-prob': 0.9999, 'one-step': 0.7199, 'k-step': 0.054609, '|X|': 100},
     {'overall-prob': 0.9999, 'one-step': 0.42, 'k-step': 0.03195, '|X|': 100},
     0.7092018779342724)
     ```
     The result means the inequality of female vs male is `0.709`.



  - We provide a basic use case for the deterioration-allocation index: [basic_tutorial.ipynb](./tutorials/basic_tutorial.ipynb).
  - A more complex tutorial around the MEPS dataset is under construction: [meps_tutorial.ipynb](./tutorials/meps_tutorial.ipynb).
  - More tutorials will be added, including those for replicating studies on HiRID and MIMIC datasets.



  [honghan.wu@ucl.ac.uk](mailto:honghan.wu@ucl.ac.uk) or [h.wilde@ucl.ac.uk](mailto:h.wilde@ucl.ac.uk)



  If using this package in your own work, please cite:

  > Honghan Wu, Aneeta Sylolypavan, Minhong Wang, and Sarah Wild. 2022. ‘Quantifying Health Inequalities Induced by Data and AI Models’. In IJCAI-ECAI, 6:5192–98. https://doi.org/10.24963/ijcai.2022/721.

  Useful links: [slides](https://www.ucl.ac.uk/research-it-services/sites/research_it_services/files/quantifying_health_inequalities_induced_by_data_and_ai_models_0.pdf), [recording](https://web.microsoftstream.com/video/568b2e88-5c21-466e-9bbf-63274048161d), [arxiv](https://arxiv.org/abs/2205.01066), [proceedings](https://www.ijcai.org/proceedings/2022/721).


pkgId: 68a9c7f2fbe52d595233cffc8e93c9086e3b56dead6817ffeeaa2dcd688e1bd1
name: python-daio
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: video and data IO tools for Python
url: https://github.com/danionella/daio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daio-0.0.1-1.src.rpm
checksum_type: sha256
description:
  ![Python Version](https://img.shields.io/badge/python-3.8+-blue)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  ![tests](https://github.com/danionella/daio/actions/workflows/test.yml/badge.svg)
  [![PyPI - Version](https://img.shields.io/pypi/v/daio)](https://pypi.org/project/daio/)
  [![Conda Version](https://img.shields.io/conda/v/danionella/daio)](https://anaconda.org/danionella/daio)
  ![GitHub last commit](https://img.shields.io/github/last-commit/danionella/daio)


  Video and data IO tools for Python.

  Links: [API documentation](http://danionella.github.io/my_package), [GitHub repository](https://github.com/danionella/my_package)


  - via conda or mamba: `conda install danionella::daio `
  - if you prefer pip: `pip install daio`
  - for development, clone this repository change to the directory containing `pyproject.toml`
      - `conda env create -n env_name -f environment.yml`
      - `conda activate env_name`
      - `pip install -e .`


  TODO.


pkgId: dae0add0b85042f2bc5eb3e8720efcd10e5711fe5ff8b9eeb4a8a694a265a8d9
name: python-daio
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: video and data IO tools for Python
url: https://github.com/danionella/daio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daio-0.0.3-1.src.rpm
checksum_type: sha256
description:
  <details><summary>Old interface (expand this)</summary>
  ```python
  from daio.h5 import save_to_h5, load_from_h5

  some_dict = dict(a = 1, b = np.random.randn(3,4,5), c = dict(g='nested'), d = 'some_string')
  save_to_h5('/path/to/datafile.h5', some_dict)

  dict_loaded = load_from_h5('/path/to/datafile.h5')
  ```
  </details>


pkgId: dc4eb2921a1b41691302a8d94b7797b046e3c92e5ddba4c684374531a08bff15
name: python-daisy
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Blockwise task scheduler for processing large volumetric data.
url: https://pypi.org/project/daisy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daisy-1.2.2-1.src.rpm
checksum_type: sha256
description:
    Task square:
      num blocks : 250
      completed ✔: 250 (skipped 0)
      failed    ✗: 0
      orphaned  ∅: 0
      all blocks processed successfully
  '''

  print(b.to_ndarray())

  ```
  See that with just a minor modification, using Daisy to run multiple workers in parallel results in a 2.8176x speedups on a computer with 6 cores. For longer running tasks with larger block sizes (to minimize process spawning/joining overheads) the speedups should approach the # of threads/cores running in parallel more.

  Now we'll write and run a `reduce` task. This task performs a sum of blocks of shape `reduce_shape` from `b` and stores the results to `c`.
  ```python
  import multiprocessing
  reduce_shape = shape/16


  c = multiprocessing.Array('Q', range(int(shape/reduce_shape)))
  def process_fn_sum_reduce(block):
      b_sub = b[block.write_roi].to_ndarray()
      s = np.sum(b_sub)
      
      idx = (block.write_roi.offset / block.write_roi.shape)[0]
      c[idx] = s
  total_roi = Roi((0,), shape)  # total ROI to map process over
  block_roi = Roi((0,), reduce_shape)  # block ROI for parallel processing
  task1 = daisy.Task(
      total_roi=total_roi,
      read_roi=block_roi,
      write_roi=block_roi,
      process_function=process_fn_sum_reduce,
      num_workers=8,
      task_id='sum_reduce',
  )
  daisy.run_blockwise([task1])
  print(c[:])
  ```
  This concludes our quickstart tutorial. For more examples/tutorials please see the [examples/](/examples) directory.

  To cite this repository please use the following bibtex entry:
  ```
  @software{daisy2022github,
    author = {Tri Nguyen and Caroline Malin-Mayor and William Patton and Jan Funke},
    title = {Daisy: block-wise task dependencies for luigi.},
    url = {https://github.com/funkelab/daisy},
    version = {1.0},
    year = {2022},
  }
  ```
  In the above bibtex entry, the version number is intended to be that from [daisy/setup.py](/setup.py), and the year corresponds to the project's 1.0 release.


pkgId: 40789338f01977462a3786fb49026f3a8f888956518c3bfc7986fbd54e4a7916
name: python-daisyRec
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: An easy-to-use library for recommender systems.
url: https://github.com/AmazingDD/daisyRec
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daisyRec-2.3.0-1.src.rpm
checksum_type: sha256
description:
  daisyRec is a Python toolkit developed for benchmarking top-N recommendation task.The name DAISY stands for multi-Dimension fAirly comparIson for recommender SYstem.


pkgId: ff89f7f5da76e953d1a6084169d964c8fe9b5dcb817c3b7a4e55f6252b920953
name: python-dakiya
arch: src
version: 0.6
epoch: 0
release: 1
summary: Relay Communcation via Nitro's Communication Hub
url: https://pypi.org/project/dakiya/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dakiya-0.6-1.src.rpm
checksum_type: sha256
description:
  ```
  make build
  make upload
  ```



  ```
  from dakiya import transmitter

  var = {
      "who": "Shamail",
      "time": "1:10",
  }
  result = transmitter.send_email("nitrox/welcome.html", to = "john.doe@example.com", subject = "Hello World!", attachments=[open("/tmp/image.png", "rb+")], **var)
  ```


pkgId: afafc8d5fe80a3523e6113ac57379ff37e81e83817dbec0530e09a348d7ef254
name: python-dakoker
arch: src
version: 0.1.31
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/dakoker/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dakoker-0.1.31-1.src.rpm
checksum_type: sha256
description:
  [MFクラウド勤怠](https://biz.moneyforward.com/attendance)利用者向けに作った打刻・勤怠状況確認ツールです。

  ![Gif](https://raw.github.com/wiki/nixiesquid/mf-dakoker/end.gif)

  ![Gif](https://raw.github.com/wiki/nixiesquid/mf-dakoker/history.gif)
  主な機能
  - MFクラウド勤怠へのログイン
  - 出勤・退勤の打刻
  - 休憩開始・終了の打刻
  - 当日の勤怠状況の確認(打刻日時)
  - ブラウザでMFクラウド勤怠ページを直接開く
  - ログイン情報キャシュ・キャッシュクリア
  実装したい機能
  - 二重打刻の防止機能
  - 指定日の勤怠状況の確認(打刻日時)
  動作環境
  - Python 3.9
  - poetry 1.0.9

  `pip3 install dakoker`
  また、現在Chrome Driver・Safari Driverに対応しており、以下の設定が必要です。
  - Chrome Driverの場合
    - `brew install chromedriver` (mac OS Xの場合) でchromedriverをインストール
    - お使いのChromeブラウザとChrome Driverのバージョンが合っていない場合、正しく動作しないケースがあります。バージョンが合ったChrome Driverを使うようにしてください。
  - Safari Driverの場合
    - Safari 10.0以上を使っている場合使用可能です
    - Safari Driverを利用する場合、"環境設定"から開発メニューを表示させ、「リモートオートメーション」を許可してください。

  ログインのため、以下の情報を入力します。
  2回目以降は使用OSのパスワード保存領域(e.g. mac OS Xであればキーチェーン上)・その他ローカル領域にキャッシュされたログイン情報を読み込み、自動ログインします。
  - 企業ID
  - ユーザーID もしくは登録メールアドレス
  - パスワード
  ![初回ログイン時](https://gyazo.com/e0657a3eecfc6a486a469a0cebd98db1.png)

  - 出勤
    - `dakoker start`
  - 退勤
    - `dakoker end`
  - 休憩開始
    - `dakoker start_break`
  - 休憩終了
    - `dakoker end_break`
  - 当日の勤怠状況の確認
    - `dakoker history`
  - ブラウザでMFクラウド勤怠ページを直接開く
    - `dakoker open`
  - ログイン情報キャッシュのクリア
    - `dakoker clear`


pkgId: 6ac77f27dd320249989744f8ba49b6a0b71215c9850ac3a26a2c702707fd48a9
name: python-daktari
arch: src
version: 0.0.221
epoch: 0
release: 1
summary: Assist in setting up and maintaining developer environments
url: https://github.com/sonocent/daktari
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daktari-0.0.221-1.src.rpm
checksum_type: sha256
description:
  **Daktari** is a tool to help the initial setup and ongoing maintenance of developer environments. It runs a series of checks (for example, that required software is installed) and provides suggestions on how to fix the issue if the check fails.



  In the root of the project repository, create a `.daktari.py` configuration file listing the checks you want run. For example,

  ```python
  from daktari.checks.git import *

  version = "0.0.221"
  title = "My Project"

  checks = [
      GitInstalled(),
      GitLfsInstalled(),
      GitLfsSetUpForUser(),
      GitLfsFilesDownloaded(),
      GitCryptInstalled(),
  ]
  ```

  Then run `daktari` to diagnose your environment:

  ```
  $ daktari
  ✅ [git.installed] Git is installed
  ✅ [git.lfs.installed] Git LFS is installed
  ✅ [git.lfs.setUpForUser] Git LFS is set up for the current user
  ✅ [git.lfs.filesDownloaded] Git LFS files have been downloaded
  ❌ [git.crypt.installed] git-crypt is not installed
  ┌─💡 Suggestion ─────────┐
  │ brew install git-crypt │
  └────────────────────────┘
  ```



  You can write a custom check as a Python class within `.daktari.py`, and include it in your list of checks. Example of a check implementation:

  ```python
  class GitCryptInstalled(Check):
      name = "git.crypt.installed"
      depends_on = [GitInstalled]

      suggestions = {
          OS.OS_X: "<cmd>brew install git-crypt</cmd>",
          OS.UBUNTU: "<cmd>sudo apt install git-crypt</cmd>",
          OS.GENERIC: "Install git-crypt (https://www.agwa.name/projects/git-crypt/)",
      }

      def check(self):
          return self.verify(can_run_command("git crypt version"), "git-crypt is <not/> installed")
  ```



  Having cloned the repo into `~/daktari`, you can make use of PYTHONPATH to run daktari using your local changes.

  To do this, navigate into a directory that has a `.daktari.py` (e.g. another repository intending to use your change) and run:

  ```bash
  PYTHONPATH=~/daktari python3 -m daktari --debug
  ```



  Daktari is continuously deployed via a github action - see [release.yaml](.github/workflows/release.yaml).
  In case of a need to manually release, the steps are:

  ```
  bumpversion --verbose patch
  python setup.py sdist bdist_wheel
  twine check dist/*
  twine upload dist/*
  ```


pkgId: 5f75f150cda3303a380a325134f3595289ae84b46b9b838ab3e36bef8e074227
name: python-daktari
arch: src
version: 0.0.224
epoch: 0
release: 1
summary: Assist in setting up and maintaining developer environments
url: https://github.com/sonocent/daktari
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daktari-0.0.224-1.src.rpm
checksum_type: sha256
description:
  **Daktari** is a tool to help the initial setup and ongoing maintenance of developer environments. It runs a series of checks (for example, that required software is installed) and provides suggestions on how to fix the issue if the check fails.



  In the root of the project repository, create a `.daktari.py` configuration file listing the checks you want run. For example,

  ```python
  from daktari.checks.git import *

  version = "0.0.224"
  title = "My Project"

  checks = [
      GitInstalled(),
      GitLfsInstalled(),
      GitLfsSetUpForUser(),
      GitLfsFilesDownloaded(),
      GitCryptInstalled(),
  ]
  ```

  Then run `daktari` to diagnose your environment:

  ```
  $ daktari
  ✅ [git.installed] Git is installed
  ✅ [git.lfs.installed] Git LFS is installed
  ✅ [git.lfs.setUpForUser] Git LFS is set up for the current user
  ✅ [git.lfs.filesDownloaded] Git LFS files have been downloaded
  ❌ [git.crypt.installed] git-crypt is not installed
  ┌─💡 Suggestion ─────────┐
  │ brew install git-crypt │
  └────────────────────────┘
  ```



  You can write a custom check as a Python class within `.daktari.py`, and include it in your list of checks. Example of a check implementation:

  ```python
  class GitCryptInstalled(Check):
      name = "git.crypt.installed"
      depends_on = [GitInstalled]

      suggestions = {
          OS.OS_X: "<cmd>brew install git-crypt</cmd>",
          OS.UBUNTU: "<cmd>sudo apt install git-crypt</cmd>",
          OS.GENERIC: "Install git-crypt (https://www.agwa.name/projects/git-crypt/)",
      }

      def check(self):
          return self.verify(can_run_command("git crypt version"), "git-crypt is <not/> installed")
  ```



  Having cloned the repo into `~/daktari`, you can make use of PYTHONPATH to run daktari using your local changes.

  To do this, navigate into a directory that has a `.daktari.py` (e.g. another repository intending to use your change) and run:

  ```bash
  PYTHONPATH=~/daktari python3 -m daktari --debug
  ```



  Daktari is continuously deployed via a github action - see [release.yaml](.github/workflows/release.yaml).
  In case of a need to manually release, the steps are:

  ```
  bumpversion --verbose patch
  python setup.py sdist bdist_wheel
  twine check dist/*
  twine upload dist/*
  ```


pkgId: 7c0eef4ffa3dee85925073754b75c64543eef92ad2eb7a6932a911ed0ff815b3
name: python-daktari
arch: src
version: 0.0.225
epoch: 0
release: 1
summary: Assist in setting up and maintaining developer environments
url: https://github.com/sonocent/daktari
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daktari-0.0.225-1.src.rpm
checksum_type: sha256
description:
  **Daktari** is a tool to help the initial setup and ongoing maintenance of developer environments. It runs a series of checks (for example, that required software is installed) and provides suggestions on how to fix the issue if the check fails.



  In the root of the project repository, create a `.daktari.py` configuration file listing the checks you want run. For example,

  ```python
  from daktari.checks.git import *

  version = "0.0.225"
  title = "My Project"

  checks = [
      GitInstalled(),
      GitLfsInstalled(),
      GitLfsSetUpForUser(),
      GitLfsFilesDownloaded(),
      GitCryptInstalled(),
  ]
  ```

  Then run `daktari` to diagnose your environment:

  ```
  $ daktari
  ✅ [git.installed] Git is installed
  ✅ [git.lfs.installed] Git LFS is installed
  ✅ [git.lfs.setUpForUser] Git LFS is set up for the current user
  ✅ [git.lfs.filesDownloaded] Git LFS files have been downloaded
  ❌ [git.crypt.installed] git-crypt is not installed
  ┌─💡 Suggestion ─────────┐
  │ brew install git-crypt │
  └────────────────────────┘
  ```



  You can write a custom check as a Python class within `.daktari.py`, and include it in your list of checks. Example of a check implementation:

  ```python
  class GitCryptInstalled(Check):
      name = "git.crypt.installed"
      depends_on = [GitInstalled]

      suggestions = {
          OS.OS_X: "<cmd>brew install git-crypt</cmd>",
          OS.UBUNTU: "<cmd>sudo apt install git-crypt</cmd>",
          OS.GENERIC: "Install git-crypt (https://www.agwa.name/projects/git-crypt/)",
      }

      def check(self):
          return self.verify(can_run_command("git crypt version"), "git-crypt is <not/> installed")
  ```



  Having cloned the repo into `~/daktari`, you can make use of PYTHONPATH to run daktari using your local changes.

  To do this, navigate into a directory that has a `.daktari.py` (e.g. another repository intending to use your change) and run:

  ```bash
  PYTHONPATH=~/daktari python3 -m daktari --debug
  ```



  Daktari is continuously deployed via a github action - see [release.yaml](.github/workflows/release.yaml).
  In case of a need to manually release, the steps are:

  ```
  bumpversion --verbose patch
  python setup.py sdist bdist_wheel
  twine check dist/*
  twine upload dist/*
  ```


pkgId: c823156bfbcb9585eec364be2c82dc88df200e2823889079f21e764142a5df9a
name: python-daktari
arch: src
version: 0.0.227
epoch: 0
release: 1
summary: Assist in setting up and maintaining developer environments
url: https://github.com/sonocent/daktari
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daktari-0.0.227-1.src.rpm
checksum_type: sha256
description:
  **Daktari** is a tool to help the initial setup and ongoing maintenance of developer environments. It runs a series of checks (for example, that required software is installed) and provides suggestions on how to fix the issue if the check fails.



  In the root of the project repository, create a `.daktari.py` configuration file listing the checks you want run. For example,

  ```python
  from daktari.checks.git import *

  version = "0.0.227"
  title = "My Project"

  checks = [
      GitInstalled(),
      GitLfsInstalled(),
      GitLfsSetUpForUser(),
      GitLfsFilesDownloaded(),
      GitCryptInstalled(),
  ]
  ```

  Then run `daktari` to diagnose your environment:

  ```
  $ daktari
  ✅ [git.installed] Git is installed
  ✅ [git.lfs.installed] Git LFS is installed
  ✅ [git.lfs.setUpForUser] Git LFS is set up for the current user
  ✅ [git.lfs.filesDownloaded] Git LFS files have been downloaded
  ❌ [git.crypt.installed] git-crypt is not installed
  ┌─💡 Suggestion ─────────┐
  │ brew install git-crypt │
  └────────────────────────┘
  ```



  You can write a custom check as a Python class within `.daktari.py`, and include it in your list of checks. Example of a check implementation:

  ```python
  class GitCryptInstalled(Check):
      name = "git.crypt.installed"
      depends_on = [GitInstalled]

      suggestions = {
          OS.OS_X: "<cmd>brew install git-crypt</cmd>",
          OS.UBUNTU: "<cmd>sudo apt install git-crypt</cmd>",
          OS.GENERIC: "Install git-crypt (https://www.agwa.name/projects/git-crypt/)",
      }

      def check(self):
          return self.verify(can_run_command("git crypt version"), "git-crypt is <not/> installed")
  ```



  Having cloned the repo into `~/daktari`, you can make use of PYTHONPATH to run daktari using your local changes.

  To do this, navigate into a directory that has a `.daktari.py` (e.g. another repository intending to use your change) and run:

  ```bash
  PYTHONPATH=~/daktari python3 -m daktari --debug
  ```



  Daktari is continuously deployed via a github action - see [release.yaml](.github/workflows/release.yaml).
  In case of a need to manually release, the steps are:

  ```
  bumpversion --verbose patch
  python setup.py sdist bdist_wheel
  twine check dist/*
  twine upload dist/*
  ```


pkgId: 7fdae052d5cfe3c8983600db81a679e1eda7dd6ffd5b082737de21d09ac86a26
name: python-daktari
arch: src
version: 0.0.228
epoch: 0
release: 1
summary: Assist in setting up and maintaining developer environments
url: https://github.com/sonocent/daktari
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daktari-0.0.228-1.src.rpm
checksum_type: sha256
description:
  **Daktari** is a tool to help the initial setup and ongoing maintenance of developer environments. It runs a series of checks (for example, that required software is installed) and provides suggestions on how to fix the issue if the check fails.



  In the root of the project repository, create a `.daktari.py` configuration file listing the checks you want run. For example,

  ```python
  from daktari.checks.git import *

  version = "0.0.228"
  title = "My Project"

  checks = [
      GitInstalled(),
      GitLfsInstalled(),
      GitLfsSetUpForUser(),
      GitLfsFilesDownloaded(),
      GitCryptInstalled(),
  ]
  ```

  Then run `daktari` to diagnose your environment:

  ```
  $ daktari
  ✅ [git.installed] Git is installed
  ✅ [git.lfs.installed] Git LFS is installed
  ✅ [git.lfs.setUpForUser] Git LFS is set up for the current user
  ✅ [git.lfs.filesDownloaded] Git LFS files have been downloaded
  ❌ [git.crypt.installed] git-crypt is not installed
  ┌─💡 Suggestion ─────────┐
  │ brew install git-crypt │
  └────────────────────────┘
  ```



  You can write a custom check as a Python class within `.daktari.py`, and include it in your list of checks. Example of a check implementation:

  ```python
  class GitCryptInstalled(Check):
      name = "git.crypt.installed"
      depends_on = [GitInstalled]

      suggestions = {
          OS.OS_X: "<cmd>brew install git-crypt</cmd>",
          OS.UBUNTU: "<cmd>sudo apt install git-crypt</cmd>",
          OS.GENERIC: "Install git-crypt (https://www.agwa.name/projects/git-crypt/)",
      }

      def check(self):
          return self.verify(can_run_command("git crypt version"), "git-crypt is <not/> installed")
  ```



  Having cloned the repo into `~/daktari`, you can make use of PYTHONPATH to run daktari using your local changes.

  To do this, navigate into a directory that has a `.daktari.py` (e.g. another repository intending to use your change) and run:

  ```bash
  PYTHONPATH=~/daktari python3 -m daktari --debug
  ```



  Daktari is continuously deployed via a github action - see [release.yaml](.github/workflows/release.yaml).
  In case of a need to manually release, the steps are:

  ```
  bumpversion --verbose patch
  python setup.py sdist bdist_wheel
  twine check dist/*
  twine upload dist/*
  ```


pkgId: 784d77970eb346d6aceccb7d3b0a165b83f608dc44f9a24a122fffccb1d1ad9d
name: python-dal-admin-filters
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Django autocomplete light filters for django admin
url: https://github.com/shamanu4/dal_admin_filters
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dal-admin-filters-1.1.0-1.src.rpm
checksum_type: sha256
description:
  default select2 widget

  ![alt text](https://raw.githubusercontent.com/shamanu4/dal_admin_filters/master/shot_01.png "Admin filter with Select2 input")

  widget with title as placeholder

  ![alt text](https://raw.githubusercontent.com/shamanu4/dal_admin_filters/master/shot_02.png "Admin filter with Select2 input and placeholder title")



  This is extension for django-autocomplete-light so you need to install and configure it too.

  Here will be minimum setup for example.

  Refer to http://django-autocomplete-light.readthedocs.io/ for more detailed instructions.



  -   Install using pip

      ```
      pip install django-autocomplete-light dal_admin_filters
      ```

  -   Update INSTALLED_APPS, you need too put django-autocomplete-light before admin

      ```python
      INSTALLED_APPS = [
          'dal',
          'dal_select2',
          'dal_admin_filters',
          
          'django.contrib.admin',
          ... other stuff there ...
          ]
      ```



  -   Create autocomplete view

      -   Let our models look like this

          ```python
          class Country(models.Model):
              name = models.CharField(max_length=100, unique=True)

              def __str__(self):
                  return self.name


          class Person(models.Model):
              name = models.CharField(max_length=100, unique=True)
              from_country = models.ForeignKey(Country)

              def __str__(self):
                  return self.name

          ```

      -   Then autocomplete view for country selection will be similar to next

          ```python
          from dal import autocomplete
          from your_countries_app.models import Country

          class CountryAutocomplete(autocomplete.Select2QuerySetView):
              def get_queryset(self):
                  
                  if not self.request.user.is_authenticated():
                      return Country.objects.none()

                  qs = Country.objects.all()

                  if self.q:
                      qs = qs.filter(name__istartswith=self.q)

                  return qs
          ```

  -   Register view in urls.py

      ```python
      from your_countries_app.views import CountryAutocomplete

      urlpatterns = [
          url(
              r'^country-autocomplete/$',
              CountryAutocomplete.as_view(),
              name='country-autocomplete',
          ),
          url(r'^admin/', admin.site.urls),
      ]
      ```

  -   Use filter in your admin.py

      ```python
      from django.contrib import admin
      from your_countries_app.models import Country, Person
      from dal_admin_filters import AutocompleteFilter


      @admin.register(Country)
      class CountryAdmin(admin.ModelAdmin):
          pass


      class CountryFilter(AutocompleteFilter):
          title = 'Country from'                    # filter's title
          field_name = 'from_country'               # field name - ForeignKey to Country model
          autocomplete_url = 'country-autocomplete' # url name of Country autocomplete view


      class CountryPlaceholderFilter(AutocompleteFilter):
          title = 'Country from'                    # filter's title
          field_name = 'from_country'               # field name - ForeignKey to Country model
          autocomplete_url = 'country-autocomplete' # url name of Country autocomplete view
          is_placeholder_title = True               # filter title will be shown as placeholder


      class CountryCustomPlaceholderFilter(AutocompleteFilter):
          title = 'Country from'                    # filter's title
          parameter_name = 'from_country'           # field name - ForeignKey to Country model
          autocomplete_url = 'country-autocomplete' # url name of Country autocomplete view
          widget_attrs = {
              'data-placeholder': 'Filter by country name'
          }


      @admin.register(Person)
      class PersonAdmin(admin.ModelAdmin):
          class Media:    # Empty media class is required if you are using autocomplete filter
              pass        # If you know better solution for altering admin.media from filter instance
                          

          list_filter = [CountryFilter]

      ```

  If setup is done right, you will see the Select2 widget in admin filter in Person's changelist view.



  -   Define forwards in the filter (example from the demo_project)

      ```python
      from dal import forward

      class PersonFilter(AutocompleteFilter):
          autocomplete_url = 'person-autocomplete'
          title = 'Owner'
          field_name = 'owner'
          forwards = [
              forward.Field(
                  'from_country__id__exact',  # Field name of filter input
                  'country_id'                # Field name passed to the autocomplete_url endpoint
              )
          ]
      ```

  Read more at [https://django-autocomplete-light.readthedocs.io/](https://django-autocomplete-light.readthedocs.io/en/master/tutorial.html#filtering-results-based-on-the-value-of-other-fields-in-the-form)


pkgId: 16d4ec72750974f74467126fd4ddabe7babf95ef3bb0fd2812a01a1e11289f07
name: python-dalex
arch: src
version: 1.7.1
epoch: 0
release: 1
summary: Responsible Machine Learning in Python
url: https://dalex.drwhy.ai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dalex-1.7.1-1.src.rpm
checksum_type: sha256
description:
  * `numpy>=2.0.0` compatibility: replace instances of `x.ptp()` with `np.ptp(x)` and `np.Inf` with `np.inf` ([#571](https://github.com/ModelOriented/DALEX/issues/571))
  * added a way to pass `sample_weight` to loss functions in `model_parts()` (variable importance) using `weights` from `dx.Explainer` ([#563](https://github.com/ModelOriented/DALEX/issues/563))
  * fixed the visualization of `shap_wrapper` for `shap==0.45.0`

  * increase the dependencies to `python>=3.8`, `pandas>=1.5.0`, `numpy>=1.23.3` and add `python==3.11` to CI
  * added `keras.src.models.sequential.Sequential` to classes with a known `predict_function`; it should fix changes in `keras==3.0.0` and `tensorflow==2.16.0`
  * turn off `verbose` in the predict method of tensorflow/keras models that [changed](https://stackoverflow.com/a/73244830) in `tensorflow>=2.9.0`
  * update the warning occurring when specifying `variable_splits` ([#558](https://github.com/ModelOriented/DALEX/pull/558))
  * fix an error occuring in `predict_profile()` when a DataFrame has MultiIndex in `pandas>=1.3.0` ([#550](https://github.com/ModelOriented/DALEX/pull/550))
  * fix gaussian `norm()` calculation in `model_profile()` from `pi*sqrt(2)` to `sqrt(2*pi)`
  * fix a warning (future error) between `prepare_numerical_categorical()` and `prepare_x()` with `pandas==2.1.0`
  * fix a warning (future error) concerning the default value of `numeric_only` in `pandas.DataFrame.corr()` in `dalex.aspect.calculate_assoc_matrix()`

  * add `ZeroDivisionError` to precision and recall functions ([#532](https://github.com/ModelOriented/DALEX/pull/532))
  * add a warning to `calculate_depend_matrix()` when there is a variable with only one value ([#537](https://github.com/ModelOriented/DALEX/issues/537))
  * fix missing EDA plots in (Python) Arena ([#544](https://github.com/ModelOriented/DALEX/issues/544))
  * fix baseline positions in the subplots of the predict parts explanations: BreakDown, Shap ([#545](https://github.com/ModelOriented/DALEX/pull/545))

  *This release consists of mostly maintenance updates and, after a year, marks the Beta -> Stable release.*
  * increase the dependency from `python>=3.6` to `python>=3.7` (at this moment, both `numpy` and `pandas` depend on `python>=3.8`), and add `python==3.10` to CI
  * increase the dependencies to `pandas>=1.2.5`, `numpy>=1.20.3` ([#526](https://github.com/ModelOriented/DALEX/issues/526)), `scipy>=1.6.3`, `plotly>=5.1.0`, and `tqdm>=4.61.2` due to errors with `pandas` (see [tqdm/#1199](https://github.com/tqdm/tqdm/issues/1199))
  * remove the use of `pd.Series.append()` ([#489](https://github.com/ModelOriented/DALEX/issues/489))
  * remove the use of `np.isnan` causing error in `dalex.fairness` ([#491](https://github.com/ModelOriented/DALEX/issues/491))
  * fix iBreakDown plot y-axis labels ([#493](https://github.com/ModelOriented/DALEX/issues/493))
  * stop the Arena's `werkzeug` server using a clearner and still supported API ([#518](https://github.com/ModelOriented/DALEX/issues/518))


  * added fairness plot for regression models to `Arena` ([dalex/#408](https://github.com/ModelOriented/DALEX/issues/408))
  * added new `facet_scales` parameter to `AP.plot` and `CP.plot`, which allows to free the y-axis with `facet_scales="free"` ([dalex/#469](https://github.com/ModelOriented/DALEX/issues/469)); consistent with R ([DALEX/#468](https://github.com/ModelOriented/DALEX/issues/468), [ingredients/#140](https://github.com/ModelOriented/ingredients/pull/140))

  * fixed `AP` and `CP` progress bars

  * added new `aspect` module, which will focus on groups of dependent variables [@krzyzinskim](https://github.com/krzyzinskim) & [@arturzolkowski](https://github.com/arturzolkowski)
  * added new `scipy>=1.5.4` dependency

  * improved the calculation of AUC, ROC plot ([#459](https://github.com/ModelOriented/DALEX/issues/459))

  * wrong yaxis labels in `VariableImportance.plot(split="variable")` ([#451](https://github.com/ModelOriented/DALEX/issues/451))
  * `repr_html()` didn't work for explanation objects before using the `fit` method ([#449](https://github.com/ModelOriented/DALEX/issues/449))

  * added new `Aspect` object with the `predict_triplot`, `model_triplot`, `predict_parts`, `model_parts`, `get_aspects` methods
  * added new `PredictTriplot`, `ModelTriplot`, `PredictAspectImportance`, `ModelAspectImportance` objects with the `plot` method


  * added bias mitigation techniques (`resample`, `reweight`, `roc_pivot`) into the `fairness` module ([#432](https://github.com/ModelOriented/DALEX/issues/432))


  * method `set_options` in Arena now takies `option_category` instead of `plot_type` (`SHAPValues` => `ShapleyValues`, `FeatureImportance` => `VariableImportance`) ([#420](https://github.com/ModelOriented/DALEX/pull/420))
  * methods using the `N` parameter now properly sample rows from `data`

  * fixed wrong error value when no `predict_function` is found in `Explainer` ([77ca90d](https://github.com/ModelOriented/DALEX/commit/77ca90d))
  * set multiprocessing context to `'spawn'` ([#412](https://github.com/ModelOriented/DALEX/issues/412))
  * fixed bug in `metric_scores` plot that made only one subgroup appear on y-axis ([#416](https://github.com/ModelOriented/DALEX/issues/416))
  * added support for older keras models ([#415](https://github.com/ModelOriented/DALEX/issues/415))

  * added a resource mechanism to Arena ([#419](https://github.com/ModelOriented/DALEX/issues/419))
  * added `ShapleyValuesImportance` and `ShapleyValuesDependence` plots to Arena ([#420](https://github.com/ModelOriented/DALEX/pull/420))
  * return `error` instead of `NaN` when AUC is calculated on observations from one class only ([#415](https://github.com/ModelOriented/DALEX/issues/415))


  * fixed concurrent random seeds when `processes > 1` ([#392](https://github.com/ModelOriented/DALEX/issues/392)), which means that the results of parallel computation will vary between `v1.1.0` and previous versions

  * `GroupFairnessX.plot(type='fairness_check')` generates ticks according to the x-axis range ([#409](https://github.com/ModelOriented/DALEX/issues/409))
  * `GroupFainressRegression.plot(type='density')` has a more readable hover - only for outliers ([#409](https://github.com/ModelOriented/DALEX/issues/409))
  * `BreakDown.plot()` wrongly displayed the "+all factors" bar when `max_vars < p` ([#401](https://github.com/ModelOriented/DALEX/issues/401))
  * `GroupFairnessClassification.plot(type='metric_scores')` did not handle `NaN`'s ([#399](https://github.com/ModelOriented/DALEX/issues/399))

  * Experimental support for regression models in the `fairness` module. Added `GroupFairnessRegression` object, with the `plot` method having two types: `fairness_check` and `density`. `Explainer.model_fairness` method now depends on the `model_type` attribute. ([#391](https://github.com/ModelOriented/DALEX/issues/391))
  * added `N` parameter to the `predict_parts` method which is `None` by default ([#402](https://github.com/ModelOriented/DALEX/issues/402))
  * `epsilon` is now an argument of the `GroupFairnessClassification` object ([#397](https://github.com/ModelOriented/DALEX/issues/397))


  * fixed broken range on `yaxis` in `fairness_check` plot ([#376](https://github.com/ModelOriented/DALEX/issues/376))
  * warnings because `np.float` is depracated since `numpy` v1.20 ([#384](https://github.com/ModelOriented/DALEX/issues/384))

  * added `ipython` to test dependencies


  These are summed up in ([#368](https://github.com/ModelOriented/DALEX/issues/368)):
  * rename modules: `dataset_level` into `model_explanations`, `instance_level` into `predict_explanations`, `_arena` module into `arena`
  * use `__dir__` method to define autocompletion in IPython environment - show only `['Explainer', 'Arena', 'fairness', 'datasets']`
  * add `plot` method and `result` attribute to `LimeExplanation` (use `lime.explanation.Explanation.as_pyplot_figure()` and `lime.explanation.Explanation.as_list()`)
  * `CeterisParibus.plot(variable_type='categorical')` now has horizontal barplots - `horizontal_spacing=None` by default (varies on `variable_type`). Also, once again added the "dot" for observation value.
  * `predict_fn` in `predict_surrogate` now uses `predict_function` (trying to make it work for more frameworks)

  * fixed wrong verbose output when any value in `y_hat/residuals` was an `int` not `float`
  * added proper `"-"` sign to negative dropout losses in `VariableImportance.plot`

  * added `geom='bars'` to `AggregateProfiles.plot` to force the categorical plot
  * added `geom='roc'` and `geom='lift'` to `ModelPerformance.plot`
  * added Fairness plot to Arena

  * remove `colorize` from `Explainer`
  * updated the documentation, refactored code (import modules not functions, unify variable names in `object.py`, move utils funcitons from `checks.py` to `utils.py`, etc.)
  * added license notice next to data

  * added support for `h2o.estimators.*` ([#332](https://github.com/ModelOriented/DALEX/issues/332))
  * added `tensorflow.python.keras.engine.functional.Functional` to the `tensorflow` list
  * updated the `plotly` dependency to `>=4.12.0`
  * code maintenance: `yhat`, `check_data`

  * fixed `check_if_empty_fields()` used in loading the `Explainer` from a pickle file, since several checks were changed
  * fixed `plot()` method in `GroupFairnessClassification` as it omitted plotting a metric when `NaN` was present in metric ratios (result)
  * fixed `dragons` and `HR` datasets having `,` delimeter instead of `.`, which transformed numerical columns into categorical.
  * fixed representation of the `ShapWrapper` class (removed `_repr_html_` method)

  * allow for `y` to be a `pandas.DataFrame` (converted)
  * allow for `data`, `y` to be a `H2OFrame` (converted)
  * added `label` parameter to all the relevant `dx.Explainer` methods, which overrides the default label in explanation's `result`
  * now using `GradientExplainer` for `tf.keras.engine.sequential.Sequential`, added proper warning when `shap_explainer_type` is `None` ([#366](https://github.com/ModelOriented/DALEX/issues/366))

  * unify verbose output of `Explainer`

  * added new `arena` module, which adds the backend for Arena dashboard [@piotrpiatyszek](https://github.com/piotrpiatyszek)

  * added new aliases to `dx.Explainer` methods ([#350](https://github.com/ModelOriented/DALEX/issues/350))
   in `model_parts` it is `{'permutational': 'variable_importance', 'feature_importance': 'variable_importance'}`,
   in `model_profile` it is `{'pdp': 'partial', 'ale': 'accumulated'}`
  * added `Arena` object for dashboard backend. See https://github.com/ModelOriented/Arena
  * new `fairness` plot types: `stacked`, `radar`, `performance_and_fairness`, `heatmap`, `ceteris_paribus_cutoff`
  * upgraded `fairness_check()`

  * added new `fairness` module, which will focus on bias detection, visualization and mitigation [@jakwisn](https://github.com/jakwisn)

  * removed unnecessary warning when `precalculate=False and verbose=False` ([#340](https://github.com/ModelOriented/DALEX/issues/340))

  * added `model_fairness` method to the `Explainer`, which performs fairness explanation
  * added `GroupFairnessClassification` object, with the `plot` method having two types: `fairness_check` and `metric_scores`

  * added the `N=50000` argument to `ResidualDiagnostics.plot`, which samples observations from
   the `result` parameter to omit performance issues when `smooth=True` ([#341](https://github.com/ModelOriented/DALEX/issues/341))

  * added support for `tensorflow.python.keras.engine.sequential.Sequential` and `tensorflow.python.keras.engine.training.Model` ([#326](https://github.com/ModelOriented/DALEX/issues/326))
  * updated the `tqdm` dependency to `>=4.48.2`, `pandas` dependency to `>=1.1.2` and `numpy` dependency to `>=1.18.4`

  * fixed the wrong order of `Explainer` verbose messages
  * fixed a bug that caused `model_info` parameter to be overwritten by the default values
  * fixed a bug occurring when the variable from `groups` was not of `str` type ([#327](https://github.com/ModelOriented/DALEX/issues/327))
  * fixed `model_profile`: `variable_type='categorical'` not working when user passed `variables` parameter ([#329](https://github.com/ModelOriented/DALEX/issues/329)) +
   the reverse order of bars in `'categorical'` plots + (again) added `variable_splits_type` parameter to `model_profile` to specify how grid points
   shall be calculated ([#266](https://github.com/ModelOriented/DALEX/issues/266)) + allow for both `'quantile'` and `'quantiles'` types (alias)

  * added informative error messages when importing optional dependencies ([#316](https://github.com/ModelOriented/DALEX/issues/316))
  * allow for `data` and `y` to be `None` - added checks in `Explainer` methods

  * wrong parameter name `title_x` changed to `y_title` in `CeterisParibus.plot` and `AggregatedProfiles.plot` ([#317](https://github.com/ModelOriented/DALEX/issues/317))
  * now warning the user in `Explainer` when `predict_function` returns an error or doesn't return `numpy.ndarray (1d)` ([#325](https://github.com/ModelOriented/DALEX/issues/325))

  * updated the `pandas` dependency to `>=1.1.0`

  * `ModelPerformance.plot` now uses a drwhy color palette
  * use `unique` method instead of `np.unique` in `variable_splits` ([#293](https://github.com/ModelOriented/DALEX/issues/293))
  * `v0.2.0` didn't export new datasets
  * fixed a bug where `predict_parts(type='shap')` calculated wrong `contributions`
   ([#300](https://github.com/ModelOriented/DALEX/issues/300))
  * `model_profile` uses observation mean instead of profile mean in `_yhat_` centering
  * fixed barplot baseline in categorical `model_profile` and `predict_profile` plots
   ([#297](https://github.com/ModelOriented/DALEX/issues/297))
  * fixed `model_profile(type='accumulated')` giving wrong results
   (#[302](https://github.com/ModelOriented/DALEX/issues/302))
  * vertical/horizontal lines in plots now end on the plot edges

  * added new `type='shap_wrapper'` to `predict_parts` and `model_parts` methods, which returns a new
   `ShapWrapper` object. It contains the main result attribute (`shapley_values`) and the plot method
   (`force_plot` and `summary_plot` respectively). These come from the [shap](https://github.com/slundberg/shap) package
  * `Explainer.predict` method now accepts `numpy.ndarray`
  * added the `ResidualDiagnostics` object with a `plot` method
  * added `model_diagnostics` method to the `Explainer`, which performs residual diagnostics
  * added `predict_surrogate` method to the `Explainer`, which is a wrapper for the `lime`
   tabular explanation from the [lime](https://github.com/marcotcr/lime) package
   * added `model_surrogate` method to the `Explainer`, which creates a basic surrogate decision tree
   or linear model from the black-box model using the [scikit-learn](https://github.com/scikit-learn/scikit-learn) package
  * added a `_repr_html_` method to all of the explanation objects (it prints the `result` attribute)
  * added `dalex.__version__`
  * added informative error messages in `Explainer` methods when `y` is of wrong type
   ([#294](https://github.com/ModelOriented/DALEX/issues/294))
  * `CeterisParibus.plot(variable_type='categorical')` now allows for multiple observations
  * new verbose checks for `model_type`
  * add `type` to `model_info` in `dump` and `dumps` for R compatibility
   ([#303](https://github.com/ModelOriented/DALEX/issues/303))
  * `ModelPerformance.result` now has `label` as index

  * removed `_grid_` column in `AggregatedProfiles.result` and `center` only works with `type=accumulated`
  * use `Pipeline._final_estimator` to extract `model_class` of the actual model
  * use `model._estimator_type` to extract `model_type` if possible

  * major documentation update ([#270](https://github.com/ModelOriented/DALEX/issues/270))
  * unified the order of function parameters

  * `v0.1.9` had wrong `_original_` column in `predict_profile`
  * `vertical_spacing` acts as intended in `VariableImportance.plot` when `split='variable'`
  * `loss_function='auc'` now uses `loss_one_minus_auc` as this should be a descending measure
  * plots are now saved with the original height and width
  * `model_profile` now properly passes the `variables` parameter to `CeterisParibus`
  * `variables` parameter in `predict_profile` now can also be a string

  * use `px.express` instead of core `plotly` to make `model_profile` and `predict_profile` plots;
   thus, enhance performance and scalability
  * added `verbose` parameter where `tqdm` is used to verbose progress bar
  * added `loss_one_minus_auc` function that can be used with `loss_function='1-auc'` in `model_parts`
  * added new example data sets: `apartments`, `dragons` and `hr`
  * added `color`, `opacity`, `title_x` parameters to `model_profile` and `predict_profile` plots ([#236](https://github.com/ModelOriented/DALEX/issues/236)),
   changed tooltips and legends ([#262](https://github.com/ModelOriented/DALEX/issues/262))
  * added `geom='profiles'` parameter to `model_profile` plot and `raw_profiles` attribute to `AggregatedProfiles`
  * added `variable_splits_type` parameter to `predict_profile` to specify how grid points
   shall be calculated ([#266](https://github.com/ModelOriented/DALEX/issues/266))
  * added `variable_splits_with_obs` parameter to `predict_profile` function to extend split points with observation
   variable values ([#269](https://github.com/ModelOriented/DALEX/issues/269))
  * added `variable_splits` parameter to `model_profile`

  * use different `loss_function` for classification and regression ([#248](https://github.com/ModelOriented/DALEX/issues/248))
  * models that use `proba` yhats now get `model_type='classification'` if it's not specified
  * use uniform way of grid points calculation in `predict_profile` and `model_profile` (see `variable_splits_type` parameter)
  * add the variable values of `new_observation` to `variable_splits` in `predict_profile` (see `variable_splits_with_obs` parameter)
  * use `N=1000` in `model_parts` and `N=300` in `model_profile` to comply with the R version
  * `keep_raw_permutation` is now set to `False` instead of `None` in `model_parts`
  * `intercept` parameter in `model_profile` is now named `center`

  * *feature:* added `random_state` parameter for `predict_parts(type='shap')` and `model_profile` for reproducible calculations
  * *fix:* fixed `random_state` parameter in `model_parts`
  * *feature:* multiprocessing added for: `model_profile`, `model_parts`, `predict_profile` and `predict_parts(type='shap')`, through the `processes` parameter
  * *fix:* significantly improved the speed of `accumulated` and `conditional` types in `model_profile`
  * *bugfix:* use [pd.api.types.is_numeric_dtype()](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.api.types.is_numeric_dtype.html)
    instead of `np.issubdtype()` to cover more types; e.g. it caused errors with `string` type
  * *defaults:* use [pd.convert_dtypes()](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.convert_dtypes.html)
   on the result of `CeterisParibus` to fix variable dtypes and
   later allow for a concatenation without the dtype conversion
  * *fix:* `variables` parameter now can be a single `str` value
  * *fix:* number rounding in `predict_parts`, `model_parts` ([#245](https://github.com/ModelOriented/DALEX/issues/245))
  * *fix:* CP calculations for models that take only variables as an input

  * *bugfix:* `variable_splits` parameter now works correctly in `predict_profile`
  * *bugfix:* fix baseline for 3+ models in `AggregatedProfiles.plot` ([#234](https://github.com/ModelOriented/DALEX/issues/234))
  * *printing:* now rounding numbers in `Explainer` messages
  * *fix:* minor checks fixes in `instance_level`
  * *bugfix:* `AggregatedProfiles.plot` now works with `groups`

  * *feature:* parameter `N` in `model_profile` can be set to `None`, to select all observations
  * *input:* `groups` and `variable` parameters in `model_profile` can be: `str`, `list`, `numpy.ndarray`, `pandas.Series`
  * *fix:* `check_label` returned only a first letter
  * *bugfix:* removed the conversion of `all_variables` to `str` in
  `prepare_all_variables`, which caused an error in `model_profile` ([#214](https://github.com/ModelOriented/DALEX/issues/214))
  * *defaults:* change numpy data variable names from numbers to strings

  * *fix:* change `short_name` encoding in `fifa` dataset (utf8->ascii)
  * *fix:* remove `scipy` dependency
  * *defaults:* default `loss_root_mean_square` in model parts changed to `rmse`
  * *bugfix:* checks related to `new_observation` in `BreakDown, Shap,
  CeterisParibus` now work for multiple inputs
  ([#207](https://github.com/ModelOriented/DALEX/issues/207))
  * *bugfix:* `CeterisParibus.fit` and `CeterisParibus.plot` now work for
  more types of `new_observation.index`, but won't work for a `bolean` type
  ([#211](https://github.com/ModelOriented/DALEX/issues/211))

  * *feature:* add `xgboost` package compatibility ([#188](https://github.com/ModelOriented/DALEX/issues/188))
  * *feature:* added `model_class` parameter to `Explainer` to handle wrapped
  models
  * *feature:* `Exaplainer` attribute `model_info` remembers if parameters are default
  * *bugfix:* `variable_groups` parameter now works correctly in `model_parts`
  * *fix:* changed parameter order in `Explainer`: `model_type`, `model_info`,
  `colorize`
  * *documentation:* `model_parts` documentation is updated
  * *feature:* new `show` parameter in `plot` methods that (`if False`) returns
  `plotly Figure` ([#190](https://github.com/ModelOriented/DALEX/issues/190))
  * *feature:* `load_fifa()` function which loads the preprocessed [players_20
  dataset](https://www.kaggle.com/stefanoleone992/fifa-20-complete-player-dataset)
  * *fix:* `CeterisParibus.plot` tooltip

  * *feature:* new `Explainer.residual` method which uses
  `residual_function` to calculate `residuals`
  * *feature:* new `dump` and `dumps` methods for saving `Explainer` in a binary form;
  `load` and `loads` methods for loading `Explainer` from binary form
  * *fix:* `Explainer` constructor verbose text
  * *bugfix:* `B:=B+1` - `Shap` now stores average results as `B=0` and path results as `B=1,2,...`
  * *bugfix:* `Explainer.model_performance` method uses `self.model_type` when
   `model_type` is `None`
  * *bugfix:* values in `BreakDown` and `Shap` are now rounded to 4 significant
   places ([#180](https://github.com/ModelOriented/DALEX/issues/180))
  * *bugfix:* `Shap` by default uses `path='average'`, `sign` column is
  properly updated and bars in `plot` are sorted by `abs(contribution)`

  * [release](https://medium.com/@ModelOriented/xai-in-python-with-dalex-4b173486aa92) of the `dalex` package
  * `Explainer` object with `predict`, `predict_parts`, `predict_profile`,
  `model_performance`, `model_parts` and `model_profile` methods
  * `BreakDown`, `Shap`, `CeterisParibus`, `ModelPerformance`,
  `VariableImportance` and `AggregatedProfiles` objects with a `plot` method
  * `load_titanic()` function which loads the `titanic_imputed` dataset


pkgId: 0fe4fbaae3c033222d089be96b6b182be79d009b72e91b4c845a04a9b73a00f7
name: python-dalf
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Dead simple autocompletion for Django admin list_filter with goodies.
url: https://github.com/vigo/django-admin-list-filter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dalf-0.2.6-1.src.rpm
checksum_type: sha256
description:
  Thanks to my dear friend [Bahattin Çiniç][bahattincinic]’s warning, He realized
  that the necessary HTML, CSS, and JavaScript files were missing from the
  published package! I quickly fixed this and published a new version. The `0.1.0`
  version is a faulty version. I apologize to the users for this confusion.


pkgId: bc2c6679d3e8701a1184d3c016a4e65bad72ea7b035c54a2be5ff12c22ce81ef
name: python-dalpha
arch: src
version: 0.5.11
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/dalpha/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dalpha-0.5.11-1.src.rpm
checksum_type: sha256
description:
  - pip 으로 설치하는 경우
    - install.sh 를 프로젝트에 복재해 사용합니다.

  - poetry 로 설치하는 경우
    - install_poetry.sh 를 프로젝트에 복재해 사용합니다.

  - CI 에 설정하는 법
    - CI 에 다음 step 을 추가합니다.



  ``` python
  import dalpha
  ```


  - `make build`
  - version 맞춰서 S3 업로드 (`dalpha-internal-sdk`)


  `pip install build twine`
  `git pull origin main`
  `python3 -m build`
  `python3 -m twine upload dist/*`


pkgId: 6b1ff1f2ed2aebe67efd9c8ebaa0d82b216c2f28a91f020884442510b1ce55ee
name: python-daltools
arch: src
version: 1.1.7
epoch: 0
release: 1
summary: Daltools: utilities for extracting data from Dalton quantum chemistry calculations
url: https://github.com/vahtras/daltools
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daltools-1.1.7-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/vahtras/daltools.svg?branch=master)](https://travis-ci.org/vahtras/daltools)
  [![Coverage Status](https://coveralls.io/repos/github/vahtras/daltools/badge.svg?branch=master)](https://coveralls.io/github/vahtras/daltools?branch=master)
  ![Python package](https://github.com/vahtras/daltools/workflows/Python%20package/badge.svg)



  Daltools is a collection of utilities for extracting data from a
  [Dalton](https://daltonprogram.org) calculation. It is experimental in nature
  and has been designed for prototyping and testing.


pkgId: 482754c6b15c27a59814205a3a112403d1af8a2641c81abd667e7b633f5977dd
name: python-dalybms
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Client for Daly BMS
url: https://github.com/dreadnought/python-daly-bms
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dalybms-0.5.0-1.src.rpm
checksum_type: sha256
description:
  This is a Python module for reading data from Daly BMS devices. It supports serial as well as Bluetooth connections. Not all commands that the BMS supports are implemented yet, please take a look at the examples below to see if it serves your needs.



  There are two different types of devices sold under the Daly Brand, which use different communication protocols.
  This module was initially written for BMS supported by the Windows program BMS monitor.
  Later (in #1) the support for BMS supported by the BMStool, also known as Sinowealth, was added. They don't support all commands of the first protocol, but still provide valuable information.

  There are two ways to check if your BMS is supported:
  1. First run `daly-bms-cli` normally and see if `--soc` returns data. If not, run it again while adding `--sinowealth`, which switches to the other protocol.
  2. Connect the BMS to a Windows computer, run the PC tools provided by Daly ([Download](https://www.dalyelec.cn/newsshow.php?cid=25&id=77&lang=1)) and see which one works.

  If you make it work with the Windows software, but not with `daly-bms-cli`, feel free to create a [bug report](https://github.com/dreadnought/python-daly-bms/issues).





  ```
  pip3 install dalybms
  ```



  ```
  git clone https://github.com/dreadnought/python-daly-bms.git
  cd python-daly-bms
  sudo python3 setup.py install
  ```



  For *serial* connections:
  ```
  pip3 install pyserial
  ```

  For *bluetooth* connections:
  ```
  pip3 install bleak
  ```

  For *MQTT*:
  ```
  pip3 install paho-mqtt
  ```



  `daly-bms-cli` is a reference implementation for this module, but can also be used to test the connection or use it in combination with other programming languages. The data gets returned in JSON format. It doesn't support Bluetooth connections yet.


  ```

  usage: daly-bms-cli [-h] -d DEVICE [--uart] [--sinowealth] [--status] [--soc] [--mosfet] [--cell-voltages] [--temperatures] [--balancing] [--errors] [--all] [--check] [--set-discharge-mosfet SET_DISCHARGE_MOSFET] [--set-soc] [--retry RETRY] [--verbose] [--mqtt]
                      [--mqtt-hass] [--mqtt-topic MQTT_TOPIC] [--mqtt-broker MQTT_BROKER] [--mqtt-port MQTT_PORT] [--mqtt-user MQTT_USER] [--mqtt-password MQTT_PASSWORD]

  optional arguments:
    -h, --help            show this help message and exit
    -d DEVICE, --device DEVICE
                          RS485 device, e.g. /dev/ttyUSB0
    --uart                UART instead of RS485
    --sinowealth          BMS with Sinowealth chip
    --status              show status
    --soc                 show voltage, current, SOC
    --mosfet              show mosfet status
    --cell-voltages       show cell voltages
    --temperatures        show temperature sensor values
    --balancing           show cell balancing status
    --errors              show BMS errors
    --all                 show all
    --check               Nagios style check
    --set-discharge-mosfet SET_DISCHARGE_MOSFET
                          'on' or 'off'
    --set-soc SET_SOC     0.0 to 100.0
    --retry RETRY         retry X times if the request fails, default 5
    --verbose             Verbose output
    --mqtt                Write output to MQTT
    --mqtt-hass           MQTT Home Assistant Mode
    --mqtt-topic MQTT_TOPIC
                          MQTT topic to write to. default daly_bms
    --mqtt-broker MQTT_BROKER
                          MQTT broker (server). default localhost
    --mqtt-port MQTT_PORT
                          MQTT port. default 1883
    --mqtt-user MQTT_USER
                          Username to authenticate MQTT with
    --mqtt-password MQTT_PASSWORD
                          Password to authenticate MQTT with
  ```



  Get the State of Charge:
  ```

  {
    "total_voltage": 57.7,
    "current": -11.1,
    "soc_percent": 99.1
  }
  ```

  Get everything possible:
  ```

  {
    "soc": {
      "total_voltage": 52.5,
      "current": 0.0,
      "soc_percent": 18.9
    },
    "cell_voltage_range": {
      "highest_voltage": 3.78,
      "highest_cell": 14,
      "lowest_voltage": 3.728,
      "lowest_cell": 1
    },
    "temperature_range": {
      "highest_temperature": 15,
      "highest_sensor": 1,
      "lowest_temperature": 15,
      "lowest_sensor": 1
    },
    "mosfet_status": {
      "mode": "stationary",
      "charging_mosfet": true,
      "discharging_mosfet": true,
      "capacity_ah": 5.67
    },
    "status": {
      "cells": 14,
      "temperature_sensors": 1,
      "charger_running": false,
      "load_running": false,
      "states": {
        "DI1": false,
        "DI2": true
      },
      "cycles": 21
    },
    "cell_voltages": {
      "1": 3.728,
      "2": 3.734,
      "3": 3.734,
      "4": 3.736,
      "5": 3.736,
      "6": 3.742,
      "7": 3.757,
      "8": 3.766,
      "9": 3.768,
      "10": 3.761,
      "11": 3.744,
      "12": 3.78,
      "13": 3.749,
      "14": 3.78
    },
    "temperatures": {
      "1": 15
    },
    "balancing_status": {
      "error": "not implemented"
    },
    "errors": [
      "SOC is too low. level one alarm"
    ]
  }
  ```

  Send SOC data to a MQTT broker:
  ```

  ```





  - It's also recommended to have a recent BlueZ installed (>=5.53).

    The Bluetooth connection uses `asyncio` for the connection, so the data is received asynchronous.

  - It seems like the Bluetooth BMS Module goes to sleep after 1 hour of inactivity (no load or charging), while the serial connection responds all the time. Sending a command via the serial interface wakes up the Bluetooth module.


pkgId: aa85ed9cd89d20173a6f4b709c13a8763300d91b63d89c3b016037d2d8a63415
name: python-damagescanner
arch: src
version: 0.7
epoch: 0
release: 1
summary: Direct damage assessments for natural hazards
url: https://github.com/ElcoK/DamageScanner
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-damagescanner-0.7-1.src.rpm
checksum_type: sha256
description:
  <img align="right" width="200" alt="Logo" src="https://raw.githubusercontent.com/ElcoK/DamageScanner/master/doc/ds_logo.png">


  [![github repo badge](https://img.shields.io/badge/github-repo-000.svg?logo=github&labelColor=gray&color=blue)](https://github.com/ElcoK/DamageScanner)
  [![github license badge](https://img.shields.io/github/license/ElcoK/DamageScanner)](https://github.com/ElcoK/DamageScanner)
  [![fair-software badge](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8B-yellow)](https://fair-software.eu)
  [![Documentation Status](https://readthedocs.org/projects/damagescanner/badge/?version=latest)](https://damagescanner.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/damagescanner.svg)](https://badge.fury.io/py/damagescanner)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2551015.svg)](https://doi.org/10.5281/zenodo.2551015)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/damagescanner?color=yellow&label=Downloads)](https://pypistats.org/packages/damagescanner)


  A python toolkit for direct damage assessments for natural hazards. Even though the method is initially developed for flood damage assessments, it can calculate damages for any hazard for which you just require a vulnerability curve (i.e. a one-dimensional relation).

  **Please note:** This package is still in development phase. In case of any problems, or if you have any suggestions for improvements, please raise an *issue*.


  This package is (loosely) based on the original DamageScanner, which calculated potential flood damages based on inundation depth and land use using depth-damage curves in the Netherlands. The DamageScanner was originally developed for the 'Netherlands Later' project [(Klijn et al., 2007)](https://www.rivm.nl/bibliotheek/digitaaldepot/WL_rapport_Overstromingsrisicos_Nederland.pdf).  The original land-use classes were based on the Land-Use Scanner in order to evaluate the effect of future land-use change on flood damages.


  [![workflow pypi badge](https://img.shields.io/pypi/v/damagescanner.svg?colorB=blue)](https://pypi.python.org/project/damagescanner/)

  **Requirements:** [NumPy](http://www.numpy.org/), [pandas](https://pandas.pydata.org/), [geopandas](http://geopandas.org/), [matplotlib](https://matplotlib.org/), [rasterio](https://github.com/mapbox/rasterio), [tqdm](https://github.com/tqdm/tqdm),
  [xarray](https://docs.xarray.dev/en/stable/), [pyproj](https://pyproj4.github.io/pyproj/stable/)


  1. Open the python environment in your command prompt or bash in which you want to install this package.
  2. Type ``pip install damagescanner`` and it should install itself into your python environment.
  3. Now you can import the package like any other package!

  OR:

  1. Clone the repository or download the package on your computer and extract the folder.
  2. Go to the DamageScanner folder in your command prompt or bash.
  3. Type ``python setup.py install`` and it should install itself into your python environment.
  4. Now you can import the package like any other package!


  Recommended option is to use a [miniconda](https://conda.io/miniconda.html)
  environment to work in for this project, relying on conda to handle some of the
  trickier library dependencies.

  ```bash


  conda config --add channels conda-forge


  conda env create -f environment.yml
  activate ds_env

  ```


  [![Documentation Status](https://readthedocs.org/projects/damagescanner/badge/?version=latest)](https://damagescanner.readthedocs.io/en/latest/?badge=latest)

  Please refer to the [ReadTheDocs](http://damagescanner.readthedocs.io/) of this project for the full documentation of all functions.


  If you use the **DamageScanner** in your work, please cite the package directly:

  * Koks. E.E. (2022). DamageScanner: Python tool for natural hazard damage assessments. Zenodo. http://doi.org/10.5281/zenodo.2551015

  Here's an example BibTeX entry:

          @misc{damagescannerPython,
                author       = {Koks, E.E.},
                title        = {DamageScanner: Python tool for natural hazard damage assessments},
                year         = 2022,
                doi          = {10.5281/zenodo.2551015},
                url          = {http://doi.org/10.5281/zenodo.2551015}
          }


  Copyright (C) 2022 Elco Koks. All versions released under the [MIT license](LICENSE).


pkgId: 19654b20e3d442af72039d88b8f0aa564a0239bca2c405ec3a52625a7588758e
name: python-dame-cli
arch: src
version: 5.8.0
epoch: 0
release: 1
summary: A execution manager cli for execution
url: https://github.com/mintproject/dame_cli
rpm_license: Apache-2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dame-cli-5.8.0-1.src.rpm
checksum_type: sha256
description:
  [![Upload Python Package](https://github.com/mintproject/dame_cli/actions/workflows/python-publish.yml/badge.svg)](https://github.com/mintproject/dame_cli/actions/workflows/python-publish.yml) [![codecov](https://codecov.io/gh/mintproject/dame_cli/branch/master/graph/badge.svg)](https://codecov.io/gh/mintproject/dame_cli)

  The Desktop Application for Model Execution (DAME) is an application for executing environmental models in any local environment or server through a command line interface.

  DAME contains a registry of model containers and input data files, as well as metadata about what input data needs to be loaded to run regional configurations and setups of any given model.

  Given a model identifier (e.g., TopoFlow for the Awash region: `topoflow36_2.1.0_Awash`), DAME downloads the model container and its execution environment, and fetches the datasets needed (e.g., soil data, elevation data, etc). Then users can run the model with different input scenarios.

  DAME works in Linux, MacOS and Windows.  It is installed through a simple pip command.






  1. Docker
  2. Python >= 3.6




  DAME can use Docker to manage and run containers of software components.

  - [Installation on Linux](https://docs.docker.com/engine/install/)
  - [Installation on MacOS](https://docs.docker.com/docker-for-mac/install/)
  - [Installation on Windows](https://docs.docker.com/docker-for-windows/install/)



  DAME uses Python. To install Python, just follow the steps below:

  - [Installation on Linux](https://realpython.com/installing-python/#linux)
  - [Installation on MacOS](https://realpython.com/installing-python/#macos-mac-os-x)
  - [Installation on Windows](https://realpython.com/installing-python/#windows)




  To install the latest version of DAME, open a terminal and run:

  ```bash
  pip install dame-cli
  ```



  Full documentation of the CLI, including usage examples, can be found at: https://dame-cli.readthedocs.io/en/latest/


pkgId: 5337eab7539219ebfbda2ec43a9e08e5ad62051fc7b5325496585cec8311dc86
name: python-daml
arch: src
version: 0.56.0
epoch: 0
release: 1
url: https://daml.ai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daml-0.56.0-1.src.rpm
checksum_type: sha256
summary:
  DAML provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks

description:
  The Data-Analysis Metrics Library, or DAML, focuses on characterizing image data and its impact on model performance across classification and object-detection tasks.

  <!-- start about -->

  **Model-agnostic metrics that bound real-world performance**
  - relevance/completeness/coverage
  - metafeatures (data complexity)

  **Model-specific metrics that guide model selection and training**
  - dataset sufficiency
  - data/model complexity mismatch

  **Metrics for post-deployment monitoring of data with bounds on model performance to guide retraining**
  - dataset-shift metrics
  - model performance bounds under covariate shift
  - guidance on sampling to assess model error and model retraining

  <!-- end about -->




  - Python 3.9-3.11



  You can install DAML directly from pypi.org using the following command.  The optional dependencies of DAML are `torch`, `tensorflow` and `all`.  Using `torch` enables Sufficiency metrics, and `tensorflow` enables OOD Detection.

  ```
  pip install daml[all]
  ```



  To install DAML from source locally on Ubuntu, you will need `git-lfs` to download larger, binary source files and `poetry` for project dependency management.

  ```
  sudo apt-get install git-lfs
  pip install poetry
  ```

  Pull the source down and change to the DAML project directory.
  ```
  git clone https://github.com/aria-ml/daml.git
  cd daml
  ```



  Install DAML with optional dependencies for development.
  ```
  poetry install --all-extras --with dev
  ```

  Now that DAML is installed, you can run commands in the poetry virtual environment by prefixing shell commands with `poetry run`, or activate the virtual environment directly in the shell.
  ```
  poetry shell
  ```


  For more ideas on getting started using DAML in your workflow, additional information and tutorials are in our Sphinx documentation hosted on [Read the Docs](https://daml.readthedocs.io/).


  This project uses code from the [Alibi-Detect](https://github.com/SeldonIO/alibi-detect) python library developed by SeldonIO.  Additional documentation from the developers are also available [here](https://docs.seldon.io/projects/alibi-detect/en/stable/).


  - **POC**: Scott Swan @scott.swan
  - **DPOC**: Andrew Weng @aweng


pkgId: 3b71eaf3d9271937d8cf18c05f977925fe0d01381092f6da2e9b2c4fb08aed4d
name: python-daml-dit-api
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Daml Hub DIT File API Package
url: https://github.com/digital-asset/daml-dit-api
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daml-dit-api-0.5.0-1.src.rpm
checksum_type: sha256
description:
  API definitions for DIT packages to be hosted in Daml Hub. This mainly
  contains the [type definitions](daml_dit_api/package_metadata.py)
  for the format of the `dabl-meta.yaml` file at the root of each DIT file.
  DIT files are also used to contain integrations loaded and run by Daml
  Hub. This repository also contains documentation (in this `README`)
  describing the runtime environment that Daml Hub provides to
  integrations.

  At their core, DIT files are [ZIP archives](https://en.wikipedia.org/wiki/Zip_(file_format))
  that follow a specific set of conventions regarding their content. The
  most important of these conventions is the presence of a YAML metadata
  file at the root of the archive and named `dabl-meta.yaml`. This
  metadata file contains catalog information describing the contents of
  the DIT, as well as any packaging details needed to successfully
  deploy a DIT file into Daml Hub. An example of a deployment instruction is
  a _subdeployment_. A subdeployment instructs Daml Hub to deploy a specific
  subfile within the DIT file. A DIT file that contains an embedded DAR
  file could use a subdeployment to ensure that the embedded DAR file is
  deployed to the ledger when the DIT is deployed. In this way, a DIT
  file composed of multiple artifacts (DARs, Bots, UI's, etc.) can be
  constructed to deploy a set of artifacts to a single ledger in a
  single action.

  Integrations are a special case of DIT file that are augmented with
  the ability to run as an executable within a Daml Hub cluster. This is
  done by packaging Python [DAZL bot](https://github.com/digital-asset/dazl-client)
  code into an [executable ZIP](https://docs.python.org/3/library/zipapp.html)
  using [PEX](https://github.com/pantsbuild/pex) and augmenting tha
  resulting file with the metadata and other resources needed to make it
  a correctly formed DIT file.
  Logically speaking, Daml Hub integrations are DAZL bots packaged with
  information needed to fit them into the Daml Hub runtime and user
  interface. The major functional contrast between a Daml Hub integration
  and a Python Bot is that the integration has the external network
  access needed to connect to an outside system and the Python Bot does
  not. Due to the security implications of running within Daml Hub with
  external network access, integrations can only be deployed with the
  approval of DA staff.

  The easiest way to develop an integration for Daml Hub is to use the
  [framework library](https://github.com/digital-asset/daml-dit-if)
  and [`ddit` build tool](https://github.com/digital-asset/daml-dit-ddit).
  The integration framework presents a Python API closely related to the
  DAZL bot api and ensures that integrations follow the conventions
  required to integrate into Daml Hub.
  _Unless you know exactly what you are doing and why you are doing it,
  use the framework._

  By convention, integrations accept a number of environment variables
  that specify key paramaters.  Integrations built with the framework
  use defaults for these variables that connect to a default locally
  configured sandbox instance.
  Variables provided by Daml Hub include the following:
  | Variable | Default | Purpose |
  |----------|---------|---------|
  | `DAML_LEDGER_URL` | `http://localhost:6865` | Address of local ledger gRPC API |
  | `DABL_HEALTH_PORT` | 8089 | Port for HTTP endpoint. (Used for both liveness/readiness and webhooks) |
  | `DABL_JWKS_URL` | | HTTP URL for JWKS Repository |
  | `DABL_INTEGRATION_METADATA_PATH` | 'int_args.yaml' | Path to local metadata file |
  | `DABL_INTEGRATION_TYPE_ID` | | Type ID for the specific integration within the DIT to run |
  | `DABL_LEDGER_PARTY` | | Party identifier for network connection |
  | `DABL_LOG_LEVEL` | 0 | Log verbosity level - 0 up to 50, inclusive. |
  (Note that for legacy reasons, the ledger URL is also available under
  the `DABL_LEDGER_URL` environment variable.)

  DABL integrations use the default Python logging package, and the
  framework provides specific support for controlling log level at
  runtime. To integrate properly with this logic, it is important that
  integrations use the `integration` logger. This logger is switched from
  `INFO` level to `DEBUG` level at a `DABL_LOG_LEVEL` setting of 10 or above.
  The preferred way of creating an integration logger is via the
  `getIntegrationLogger` function in the API package.


pkgId: ac633ac16e17cf2ebd2582af8ac7f05343c1c68e2b296d8d8c3214f8cda8f70f
name: python-damm
arch: src
version: 1.0
epoch: 0
release: 1
summary: Computing the Damm check digit
url: https://bitbucket.org/shezi/damm/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-damm-1.0-1.src.rpm
checksum_type: sha256
description:
  Note that check digits are NOT used for verification of data transfers between
  computers -- use a CRC or a hash for that purpose! Check digits are used to
  check *manual* entry of a digit into a computer system.
  A Damm check digit is a single check digit that can detect any
  single-digit error as well as any adjacent-digit transpositions. The digit
  computed in this module also detects some important phonetic errors (13<->30,
  14<->40, ... 19<-->90).
  This makes the Damm check digit better than other, more well-known check digits
  like the Luhn code (used in credit cards) and the ISBN base-11 check digit. It
  is equal in detection strength to a Verhoeff check digit, but much simpler to
  compute.
  Furthermore, a hexadecimal Damm check digit was added. This single hexadecimal
  check digit that detects every single-digit error as well as any adjacent-digit
  transpositions. The digit computed in this module also detects some important
  phonetic errors (13<->30, 14<->40, ... 19<-->90). It also detects all
  jump-transposition errors (abc -> cba), 93.5 % of all twin digit errors (aa ->
  bb) and 93.5 % of all jump twin digit errors (aca -> bcb).
  There are four functions in this module: `encode`, `encode16`, `check` and
  `check16`. The first two, `encode` and `encode16` are used to calculate the
  check digit for a number that you have. Pass in a string with the number you
  want encoded and get a string with the check digit back. The other two, `check`
  and `check16` are used to check that a number that was entered was entered
  correctly. Pass in a string with a number including check digit and get back
  `True`/`False`.


pkgId: 6624a0579f6f6a315d8ff16c7039d99fea30af1c7ad1bf119467b3e3c04e4cff
name: python-damm32
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: A pure-python implementation of the Damm Algorithm in Base 32.
url: https://github.com/pyinv/damm32
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-damm32-1.2.1-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/pyinv/damm32/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/pyinv/damm32/actions/workflows/test.yml)

  Python implementation of the Damm Algorithm in Base 32

  By default, it uses an alphabet as specified in [RFC 4648](https://tools.ietf.org/html/rfc4648) which contains 32 alphanumeric characters, with similar looking characters removed. The padding symbol is not included.



  The package is available on [PyPI](https://pypi.org/project/damm32/) and can be installed using pip: `pip install damm32`

  It is also available on the [Arch User Repository](https://aur.archlinux.org/packages/python-damm32/) as `python-damm32`.

  Alternatively, you can clone the repository and use the module.



  The module contains a single class called `Damm32`, this class implements the methods for the checksum.

  ```
  from damm32 import Damm32

  d32 = Damm32()

  digit = d32.calculate("HELLO")

  d32.verify("HELLO" + digit)

  ```

  You can also pass an list of length 32 to the constructor for the class to specify your alphabet.

  ```
  from damm32 import Damm32

  d32 = Damm32(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '2', '3', '4', '5', '6', '7'])

  ```



  This is an implementation of the [Damm Algorithm](https://en.wikipedia.org/wiki/Damm_algorithm) for use in Base 32 systems.

  It will detect all occurrences of the two most frequently appearing types of transcription errors, namely altering one single digit, and transposing two adjacent digits (including the transposition of the trailing check digit and the preceding digit).

  Since prepending leading zeros does not affect the check digit, variable length codes should not be verified together since, e.g., 0, 01, and 001, etc. produce the same check digit. However, all checksum algorithms are vulnerable to this.

  The implementation uses a bitmask from [Table of Low-Weight Binary Irreducible Polynomials](https://www.hpl.hp.com/techreports/98/HPL-98-135.pdf) to enable calculation of the check digit without constructing the quasigroup.


pkgId: 60afc62287aa67d30756ae7787ae54e417fce6c646e70cd46b90309e5b8536d7
name: python-dammy7878-pixegami-hello
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/dammy7878-pixegami-hello/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dammy7878-pixegami-hello-0.4.0-1.src.rpm
checksum_type: sha256
description:
  To publish your python package to PYPI, you can use the twine tool.



  ```bash

  python setup.py sdist bdist_wheel


  pip install dist/pixegami_hello-0.4-py3-none-any.whl

  export TWINE_USERNAME=__token__
  export TWINE_PASSWORD=pypi-XXXXXXXXX

  twine upload dist/*
  ```


pkgId: b9e3394fe759be4937d4b6497769dbb7780f6a64d49a6c8b65c66b667ab8aeda
name: python-damnit
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: The Data And Metadata iNspection Interactive Thing
url: https://pypi.org/project/damnit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-damnit-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/damnit/badge/?version=latest)](https://damnit.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://codecov.io/gh/European-XFEL/DAMNIT/graph/badge.svg?token=NGwo3ShLNw)](https://codecov.io/gh/European-XFEL/DAMNIT)

  DAMNIT is a tool developed at the European XFEL to help users create an
  automated overview of their experiment. Check out the documentation for more
  information: https://damnit.rtfd.io


pkgId: ced7617469bf59f17df515750f52df95cebcea9b474df67b2a366c972acc7fc0
name: python-damo
arch: src
version: 2.5.2
epoch: 0
release: 1
summary: DAMON user-space tool
url: https://github.com/damonitor/damo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-damo-2.5.2-1.src.rpm
checksum_type: sha256
description:
  `damo` is a user space tool for [DAMON](https://damonitor.github.io).  Using
  this, you can monitor the data access patterns of your system or workloads and
  make data access-aware memory management optimizations.


pkgId: b61e11bc7cdab00702efc9de0ac254a8a4a17bda2926ea2e68701cc13a862a6a
name: python-damoov-admin
arch: src
version: 0.9.6
epoch: 0
release: 1
summary: SDK for Damoov's APIs
url: https://pypi.org/project/damoov-admin/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-damoov-admin-0.9.6-1.src.rpm
checksum_type: sha256
description:
  Install the SDK using pip:
  ```bash
  pip install damoov-admin
  ```

  - **Authentication:** Seamlessly authenticate and manage sessions.
  - **Telematics Data Retrieval:** Fetch driving statistics, safety patterns, performance metrics, and more.
  - **Error Handling:** Handle errors effectively with descriptive messages.
  - **Utility Functions:** Set of helper functions for date and time management.

  [Full Documentation](https://docs.damoov.com/docs/python-sdk)
  1. **Authentication:**
     ```python
      from damoov_admin import statistics, trips, users
      email = ""
      password = ''
      
      data = <module>.DamoovAuth(email=email, password=password)
     ```

  Detailed documentation is available at [Developer Portal](https://docs.damoov.com/docs/python-sdk).

  If you have any feedback or need support, please contact us at [hellp@damoov.com](mailto:hello@damoov.com).


pkgId: 68d379f090035d2110b79666b282a32ba09e6de8a6ab02572dd815b98beaa84e
name: python-damply
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: A Quick Tool For Sorting Dicom Files
url: https://pypi.org/project/damply/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-damply-0.9.0-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/jjjermiah/damply/graph/badge.svg?token=tCcajRIGz9)](https://codecov.io/gh/jjjermiah/damply)
  [![CI-CD](https://github.com/jjjermiah/damply/actions/workflows/main.yaml/badge.svg)](https://github.com/jjjermiah/damply/actions/workflows/main.yaml)
  [![CodeFactor](https://www.codefactor.io/repository/github/jjjermiah/damply/badge)](https://www.codefactor.io/repository/github/jjjermiah/damply)

  [![pixi-badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json&style=flat-square)](https://github.com/prefix-dev/pixi)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&style=flat-square)](https://github.com/pre-commit/pre-commit)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=flat-square)](https://github.com/astral-sh/ruff)
  [![Built with Material for MkDocs](https://img.shields.io/badge/mkdocs--material-gray?logo=materialformkdocs&style=flat-square)](https://github.com/squidfunk/mkdocs-material)

  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/damply)](https://pypi.org/project/damply/)
  [![PyPI - Version](https://img.shields.io/pypi/v/damply)](https://pypi.org/project/damply/)
  [![PyPI - Format](https://img.shields.io/pypi/format/damply)](https://pypi.org/project/damply/)
  [![Downloads](https://static.pepy.tech/badge/damply)](https://pepy.tech/project/damply)




  DaMPly (Data Management Plan) is a Python module designed to streamline the process of managing and packaging directories.

  This tool is particularly useful for archiving project directories while leaving behind a README file to provide context and instructions for future users.



  View a project's `README`, with emphasized fields that follow the Data Management Plan (DMP) guidelines.
  ![img](assets/screenshot.png)

  TODO
  - [ ] README Check: Verifies the presence of a README file in the specified directory.
  - [ ] User Interaction: Prompts the user for necessary information to enhance the archiving process.
  - [ ] Directory Compression: Compresses all files and sub




  This project uses [`pixi`](pixi.sh) for managing the development environment.
  A set of convenient `tasks` are defined in the `pyproject.toml` file to streamline the development process.

  The `build` feature contains the following tasks:

  - `build`: Builds the package.
  - `publish-pypi`: Publishes the package to the main PYPI repository.
  - `publish-test`: Publishes the package to the TEST-PYPI repository.

  For more details, view the [devnotes on pixi + hatch](devnotes/pixi-hatch-build.md).


pkgId: fc609cc5271c317bca0edcec051e8a43bb7f5459a1326d200ee826f62b5f6356
name: python-dandischema
arch: src
version: 0.10.4
epoch: 0
release: 1
summary: Schemata for DANDI archive project
url: http://dandiarchive.org
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dandischema-0.10.4-1.src.rpm
checksum_type: sha256
description:
  `dandi-schema` is a Python library for maintaining and managing DANDI metadata schemata.



  `pip install dandischema`



  Every `Dandiset` and associated asset has a metadata object that can be retrieved using
  the DANDI API. This library helps create and validate DANDI schema-compliant metadata for `Dandisets`
  and assets. It uses [Pydantic](https://github.com/samuelcolvin/pydantic) to implement
  all the metadata classes. Schemas are generated on schema modifications and placed into
  [this repository](https://github.com/dandi/schema/tree/master/releases).

  `dandi-schema` also generates JSON schema definitions and an associated `context.json`
  file for JSON-LD compliance of the metadata models.

  Important files in this repository include:
  - [models.py](./dandischema/models.py) - contains the models
  - [metadata.py](./dandischema/metadata.py) - contains functions for validating, migrating, and aggregating metadata
  - [datacite.py](./dandischema/datacite.py) - converts the `Dandiset` metadata to a Datacite metadata structure

  The generated JSON schemas can be used together with
  [VJSF](https://koumoul-dev.github.io/vuetify-jsonschema-form/latest/) to create a UI
  for `Dandiset` metadata modification as used for Dandiset metadata modification on https://dandiarchive.org.

  Also Pydantic models are used by [DANDI Client/Library](https://github.com/dandi/dandi-cli) to validate
  metadata while submitting data to the archive, and later by the [DANDI Archive](https://github.com/dandi/dandi-archive) itself to ensure
  that all metadata conforms the model before Dandiset is allowed to be published and gain a DOI.
  Such DOI generation is done via Datacite service, and `dandi-schema` library produces Datacite metadata records
  out of the Pydantic models.



  * To learn how to interact with the DANDI archive,
  see [the handbook](https://www.dandiarchive.org/handbook/).
  * To file a feature request or bug report, go to https://github.com/dandi/helpdesk/issues/new/choose.
  * For all other issues, contact the DANDI team: help@dandiarchive.org.


pkgId: f4c5595ebb910cbd5f1d4f422b4186039967556e197354bc999d7f73f51d4dfc
name: python-dandy
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Intelligence Bot Framework
url: https://github.com/stratusadv/dandy
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dandy-0.4.2-1.src.rpm
checksum_type: sha256
description:
  Dandy is a framework for developing programmatic intelligent bots and workflows. It's opinionated, magical, and designed to be incredibly pythonic.

rpm_license:
  Copyright (c) 2024 Stratus Advanced Technologies and Contributors.  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: d41ddc024a05f4f29dc2fd8bedabf4dc5d8d6b48afbd21aa5163f8a746ba8eec
name: python-danecode
arch: src
version: 0.2.11
epoch: 0
release: 1
summary: A simple util to get dane codes by department and municipality
url: https://pypi.org/project/danecode/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-danecode-0.2.11-1.src.rpm
checksum_type: sha256
description:
  ```python

  import danecode



  department = "Santnder"
  municipality = "Riongro"

  municipality_data = danecode.get_data(department, municipality)


  municipality_data = {
      'department': 'Santander',
      'department_code': '68',
      'municipality': 'Rionegro',
      'municipality_code': '68615'
  }

  ```


pkgId: 0fe8d970fb34a6d6a4a1e66c03c27e6b8fc9d53abf267570f94d0fb76f74a081
name: python-dang-sqlfluffer
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: my convenient opinionated wrapper around sqlfluff
url: https://github.com/dannguyen/dang-sqlfluffer
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dang-sqlfluffer-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dang-sqlfluffer.svg)](https://pypi.org/project/dang-sqlfluffer/)
  [![Changelog](https://img.shields.io/github/v/release/dannguyen/dang-sqlfluffer?include_prereleases&label=changelog)](https://github.com/dannguyen/dang-sqlfluffer/releases)
  [![Tests](https://github.com/dannguyen/dang-sqlfluffer/actions/workflows/test.yml/badge.svg)](https://github.com/dannguyen/dang-sqlfluffer/actions/workflows/test.yml)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/dannguyen/dang-sqlfluffer/blob/master/LICENSE)

  my convenient opinionated wrapper around sqlfluff




  Invoke either lint or fix; lint is default.

  ```sh

  $ echo 'select 1 as id, 2 hello, 3 world order by id' | dang-sqlfluff -

  == [stdin] FAIL                                                                                                                      L:   1 | P:   1 | CP01 | Keywords must be upper case.
                         | [capitalisation.keywords]
  L:   1 | P:   1 | LT09 | Select targets should be on a new line unless there is
                         | only one select target. [layout.select_targets]
  L:   1 | P:  10 | CP01 | Keywords must be upper case.
                         | [capitalisation.keywords]
  L:   1 | P:  19 | AL02 | Implicit/explicit aliasing of columns.
                         | [aliasing.column]
  L:   1 | P:  28 | AL02 | Implicit/explicit aliasing of columns.
                         | [aliasing.column]
  L:   1 | P:  34 | CP01 | Keywords must be upper case.
                         | [capitalisation.keywords]
  L:   1 | P:  40 | CP01 | Keywords must be upper case.
                         | [capitalisation.keywords]
  All Finished 📜 🎉!
  ```










  Install this tool using `pip`:
  ```bash
  pip install dang-sqlfluffer
  ```


  For help, run:
  ```bash
  dang-sqlfluff --help
  ```
  You can also use:
  ```bash
  python -m dang_sqlfluffer --help
  ```


  To contribute to this tool, first checkout the code. Then create a new virtual environment:
  ```bash
  cd dang-sqlfluffer
  python -m venv venv
  source venv/bin/activate
  ```
  Now install the dependencies and test dependencies:
  ```bash
  pip install -e '.[test]'
  ```
  To run the tests:
  ```bash
  python -m pytest
  ```




  (notes for foregetful dan)

  ```sh

  python3 -m build
  python3 -m twine upload dist/*
  ```


pkgId: 89503b46a5bccb83eedb4683f0bf3533333dd04e95a9b2bbc4e6abb211ebd094
name: python-dank-mids
arch: src
version: 4.20.100
epoch: 0
release: 1
summary: Multicall batching middleware for asynchronous scripts using web3.py
url: https://github.com/BobTheBuidler/dank_mids
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dank-mids-4.20.100-1.src.rpm
checksum_type: sha256
description:
  Dank Mids is a EVM RPC batching library that helps reduce the number of HTTP requests to a node, saving time and resources. It automatically collects eth_call calls into [multicalls](https://github.com/makerdao/multicall#multicall-) and bundles all RPC calls together in [jsonrpc](https://www.jsonrpc.org/specification#batch) [batch](https://geth.ethereum.org/docs/interacting-with-geth/rpc/batch) calls. tl;dr: its fast as fuck.

  ![image](https://github.com/BobTheBuidler/dank_mids/assets/70677534/3ecb46aa-f33a-41bd-85fb-c6d2433c7154)

  The goal of this tool is to reduce the workload on RPC nodes and allow users to make calls to their preferred node more efficiently. This optimization is especially useful for developers writing scripts that perform large-scale blockchain analysis, as it can save development time and resources.

  ![](https://i.imgur.com/o9FUmAn.jpg)



  To install Dank Mids, use pip:

  `pip install dank-mids`



  The primary function you need to use Dank Mids is `setup_dank_w3_from_sync`. This function takes a sync Web3 instance and wraps it for async use. If using dank_mids with eth-brownie, you can just import the premade dank_web3 object as well

  Example usage of Dank Mids with web3py:

  ```python
  from dank_mids.helpers import setup_dank_w3_from_sync
  dank_web3 = setup_dank_w3_from_sync(w3)

  from dank_mids.helpers import dank_web3


  random_block = await dank_web3.eth.get_block(123)
  ```



  - [Dank Brownie Example Commented Code](./examples/dank_brownie_example.py)



  - COMING SOON: Dank Mids will also work with [ape](https://github.com/ApeWorX/ape).



  [Yearn](https://yearn.finance) big brain [Tonkers Kuma](https://github.com/tonkers-kuma) had this to say:

  ![image](https://user-images.githubusercontent.com/70677534/211255488-e76e641c-a0fe-461c-a4e5-27c45a3fea5b.png)



  You can also set `DANK_MIDS_DEMO_MODE=True` to see a visual representation of the batching in real time on your console.


pkgId: 2159d273e4fce614dbac78e9ce1718e0c546746f18a82efab851569f6ca88c93
name: python-dankware
arch: src
version: 3.6.4
epoch: 0
release: 1
summary: Python package with various features!
url: https://github.com/SirDank/dankware
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dankware-3.6.4-1.src.rpm
checksum_type: sha256
description:
  ```py
  import os
  from dankware import export_registry_keys

  export_path = "D:\\export.reg"
  registry_root = r'HKEY_CURRENT_USER'
  registry_path = r'Software\Google\Chrome\PreferenceMACs'

  export_registry_keys(registry_root, registry_path, recursive=True, export_path=export_path)
  ```
  <img width="500" alt="image" style="border-radius:5%" src="https://user-images.githubusercontent.com/52797753/221345714-f1cdea4a-0c08-4c47-8c95-c64d95d12dec.png">
  <img width="500" alt="image" style="border-radius:5%" src="https://user-images.githubusercontent.com/52797753/221345782-3a5a6ef0-d3b4-48a7-b8f8-c40f210b067d.png"><br>


pkgId: f6658f2b5fefaef2cde099d8d436802e43b78d2ca2940329894bcbb21a026fe9
name: python-danling
arch: src
version: 0.3.11
epoch: 0
release: 1
summary: Scaffold for experienced Machine Learning Researchers
url: https://pypi.org/project/danling/
rpm_license: Unlicense OR AGPL-3.0-or-later OR GPL-2.0-or-later OR BSD-4-Clause OR MIT OR Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-danling-0.3.11-1.src.rpm
checksum_type: sha256
description:
  DanLing (丹灵) is a high-level library to help with running neural networks flexibly and transparently.

  DanLing is meant to be a scaffold for experienced researchers and engineers who know how to define a training loop, but are bored of writing the same boilerplate code, such as DDP, logging, checkpointing, etc., over and over again.

  Therefore, DanLing does not feature complex Runner designs with many pre-defined methods and complicated hooks.
  Instead, the Runner of DanLing just initialise the essential parts for you, and you can do whatever you want, however you want.

  Although many attributes and properties are pre-defined and are expected to be used in DanLing, you have full control over your code.

  DanLing also provides some utilities, such as [`NestedTensor`][danling.NestedTensor], [`LRScheduler`][danling.optim.LRScheduler], [`catch`][danling.utils.catch], etc.



  Install the most recent stable version on pypi:

  ```shell
  pip install danling
  ```

  Install the latest version from source:

  ```shell
  pip install git+https://github.com/ZhiyuanChen/DanLing
  ```

  It works the way it should have worked.



  DanLing is multi-licensed under the following licenses:

  - The Unlicense
  - GNU Affero General Public License v3.0 or later
  - GNU General Public License v2.0 or later
  - BSD 4-Clause "Original" or "Old" License
  - MIT License
  - Apache License 2.0

  You can choose any (one or more) of these licenses if you use this work.

  `SPDX-License-Identifier: Unlicense OR AGPL-3.0-or-later OR GPL-2.0-or-later OR BSD-4-Clause OR MIT OR Apache-2.0`


pkgId: 598d3fb1f021191a43d98929b803e48b721ec8f715b77bae1f388efda6290585
name: python-danpy
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: Helpful functions for python.
url: https://github.com/danhagen/danpy
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-danpy-1.5.1-1.src.rpm
checksum_type: sha256
description:
  Prepared by: Daniel A Hagen
  [![Build Status](https://travis-ci.com/danhagen/danpy.svg?branch=master)](https://travis-ci.com/danhagen/danpy)
  [![PEP8](https://img.shields.io/badge/code%20style-pep8-green.svg)](https://www.python.org/dev/peps/pep-0008/)
  [![Coverage Status](https://coveralls.io/repos/github/danhagen/danpy/badge.svg?branch=master&service=github)](https://coveralls.io/github/danhagen/danpy?branch=master&service=github)


  ```py
  pip install danpy
  ```


  ```bash
  git clone https://github.com/danhagen/danpy.git && cd danpy
  pip install -r requirements.txt
  pip install .
  ```



  This helpful statusbar can be used with `for/while` loops to keep track of how much time has elapsed as well as how much time remains. Simply place inside the loop (after initializing the statusbar -- `dsb` -- with `finalValue`) and `update` with the current timestep (i). A `title` can be added to the statusbar to keep track of individual function/loops and it is recommended that any function that runs a loop uses `arbitrary_function_name.__name__` to automatically assign an appropriate title. The `initialValue` can also be initialized or left at default (0).


  ```py
  from danpy.sb import *
  from time import sleep

  initialValue = 0
  finalValue = 10
  statusbar = dsb(initialValue,finalValue,title='a Loop')
  for i in range(finalValue):
    sleep(0.5)
    statusbar.update(i)
  ```

  It is useful to either `reset` the statusbar instance. However, loops run in succession will automatically reset if the loops are of the same size.

  ```py
  from danpy.sb import *
  from time import sleep

  initialValue = 0
  finalValue = 10
  numberOfOutsideLoops = 3
  statusbar = dsb(initialValue,finalValue,title="Loop-D-Loops")
  for j in range(numberOfOutsideLoops):
    for i in range(finalValue):
      sleep(0.5)
      statusbar.update(i)
  ```
  It is also possible to rename loops when they are run in succession by using the updating `title`.

  ```py
  from danpy.sb import *
  from time import sleep

  initialValue = 0
  finalValue = 10
  statusbar = dsb(initialValue,finalValue,title="a Loop")
  for i in range(finalValue):
    sleep(0.5)
    statusbar.update(i)

  for i in range(finalValue):
    sleep(0.5)
    statusbar.update(i,title="a Different Loop")
  ```

  However, these automatic reset features will only work if the length of each loop is the same *and* they have the same starting value. If you wish to run consecutive loops with *different* starting values or loop lengths, then you can `reset` the statusbar. It should be noted that the automatic reset, although convenient, will initialize the `start_time` after the first iteration of the loop. Therefore it is not the most accurate representation of runtime. We recommend a hard reset between trials or a redefinition of the statusbar before each loop.



  A statusbar can be reset by calling the builtin function `reset` one of two way; `reset()` will return a statusbar with the previously used `initialValue`, `finalValue`, and `title`, or `reset(**kwargs)` can manually reset any of those values (while the others are kept as previously define).

  ```py
  from danpy.sb import *
  from time import sleep

  initialValue = 0
  finalValue = 10
  statusbar = dsb(initialValue,finalValue,title='One Loop')
  for i in range(finalValue):
    sleep(0.5)
    statusbar.update(i)

  aDifferentFinalValue = 1010
  aDifferentInitialValue = 1000
  statusbar.reset(
    initialValue=aDifferentInitialValue,
    finalValue=aDifferentFinalValue,
    title="Another Loop")
  for i in range(aDifferentInitialValue,aDifferentFinalValue):
    sleep(0.5)
    statusbar.update(i)
  ```


  If using a `while` loop, the statusbar will still update, but depending on the nature of the code in the loop, the extrapolation to determine time remaining may be off.

  ```py
  from danpy.sb import *
  from time import sleep

  count = 0
  finalCount = 10
  statusbar = dsb(count,finalCount,title="a while Loop")
  while count<finalCount:
    sleep(0.5)
    statusbar.update(count)
    count+=1
  ```

  Only compatible with while loops that utilize a `count` metric where the loop continues while `count<finalValue`. The "<" ensures that the statusbar terminates at 100%. If you use "<=" then the input to the statusbar will be `statusbar.update(i,finalValue+1,**kwargs)`.


  Included in this package are the functions `is_number` and `save_figures`.


  The function `save_figures` is designed to save all currently open figures (or a prescribed subset of them) to a convenient location for easy storing, viewing, and comparison.
  I find that this works best if you create a "figures/" destination folder first so that your figures automatically get organized in a location other than location of your project's source code.

  In order to save your figures, you must specify the `destination` of the figures (`str`, in this case, "figures/"), the `baseFileName` (`str`, which can be used to further describe the figures), and a dictionary of the parameters (`params`:`dict`) used to create these plots.
  This last argument is a little different and can left blank (i.e., `{}`) if desired, but I find this to be incredibly useful when you need to compare parameters across trials.
  This will also be used to create a `notes.txt` (or `README.md`; see below) file that allows for quick reference of the used parameters. As an example, try:

  ```py
  from danpy.useful_functions import save_figures
  import matplotlib.pyplot as plt
  import numpy as np

  dt = 0.01
  signalAmplitude = 1
  signalFrequency = 0.5 # Hz
  durationOfSignal = 10 # seconds

  params = {
    "Time Step" : dt,
    "Signal Amplitude" : signalAmplitude,
    "Signal Frequency" : signalFrequency,
    "Duration Of Signal" : durationOfSignal
  }

  time = np.arange(0,durationOfSignal+dt,dt)
  signal1 = signalAmplitude*np.sin(2*np.pi*signalFrequency*time)
  signal2 = signalAmplitude*np.cos(2*np.pi*signalFrequency*time)

  fig1 = plt.figure()
  ax1 = plt.gca()
  ax1.plot(time,signal1)
  ax1.set_xlabel("Time (s)")
  ax1.set_ylabel("Signal 1")

  fig2 = plt.figure()
  ax2 = plt.gca()
  ax2.plot(time,signal2)
  ax2.set_xlabel("Time (s)")
  ax2.set_ylabel("Signal 2")

  save_figures(
    "figures/",
    "Signal_figures",
    params
  )

  plt.show()
  ```

  This code will create a subfolder in "figures/" that is time stamped that contains three files (`Signal_figures_01-01.png`,`Signal_figures_01-02.png`, and `notes.txt`). The first two files have the base file name `Signal_figures` followed by the number 01 (which corresponds to the trial number) and then the figure number. This can be useful when you wish to add figures to the _same_ subfolder, when the parameters don't change (but more on that later).

  The notes will appear as such,

  ```
  [Created 2020/01/03 at 09:28.42]





  		NONE





  		Time Step: 0.01
  		Signal Amplitude: 1
  		Signal Frequency: 0.5
  		Duration Of Signal: 10


  ```

  Note that all of the parameters have been listed conveniently as well as the date and time that the file was generated. You can also add your own notes to further categorize your results with the `addNotes` kwarg.

  Additionally, you can set the kwarg `saveAsMD` as `True` (default is `False`) to create a Github-flavored markdown version of this `notes.txt` files, which will be saved as a `README.md` file to allow for seamless viewing.
  If these figures are to be pushed to your project repository, simply navigate to the `figures/` folder and the corresponding subfolder and your results will be automatically presented on the Github subfolder page thanks to the magic of Github-flavored markdown.
  I prefer this option as it will also automatically add HTML figure blocks with all of the figures in the corresponding subfolder. As an example, see the screen grab of the `README.md` file created for the above code when `saveAsMD=True`.

  <p align="center">
  	<img width="500" src="https://user-images.githubusercontent.com/16945786/91619078-f4a73900-e940-11ea-87f4-c61f30ee2c6d.png">
  </p>

  These README files can be edited directly as well to include things like figure captions.

  For either option, if you wish to run an additional trial and have those results saved in the same folder you can specify the `subFolderName` to the previously generated subfolder and (1) the figures will be saved there with the number identifier changed (generally, plus 1) to denote a new trial and (2) the `notes.txt` or `README.md` file will be _appended_ to include the new information.

  To do this, you will also want to recover the path to the previous subfolder. To do this, use the kwarg `returnPath=True` in the first `save_figures` instance which will return the `Path` (from `pathlib` package) of the folder, which we will designate as `figPath`.
  Then use the kwarg `subFolderName=figPath.stem`.

  ```py
  from danpy.useful_functions import save_figures
  import matplotlib.pyplot as plt
  import numpy as np

  dt = 0.01
  signalAmplitude = 1
  signalFrequency = 0.5 # Hz
  durationOfSignal = 10 # seconds

  params = {
    "Time Step" : dt,
    "Signal Amplitude" : signalAmplitude,
    "Signal Frequency" : signalFrequency,
    "Duration Of Signal" : durationOfSignal
  }

  time = np.arange(0,durationOfSignal+dt,dt)
  signal1 = signalAmplitude*np.sin(2*np.pi*signalFrequency*time)
  signal2 = signalAmplitude*np.cos(2*np.pi*signalFrequency*time)

  fig1 = plt.figure()
  ax1 = plt.gca()
  ax1.plot(time,signal1)
  ax1.set_xlabel("Time (s)")
  ax1.set_ylabel("Signal 1")

  fig2 = plt.figure()
  ax2 = plt.gca()
  ax2.plot(time,signal2)
  ax2.set_xlabel("Time (s)")
  ax2.set_ylabel("Signal 2")


  figPath = save_figures(
    "figures/",
    "Signal_figures",
    params,
    returnPath=True
  )

  plt.close('all')

  fig3 = plt.figure()
  ax1 = plt.gca()
  ax1.plot(time,signal1+signal2)
  ax1.set_xlabel("Time (s)")
  ax1.set_ylabel("Signal 1 + Signal 2")

  fig4 = plt.figure()
  ax2 = plt.gca()
  ax2.plot(time,signal1-signal2)
  ax2.set_xlabel("Time (s)")
  ax2.set_ylabel("Signal 1 - Signal 2")


  save_figures(
    "figures/",
    "Signal_figures",
    params,
    subFolderName=figPath.stem
  )

  plt.show()
  ```


  There are multiple ways to adjust the behavior of this function with `kwargs`. Specifically,

    * `fileType` (default is "png") - You can change the file extension to any of the following: "eps", "pdf", "pgf", "png", "ps", "raw", "rgba", "svg", "svgz". Note that saving them as "pdf" will save each figure individually, where the `kwargs` `saveAsPDF` will combine them into a single file.
    * `subFolderName` (default is the time stamped folder name) - Sometimes it is more convenient to name the subfolder yourself **or** to send files to a previously defined location. In this case, just specify the `subFolderName` and it will send the figures there. Note that this should only be done for trials where the parameters *do not change* as the `notes.txt` files is only generated when the subfolder is created.
    * `addNotes` (default `None`) - This will allow for notes to be added to the `notes.txt` or `README.md` files directly from the function call. Must be a `str`.
    * `saveAsMD` (default `False`) - If true, the notes will be saved in Github-flavored markdown which includes figure displays in addition to notes and parameters. This can be viewed directly from the figure folder once uploaded to your projects repository or locally with a markdown previewer (like Atom).
    * `saveAsPDF` (default `False`) - If true, in addition to saving the figures as the specified filetype, a single PDF will be constructed to include all figures generated.
    * `returnPath` (default `False`) - If you intend on saving additional figures to the folder location, this option allows you to return the path of the subfolder. Use this for the first trial and the `subFolderName` argument for any additional trials to send new figures to the same location. Note that this returns a `Path` item from the `pathlib` package, which means that the subfolder name can be recovered by the command `<figure subfolder path>.stem`
    * `figs` (default will save every figure open) - You can alternatively specify the specific figures that you wish to save. This should be a list of figures.



  This class creates a timer that allows you to keep track of how long loops take to run. This can be particularly helpful if you are running many large loops with irregular run times and you want to keep track of how long your code has been running.

  To use this class, simply instantiate it with `myTimer = timer()` and then print updates after each loop with a variety of commands depending on what you are doing.

  As an example consider the code snippet below

  ```py
  from danpy.useful_functions import timer
  import time

  myTimer = timer()

  myTimer.start()
  for i in range(5):
      print("Trial " + str(i+1) + "\n")
      time.sleep(5)
      myTimer.loop()
  ```

  Which prints the following output.

  ```console
  Trial 1

  Total Run Time: 00:00:05 (00:00:05)

  Trial 2

  Total Run Time: 00:00:10 (00:00:05)

  Trial 3

  Total Run Time: 00:00:15 (00:00:05)

  Trial 4

  Total Run Time: 00:00:20 (00:00:05)

  Trial 5

  Total Run Time: 00:00:25 (00:00:05)
  ```

  Alternatively, you can choose to only print the total run time of your code by starting the timer at the beginning and then ending it at the bottom of your code with the command `myTimer.end()`, which will print the total run time as well. If this is the case, you can select the arg `--single_trial` when the timer is initialized and the displays will adjust to only display the total run time (i.e., `myTimer = timer('--single_trial')`). Note, however, that you cannot use the `loop` function in single trial mode.

  If instead you wish to display or save the run time, the output of these functions can be suppressed by the kwarg `verbose=0`. The value of the `totalRunTime` can then be recovered as an attribute of the timer (i.e., `myTimer.totalRunTime`). Similarly, the trial run time can always be recovered by the attribute `trialRunTime`. And lastly, the formated `str` version of these values can be recovered by the attributes `totalRunTimeStr` and `trailRunTimeStr`, respectively.

  You can always reset your timer with the function `reset` as well, in case you ever needed to run back to back timers (but be sure to use `--single_trial` again if you want to continue using that option).

  ```py
  from danpy.useful_functions import timer
  import time

  myTimer = timer()

  print("First Timer\n")
  myTimer.start()
  for i in range(5):
      print("Trial " + str(i+1) + "\n")
      time.sleep(5)
      myTimer.loop()

  print("Second Timer\n")
  myTimer.reset()
  for i in range(5):
      print("Trial " + str(i+1) + "\n")
      time.sleep(5)
      myTimer.loop()
  ```


  In order to quickly test if a variable is a number (and not a `str` or `bool`), simply type `is_number(variable,variableName)` as such:

  ```py
  from danpy.useful_function import is_number

  myVariable = 3.1415926536
  is_number(myVariable,"myVariable")
  ```

  This will not raise an AssertionError as `myVariable` is a number. To make the debugging easier to locate, the additional arguments `default` and `notes` have been added.

  ```py
  from danpy.useful_functions import is_number

  myVariable = "Not a number"
  defaultValue = 3.1415926536
  notes = "This is where I would put notes pertaining to the variable like relative magnitude, units, etc."

  is_number(myVariable,"myVariable",
  default=defaultValue,
  notes=notes
  )
  ```

  which will raise the `AssertionError`:

  ```console
  AssertionError: myVariable must be an int, float, float32, float64, or numpy.float not <class 'str'>. Default is 3.1415926536. This is where I would put notes pertaining to the variable like relative magnitude, units, etc.
  ```


pkgId: 28bddbe2bf3695375eafdbb7724b3e2e0b17e741b77acba3600e2d1938b2b8b6
name: python-dante
arch: src
version: 2.0.7
epoch: 0
release: 1
summary: Python dependency management utility
url: https://github.com/sbg/dante
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dante-2.0.7-1.src.rpm
checksum_type: sha256
description:
  [![Travis](https://api.travis-ci.com/sbg/dante.svg)](https://travis-ci.com/sbg/dante)
  [![PyPI version](https://badge.fury.io/py/dante.svg)](https://badge.fury.io/py/dante)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/sbg/dante/blob/master/LICENSE)
  [![Downloads](https://pepy.tech/badge/dante)](https://pepy.tech/project/dante)

  Dante is a dependency management and validation tool for python projects.



  Dante was written to simplify dependency management in python by using lock
  files to keep consistent environments for both development and deployment. It
  does not manage installation of environments and packages but focuses on
  validation.

  Dante will help you keep track of dependencies with just a few simple commands.
  Unlike some other tools, it is not as opinionated, and is highly configurable.
  While it uses standard requirements files, a parser can be written for any
  other file type.



  Files to use:

  - **requirements.txt** for used project packages
  - **requirements.lock** for deployment packages
  - **requirements-dev.txt** for used development packages
  - **requirements-dev.lock** for all test environment packages

  Lock files enforce exact versions for all packages.
  When deploying and preparing the environment only install from lock files.



  Dante can be found on PyPI and can simply be installed with:

      pip install dante

  Since version 2, it no longer installs it's own dependencies, but instead
  vendors them to avoid possible false positives.



  Dante has a default configuration which can be overridden using a standard
  `setup.cfg` file. Configurable properties are as follows:


  |Property|Description|
  |---|---|
  |**checks**|Checks to run when calling the `check` command. Defaults are `conflicts`, `cyclic`, `missing`, `validate`.|
  |**ignore_list**|List of package keys to ignore. Defaults are `dante`, `pip`, `setuptools`, and `wheel`.|
  |**allow_named_versions**|Whether to allow custom named versions (invalid by default) for packages. Default is `false`.|
  |**named_version_patterns**|List of regex patterns that will determine named versions. Default is empty.|
  |**requirements_files**|List of requirement files used in the project. Defaults to `requirements.txt`.|
  |**lock_files**|List of lock files used in the project. Defaults to `requirements.lock`.|
  |**lock_file_path**|Path of the lock file that will be generated with `dante lock --save`.|
  |**parser**|Parser to use to read/write requirements/lock files. Currently only the default is supported.|
  |**any_version**|Undefined version name. Default is `Any`.|
  |**graph_name**|Name of the graph that will be created. Defaults to `dante-graph`.|
  |**graph_filename**|Filename of the graph that will be created. Defaults to `dante-graph.pdf` in the working directory.|
  |**graph_format**|Format of the graph that will be created. Defaults to `pdf`. Supports all graphviz formats.|
  |**graph_engine**|Engine of the graph that will be created. Defaults to `dot`. Supports all graphviz engines.|
  |**graph_attributes**|Custom graph attributes. Supports all graphviz attributes.|
  |**graph_strict**|Whether the graphviz graph follows strict rules. Defaults to `True`.|
  |**graph_node_attributes**|Custom graph node attributes. Defaults to setting `shape` to `box3d`. Supports all graphviz node attributes.|
  |**graph_edge_attributes**|Custom graph edge attributes. Defaults to setting `fontsize` to `10`. Supports all graphviz edge attributes.|






  |Command|Description|
  |---|---|
  |**list**|List all dependencies
  |**tree**|Show dependency tree
  |**config**|Print configuration
  |**validate**|Validate requirements and lock files
  |**conflicts**|Check for conflicts in required dependencies
  |**cyclic**|Check for cyclic dependencies
  |**missing**|Show missing dependencies
  |**check**|Run a complete list of checks
  |**lock**|Display or generate lock file from environment and/or requirements file(s)
  |**graph**|Export a dependency graph using graphviz


  Note: Almost all command flags have shorthands that are equivalent to the first
  letter of their name. They can be displayed with the help command.



  The version flag will get dante to display it's installed version end exit:

      dante --version



  Dante has several flags on the CLI's top level:

  - `--all` - Shows all packages (Does not use the ignore list)
  - `--ignore IGNORE` - Ignore specified package. Can be used multiple times.



  Lists all packages relevant to the project:

      dante list [--requirements REQUIREMENTS]

  Flag|Shorthand|Description
  |---|---|---|
  |**--requirements**|**-r**|Requirements file to use (will ignore `setup.cfg`)|

  Unlike `pip freeze` unless it's used with the `--all` flag dante will only
  display packages that are required for the project. This is determined by using
  installed packages and requirements files.



  Displays a dependency tree for a single package or the entire environment:

      dante tree [--package PACKAGE] [--requirements REQUIREMENTS]

  Flag|Shorthand|Description
  |---|---|---|
  |**--package**|**-p**|Package to display the tree for|
  |**--requirements**|**-r**|Requirements file to use (will ignore `setup.cfg`)|



  Displays the current configuration in JSON format:

      dante config

  Example result:
  ~~~json
  {
      "dante": {
          "any_version": "Any",
          "checks": [
              "conflicts",
              "cyclic",
              "missing",
              "validate"
          ],
          "ignore_list": [
              "dante",
              "pip",
              "setuptools",
              "wheel"
          ],
          "allow_named_versions": true,
          "named_version_patterns": [
              "0.*version"
          ],
          "lock_file_path": "requirements-dev.lock",
          "requirements_files": [
              "requirements-dev.lock"
          ],
          "lock_files": [
              "requirements-dev.lock"
          ],
          "graph_name": "dante-graph",
          "graph_filename": null,
          "graph_format": "pdf",
          "graph_engine": "dot",
          "graph_strict": true
      },
      "graph_attributes": {},
      "graph_node_attributes": {
          "shape": "box3d"
      },
      "graph_edge_attributes": {
          "fontsize": "10"
      }
  }
  ~~~



  Performs various checks on requirements and lock files:

      dante validate [-requirments REQUIREMENTS] [--lock LOCK] [--strict]

  Flag|Shorthand|Description
  |---|---|---|
  |**--requirements**|**-r**|Requirements file to use (will ignore `setup.cfg`)|
  |**--lock**|**-l**|Lock file to use (will ignore `setup.cfg`)|
  |**--strict**|**-r**|Run strict checks|

  The checks performed are as follows:
  - Check if all set requirements are set to a version or a version range
  - Check if all locked requirements are set to an exact version
  - Check if all installed package versions match the locked requirement versions
  - Check if all required versions match the locked requirement versions

  Successful run will print out:

      All set requirements locked
      No unset locks found
      All package versions matching
      All requirement versions matching

  Running validation with the `--strict` flag will add some additional checks:

  - Check if there are installed packages that are not required by anything
  - Check if there are locked requirements that are not required by anything

  It is recommended to use the strict check whenever it's possible.

  Successful run will print out:

      No non-required packages found
      No non-required locks found



  Detects conflicts between installed packages:

      dante conflicts

  Conflicts can occur when multiple packages require the same package with
  incompatible versions (e.g. one requires <1.0.0 and the other >2.0.0).
  Successful run will print out:

      No conflicts found



  Detects cyclical dependencies in installed packages:

      dante cyclic

  This can occur when there is a cyclical path in package dependencies (e.g.
  `package1` requires `package2` which requires `package3`, which in turn
  requires `package1`). Successful run will print out:

      No cyclic dependencies found



  Detects if there are required packages that are not installed in the environment:

      dante missing [--requirements REQUIREMENTS]

  Flag|Shorthand|Description
  |---|---|---|
  |**--requirements**|-r|Requirements file to use (will ignore `setup.cfg`)|


  Successful run will print out:

      No missing dependencies found



  Runs all defined checks at once:

      dante check [--requirements REQUIREMENTS] [--lock LOCK] [--strict]

  Flag|Shorthand|Description
  |---|---|---|
  |**--requirements**|**-r**|Requirements file to use (will ignore `setup.cfg`)|
  |**--lock**|**-l**|Lock file to use (will ignore `setup.cfg`)|
  |**--strict**|**-r**|Run strict checks|


  Successful run with all checks will print out:

      All set requirements locked
      No unset locks found
      All package versions matching
      All requirement versions matching
      No non-required packages found
      No non-required locks found
      No conflicts found
      No cyclic dependencies found
      No missing dependencies found



  Displays or saves locked requirements for the current project:

      dante lock [--requirements REQUIREMENTS] [--save] [--file FILE]

  Flag|Shorthand|Description
  |---|---|---|
  |**--requirements**|**-r**|Requirements file to use (will ignore `setup.cfg`)|
  |**--save**|**-s**|Save to file|
  |**--file**|**-f**|Filename to save to (will override `setup.cfg`)|

  Locked requirements are determined by walking through all installed packages
  and provided requirements recursively retrieving their dependencies.

  Only the requirements that are needed for the project will be returned.



  Returns a dependency graph description or renders it to a file:

      dante graph [--strict] [--render] [--view] [--name NAME] [--filename FILENAME]
                         [--format FORMAT] [--engine ENGINE]
                         [--graph_attr GRAPH_ATTR] [--node_attr NODE_ATTR]
                         [--edge_attr EDGE_ATTR]

  Flag|Shorthand|Description
  |---|---|---|
  |**--render**|**-r**|Render graph to file|
  |**--view**|**-v**|Display graph after rendering|
  |**--strict**|**-s**|Use strict graph rules|
  |**--name**| |Graph name|
  |**--filename**| |Filename to save graph to|
  |**--format**| |Graph file format|
  |**--engine**| |Graph engine|
  |**--graph_attr**| |Graph attributes|
  |**--node_attr**| |Graph node attributes|
  |**--edge_attr**| |Graph edge attributes|



  Dante exposes it's operations through the api module, so they can be imported
  and used in your libraries/applications:

  Example for retrieving installed packages:
  ~~~python
  from dante.api import dependency_list
  installed_packages = dependency_list()
  ~~~



  Dante can be used as a CI checking tool, with proper configuration in
  `setup.cfg` configured, all it takes to run a check on any CI is:

      dante check

  Dante includes error codes when run through the CLI, so it will fail the build
  if any problems are detected.

  Note: It's recommended to use the strict check whenever it's possible, since
  unnecessary requirements can still cause problems in the environments
  (e.g. can overwrite other package's files...):

      dante check --strict



  To run tests simply install all dependencies from `requirements-dev.lock` and run:
  ~~~
  pytest --cov-config setup.cfg
  ~~~




  - Full documentation


pkgId: 601ae431ea8fd300aa1462f332d813defe574f0269411c90765574751cc736d5
name: python-dante-corpora
arch: src
version: 2.0.5
epoch: 0
release: 1
summary: Pacote Python contendo os corpora do projeto DANTE do POeTiSA
url: https://pypi.org/project/dante-corpora/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dante-corpora-2.0.5-1.src.rpm
checksum_type: sha256
description:
  <a name="readme-top"></a>

  <div align="center">

  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]

  </div>

  <br />
  <div align="center">
    <a href="https://github.com/DANTE-POeTiSA/dante-corpora">
      <img src="https://github.com/DANTE-POeTiSA/dante-corpora/blob/main/images/dante.png?raw=true" alt="Logo"  height="100" style="border-radius:50%">
    </a>

  <h3 align="center">DANTE Corpora</h3>

    <p align="center">
      Pacote Python contendo os corpora do projeto DANTE do POeTiSA
      <br />
      <br />
      <a href="https://github.com/DANTE-POeTiSA/dante-corpora/issues">Report Bug</a>
      -
      <a href="https://github.com/DANTE-POeTiSA/dante-corpora/issues">Request Feature</a>
    </p>
  </div>

  <br />



  ```
  pip install dante-corpora
  ```

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



  Esta biblioteca contempla os seguintes corpora:

  1. DANTEStocks: Corpus de tweets que usam termos do mercado financeiro. Esse corpus foi segmentado em 3 Pandas DataFrame:
      - base: Conteudo dos tweets;
      - emotion: Camada de anotacao dos tweets;
      - pos: Camada de anotacao Morfossintatica (Part of Speech).

  2. DANTEShots: Corpus de tweets de pessoas politicas sobre a vacinacao contra a COVID-19. Esse corpus foi segmentado em 3 Pandas DataFrame:
      - base: Conteudo dos tweets;
      - stance: Camada de anotacao de posicionamento;
      - pos: Camada de anotacao Morfossintatica (Part of Speech).


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




  ```python

  from dante.corpora import Dante


  stocks = Dante('dantestocks')


  base = stocks.get_data('base')
  emotion = stocks.get_data('emotion')
  pos = stocks.get_data('pos')


  print(base.head())
  ```


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



  Contribuicoes sao bem-vindas! Sinta-se a vontade para propor melhorias, relatar problemas ou abrir pull requests.

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



  Este projeto e licenciado sob a [Licenca MIT](LICENSE).

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

  [contributors-shield]: https://img.shields.io/github/contributors/DANTE-POeTiSA/dante-corpora.svg?style=for-the-badge
  [contributors-url]: https://github.com/DANTE-POeTiSA/dante-corpora/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/DANTE-POeTiSA/dante-corpora.svg?style=for-the-badge
  [forks-url]: https://github.com/DANTE-POeTiSA/dante-corpora/network/members
  [stars-shield]: https://img.shields.io/github/stars/DANTE-POeTiSA/dante-corpora.svg?style=for-the-badge
  [stars-url]: https://github.com/DANTE-POeTiSA/dante-corpora/stargazers
  [issues-shield]: https://img.shields.io/github/issues/DANTE-POeTiSA/dante-corpora.svg?style=for-the-badge
  [issues-url]: https://github.com/DANTE-POeTiSA/dante-corpora/issues
  [license-shield]: https://img.shields.io/github/license/DANTE-POeTiSA/dante-corpora.svg?style=for-the-badge
  [license-url]: https://github.com/DANTE-POeTiSA/dante-corpora/blob/master/LICENSE.txt


pkgId: 7d1e656a0acd363c02a34e4908793ba037c877ed889a6f9200cd16a317a58cff
name: python-dante-db
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Dante, a document store for Python backed by SQLite
url: https://pypi.org/project/dante-db/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dante-db-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/senko/dante/actions/workflows/ci.yml/badge.svg)](https://github.com/senko/dante/actions/workflows/ci.yml)
  [![Coverage](https://coveralls.io/repos/github/senko/dante/badge.svg?branch=main)](https://coveralls.io/github/senko/dante?branch=main)
  [![PyPI](https://img.shields.io/pypi/v/dante-db)](https://pypi.org/project/dante-db/)

  Dante is zero-setup, easy to use document store (NoSQL database) for Python.
  It's ideal for exploratory programming, prototyping, internal tools and
  small, simple projects.

  Dante can store Python dictionaries or Pydantic models, supports both
  sync and async mode, and is based on SQLite.

  Dante *does not* support SQL, relations, ACID, aggregation, replication and is
  emphatically not web-scale. If you need those features, you should choose
  another database or ORM engine.

  * [Quickstart](#quickstart)
  * [API Reference](docs/api.md)
  * [Examples](#examples)



  1. Install via PyPI:

      ```shell
      pip install dante-db
      ```

  2. Use it with Python dictionaries ([example](examples/hello.py)):

      ```python
      from dante import Dante

      
      
      db = Dante("mydatabase.db")

      
      collection = db["mycollection"]

      
      data = {"name": "Dante", "text": "Hello World!"}
      collection.insert(data)

      
      result = collection.find_one(name="Dante")
      print(result["text"])

      new_data = {"name": "Virgil", "text": "Hello World!"}
      collection.update(new_data, name="Dante")
      ```

  Under the hood, Dante stores each dictionary in a JSON-encoded TEXT column
  in a table (one per collection) in the SQLite database.



  Dante works great with Pydantic.

  Using the same API as with the plain Python objects, you can insert,
  query and delete Pydantic models ([example](examples/hello-pydantic.py)):

  ```python
  from dante import Dante
  from pydantic import BaseModel

  class Message(BaseModel):
      name: str
      text: str


  db = Dante("mydatabase.db")
  collection = db[Message]


  obj = Message(name="Dante", text="Hello world!")
  collection.insert(obj)


  result = collection.find_one(name="Dante")
  print(result.text)



  result.name = "Virgil"
  collection.update(result, name="Dante")
  ```



  Dante supports async usage with the identical API, both for plain Python
  objects and Pydantic models ([example](examples/hello-async.py)):

  ```python
  from asyncio import run
  from dante import AsyncDante

  async def main():
      db = AsyncDante("mydatabase.db")
      collection = await db["mycollection"]

      data = {"name": "Dante", "text": "Hello World!"}
      await collection.insert(data)

      result = await collection.find_one(name="Dante")
      print(result["text"])

      new_data = {"name": "Virgil", "text": "Hello World!"}
      await collection.update(new_data, name="Dante")

      await db.close()

  run(main())
  ```



  Check out the command-line [ToDo app](examples/todo.py),
  a simple [FastAPI CRUD app](examples/fastapi-example.py),
  and the other examples in the [examples](examples/) directory.



  Detailed guide on how to develop, test and publish Dante is available in the
  [Developer documentation](docs/development.md).




  Copyright (c) 2024. Senko Rasic

  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: d6fd9e3752d17d9b86599f314d777d70e4ead3ad9fabafc0115fd85143e9a86c
name: python-dao-analyzer
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: "A tool to monitor DAO activity"
url: https://dao-analyzer.science
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dao-analyzer-1.3.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="./dao_analyzer/web/assets/github_logo.png"
          height="130">
  </p>
  <p align="center">
      <a href="https://pypi.org/project/dao-analyzer/">
          <img src="https://img.shields.io/pypi/v/dao-analyzer" alt="PyPI">
      </a>
      <a href="https://doi.org/10.5281/zenodo.7669689">
          <img src="https://zenodo.org/badge/DOI/10.5281/zenodo.7669689.svg" alt="DOI 10.5281/zenodo.7669689.svg">
      </a>
      <img src="https://img.shields.io/github/license/grasia/dao-analyzer" alt="License">
  </p>


  It is a tool to visualize DAO metrics. Currently, it shows DAO from [DAOstack](https://daostack.io/), [DAOhaus](https://daohaus.club/), and [Aragon](https://aragon.org/). Web site: [http://dao-analyzer.science/](http://dao-analyzer.science/)


  - [Set-up \& Running (Download app)](#set-up--running-download-app)
    - [How to run it?](#how-to-run-it)
    - [Environment variables](#environment-variables)
  - [Build application](#build-application)
  - [Using Docker ](#using-docker-)
  - [Technical details](#technical-details)
    - [Architecture](#architecture)
    - [Debugging](#debugging)
    - [How to test it?](#how-to-test-it)
      - [Flags for hypothesis testing](#flags-for-hypothesis-testing)
  - [Deploy](#deploy)
    - [Matomo integration](#matomo-integration)
  - [Data](#data)
  - [Publications](#publications)
  - [Acknowledgements](#acknowledgements)
  - [Cite as](#cite-as)



  You can either install it on your local machine, or if you prefer it, you can use the official docker image.

  > If you only want to retrieve the data used by our application, go to [grasia/dao-scripts](https://github.com/Grasia/dao-scripts) instead

  The easiest method by far to download and run the application is to use pip to install it

  ```
  pip install dao-analyzer
  ```

  Then, you can run the app using the commands `daoa-cache-scripts` and `daoa-server`


  Before launching the app, you have to run the following script in order to enable the cache stored in `datawarehouse`:

  ```
  dao-scripts
  ```

  After a few minutes, you can now run the app with:

  ```
  daoa-server
  ```

  Now, visit `http://127.0.0.1:8050` or the address given in the program output with your web browser.


  To be able to access all the features of dao-analyzer, you can specify the following
  environment variables:

  ```

  DAOA_CC_API_KEY = "your_api_key"


  DAOA_DW_PATH = './datawarehouse' # <-- Default value
  ```


  Enter in your terminal (git must be installed) and write down:

  `git clone https://github.com/Grasia/dao-analyzer`

  After that, move to repository root directory with:

  ```
  cd dao-analyzer
  ```

  Build the `dao_analyzer_components` (not necessary if you only want to get the data, but not to display it)

  ```
  cd dao_analyzer_components && npm ci && npm build
  ```

  Then, go back to the root folder of the project, and install the package

  ```
  pip install -e .
  ```

  If you don't want to share Python dependencies among other projects, you should use a virtual environment, such as [virtualenv](https://docs.python-guide.org/dev/virtualenvs/).


  If you use Docker, you can just use the images at [ghcri.io/grasia/dao-analyzer](https://github.com/Grasia/dao-analyzer/pkgs/container/dao-analyzer). The tags with the `-cached` suffix have a pre-populated data warehouse (this means the image uses more space, but takes less time to load). To use it, just run the command:

  ```
  docker run --name dao-analyzer -it -p80:80 ghcr.io/grasia/dao-analyzer:latest
  ```

  or

  ```
  docker run --name dao-analyzer -it -p80:80 ghcr.io/grasia/dao-analyzer:latest-cached
  ```

  > `dao-analyzer` is the container name, you can put whatever you want, but remember
  > to change it also on the following command

  Now, you can update the datawarehouse using:

  ```
  docker exec -it dao-analyzer dao-scripts
  ```

  You can even add it to your system as a cron job to update it daily, weekly, etc...




  There is available a class diagram of the [DAOstack app](https://github.com/Grasia/dao-analyzer/blob/master/dao_analyzer/apps/daostack/class_diagram.png), the [DAOhaus app](https://github.com/Grasia/dao-analyzer/blob/master/dao_analyzer/apps/daohaus/class_diagram.png), and the [Aragon app](https://github.com/Grasia/dao-analyzer/blob/master/dao_analyzer/apps/aragon/class_diagram.png).



  This app uses `flask`, so you can use the `FLASK_ENV` variable, which also enables debug mode (among other things) when set to `development`.

  ```
  export FLASK_ENV=development
  ```


  Run all tests with:

  `tox`

  or

  `python3 -m pytest test/`


  Use this flag `--hypothesis-show-statistics` to show statistics.

  Use the flag `--hypothesis-seed=<int>` to set a fixed seed, it's useful to reproduce a failure.




  In order to fully deploy the app, use the `deploy.sh` script, which installs all the Python dependencies, updates the datawarehouse, and runs the web-app with gunicorn, using the `gunicorn_config.py` file.


  To enable Matomo integration, you just have to pass the following environment variables like this:
  ```bash
  DAOA_MATOMO_URL = "https://matomo.example.com"
  DAOA_MATOMO_SITE_ID = 1
  ```

  You can check if the integration is working visiting the page and then your dashboard. The integration uses Javascript, so if there are any errors, you should be able to see them using "Inspect view" in your browser.



  The data is updated daily and published in [Kaggle](https://www.kaggle.com/datasets/daviddavo/dao-analyzer) and [Zenodo](https://zenodo.org/doi/10.5281/zenodo.7669709)




  * Javier Arroyo, David Davó, Elena Martínez-Vicente, Youssef Faqir-Rhazoui, and Samer Hassan (2022). "DAO-Analyzer: Exploring Activity and Participation in Blockchain Organizations.". Companion Publication of the 2022 Conference on Computer Supported Cooperative Work and Social Computing (CSCW'22 Companion). ACM, 193–196.
      * [Freely available here](https://doi.org/10.1145/3500868.3559707)

  * Youssef Faqir-Rhazoui, Javier Arroyo and Samer Hassan (2021). "A comparative analysis of the platforms for decentralized autonomous organizations in the Ethereum blockchain." Journal of Internet Services and Applications volume 12, Article number: 9.
      * [Freely available here](https://jisajournal.springeropen.com/articles/10.1186/s13174-021-00139-6).

  * Youssef Faqir-Rhazoui, Miller Janny Ariza-Garzón, Javier Arroyo and Samer Hassan (2021). "Effect of the Gas Price Surges on User Activity in the DAOs of the Ethereum Blockchain." Extended Abstracts of the 2021 CHI Conference on Human Factors in Computing Systems, Article No.: 407, Pages 1–7.
      * [Freely available here](https://dl.acm.org/doi/pdf/10.1145/3411763.3451755?casa_token=cU40LWnMO0EAAAAA:608tLS07Ya0KuhrBXihSSCRqMV72jDOu0XfP3jXnH64z4c2glcY43w69feOikee4t2oxoQ4doxAFjg).

  * Youssef Faqir-Rhazoui, Javier Arroyo, and Samer Hassan (2021). "A Scalable Voting System: Validation of Holographic Consensus in DAOstack." Proceedings of the 54th Hawaii International Conference on System Sciences, 5557-5566.
      * [Freely available here](https://scholarspace.manoa.hawaii.edu/bitstream/10125/71296/0543.pdf).

  * Youssef Faqir-Rhazoui, Javier Arroyo, and Samer Hassan. (2020). An overview of Decentralized Autonomous Organizations on the blockchain. Proceedings of the 16th International Symposium on Open Collaboration (Opensym 2020) 11:1-11:8. ACM.
      * [Freely available here](https://opensym.org/wp-content/uploads/2020/08/os20-paper-a11-el-faqir.pdf).



  <div align="center">
  <img src="https://github.com/Grasia/dao-analyzer/blob/master/dao_analyzer/web/assets/logo-ministerio.png?raw=true"
       alt="Logo Ministerio de Ciencia e Innovación. Gobierno de España"
       style="max-height: 3em"
  ><img src="https://github.com/Grasia/dao-analyzer/blob/master/dao_analyzer/web/assets/logo-erc.png?raw=true"
       alt="Logotipo European Research Council"
       style="max-height: 3em"
  ><img src="https://github.com/Grasia/dao-analyzer/blob/master/dao_analyzer/web/assets/logo-grasia.png?raw=true"
       alt="Logo GRASIA UCM"
       style="max-height: 3em"
  ><img src="https://github.com/Grasia/dao-analyzer/blob/master/dao_analyzer/web/assets/logo-ucm.png?raw=true"
       alt="Logo Universidad Complutense de Madrid"
       style="max-height: 3em"
  >
  </div>

  DAO-Analyzer is created under the umbrella of multiple research projects:
  - Chain Community, funded by the Spanish Ministry of Science and Innovation ([RTI2018‐096820‐A‐I00](https://produccioncientifica.ucm.es/proyectos/48103/detalle)) and led by Javier Arroyo and Samer Hassan
  - P2P Models, funded by the European Research Council (ERC-2017-STG 625 grant no.: 75920), led by Samer Hassan.
  - DAOapplications, funded by the Spanish Ministry of Science and Innovation ([PID2021-127956OB-I00](https://produccioncientifica.ucm.es/proyectos/551171/detalle)) and led by Javier Arroyo, Samer Hassan and maria Cruz Valiente



  You can just cite one of our publications:

  > Javier Arroyo, David Davó, Elena Martínez-Vicente, Youssef Faqir-Rhazoui, and Samer Hassan (2022). "DAO-Analyzer: Exploring Activity and Participation in Blockchain Organizations.". Companion Publication of the 2022 Conference on Computer Supported Cooperative Work and Social Computing (CSCW'22 Companion). ACM, 193–196.

  Or, if you want to explicitly cite the application:

  > Arroyo, Javier, Davó, David, Faqir-Rhazoui, Youssef, & Martínez Vicente, Elena. (2023). DAO Analyzer. Zenodo. https://doi.org/10.5281/zenodo.7669689


pkgId: 7f05b078484c68b371809ba61df15f39301f8c28c742ddb00ec7b28970411620
name: python-dapclient
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: A client-only fork of pydap using the DAP protocol to access scientific data on the internet.
url: https://pypi.org/project/dapclient/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapclient-1.0.6-1.src.rpm
checksum_type: sha256
description:
  dapclient is a client-only fork of the venerable pydap. It implements the
  Opendap/DODS protocol.  You can use dapclient to access scientific data on the
  internet without having to download it; instead, you work with special array
  and iterable objects that download data on-the-fly as necessary, saving
  bandwidth and time.


pkgId: 3d30f3c0d64d21017a107b57584f9bcd36c635ffb12f7a973a72cf96d108a219
name: python-daphne
arch: src
version: 4.1.2
epoch: 0
release: 1
summary: Django ASGI (HTTP/WebSocket) server
url: https://github.com/django/daphne
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daphne-4.1.2-1.src.rpm
checksum_type: sha256
description:
  Daphne is a HTTP, HTTP2 and WebSocket protocol server for
  `ASGI <https://github.com/django/asgiref/blob/main/specs/asgi.rst>`_ and
  `ASGI-HTTP <https://github.com/django/asgiref/blob/main/specs/www.rst>`_,
  developed to power Django Channels.
  It supports automatic negotiation of protocols; there's no need for URL
  prefixing to determine WebSocket endpoints versus HTTP endpoints.


pkgId: be19ea37be78841fa429ee070a5fa2e9b3186d3d3f3e15903ed18b92c16183cf
name: python-dapla-cli
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Dapla CLI
url: https://github.com/statisticsnorway/dapla-cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapla-cli-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dapla-cli.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/dapla-cli.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/dapla-cli)][pypi status]
  [![License](https://img.shields.io/pypi/l/dapla-cli)][license]

  [![Documentation](https://github.com/statisticsnorway/dapla-cli/actions/workflows/docs.yml/badge.svg)][documentation]
  [![Tests](https://github.com/statisticsnorway/dapla-cli/actions/workflows/tests.yml/badge.svg)][tests]
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-cli&metric=coverage)][sonarcov]
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-cli&metric=alert_status)][sonarquality]

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)][poetry]

  [pypi status]: https://pypi.org/project/dapla-cli/
  [documentation]: https://statisticsnorway.github.io/dapla-cli
  [tests]: https://github.com/statisticsnorway/dapla-cli/actions?workflow=Tests

  [sonarcov]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-cli
  [sonarquality]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-cli
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black
  [poetry]: https://python-poetry.org/





  Install with [pipx] from [pypi]:

  ```console
  pipx install dapla-cli
  ```

  Alternatively you can build `dapla-cli` using the provided nix flake:

  ```console
  $ nix build .#dapla-cli
  $ ./result/bin/dp --version
  ```

  or open the provided nix shell:

  ```console
  $ nix develop .#
  $ dp --version
  ```



  Please see the [Reference Guide] for details.



  Install a local development edition with [pipx] from the source code:

  ```console
  pipx install --editable .
  ```

  Alternatively, use `make help` for other options, such as running Dapla CLI in an isolated environment:

  ```console
  run-isolated       Run Dapla CLI in isolated environment (Docker container) using latest release from PyPI
  run-isolated-dev   Run Dapla CLI in isolated environment (Docker container) using latest release from local source (in editable mode)
  pipx-install       Install with pipx from PyPI
  pipx-install-dev   Install with pipx from the source code in editable mode
  build-docker       Build local Docker image for testing in an isolated environment
  ```



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _Dapla CLI_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  This project was generated from [Statistics Norway]'s [SSB PyPI Template].

  [statistics norway]: https://www.ssb.no/en
  [pypi]: https://pypi.org/project/dapla-cli/
  [ssb pypi template]: https://github.com/statisticsnorway/ssb-pypitemplate
  [file an issue]: https://github.com/statisticsnorway/dapla-cli/issues
  [pipx]: https://pipx.pypa.io/

  <!-- github-only -->

  [license]: https://github.com/statisticsnorway/dapla-cli/blob/main/LICENSE
  [contributor guide]: https://github.com/statisticsnorway/dapla-cli/blob/main/CONTRIBUTING.md
  [reference guide]: https://statisticsnorway.github.io/dapla-cli/reference.html


pkgId: 3ed80a42e8c34805798d1fed99d66276e5fd6036ec9165b8ede3e17e4d3546d3
name: python-dapla-statbank-client
arch: src
version: 1.2.8
epoch: 0
release: 1
summary: Handles data transfer Statbank <-> Dapla for Statistics Norway
url: https://github.com/statisticsnorway/dapla-statbank-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapla-statbank-client-1.2.8-1.src.rpm
checksum_type: sha256
description:
  Statbank-package makes its own logger using the python logging package. The logger is available at `statbank.logger`.
  A lot of the validations are logged as the level "info", if they seem ok.
  Or on the level "warning" if things are not ok. The levels are colorized with colorama, green for INFO, magenta for WARNING.
  If you *dont* want to see the info-parts of the validate-method, you can change the loggers level before calling validate, like this:
  ```python
  import statbank
  import logging
  statbank.logger.setLevel(logging.WARNING)
  ```

  Distributed under the terms of the [MIT license][license],
  _Dapla Statbank Client_ is free and open source software.

  If you encounter any problems,
  please [file an issue] along with a detailed description.

  This project was generated from [Statistics Norway]'s [SSB PyPI Template].
  [statistics norway]: https://www.ssb.no/en
  [pypi]: https://pypi.org/
  [ssb pypi template]: https://github.com/statisticsnorway/ssb-pypitemplate
  [file an issue]: https://github.com/statisticsnorway/dapla-statbank-client/issues
  [pip]: https://pip.pypa.io/
  <!-- github-only -->
  [license]: https://github.com/statisticsnorway/dapla-statbank-client/blob/main/LICENSE
  [contributor guide]: https://github.com/statisticsnorway/dapla-statbank-client/blob/main/CONTRIBUTING.md
  [reference guide]: https://statisticsnorway.github.io/dapla-statbank-client/reference.html


pkgId: ce04bde6d6fc574e8c47a89daca1fc9464a971bd778bfcad853ed82100da4a9a
name: python-dapla-suv-tools
arch: src
version: 0.1.49
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/dapla-suv-tools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapla-suv-tools-0.1.49-1.src.rpm
checksum_type: sha256
description:
  - `ra_number` (str, required): Skjema's RA-number.
  - `max_results` (int, optional): Maximum number of results in the result set.  A value of `0` will get ALL results. Defaults to `0`.
  - `latest_only` (bool, optional): A boolean flag to trigger a special condition. Defaults to `False`.
  - `pagination_info` (PaginationInfo, optional): An object holding pagination metadata. Defaults to `None`.
  **Returns:**
  - `dict`: A list of skjema json objects matching the RA-number

  ```python
  output = client.get_pulje_by_id(pulje_id=123)
  print(output)
  ```
  **Parameters:**
  - `pulje_id` (int): The ID of the pulje to retrieve.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the pulje information if found, or an error message if the retrieval fails.

  ```python
  output = client.get_pulje_by_periode_id(periode_id=123)
  print(output)
  ```
  **Parameters:**
  - `periode_id` (int): The periode_id of the pulje to retrieve.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: A list of objects containing the pulje information for every pulje under the given pulje_id if found, or an error message if the retrieval fails.

  ```python
  output = client.update_pulje_by_id(pulje_id=123,altinn_tilgjengelig=datetime(2023,12,12))
  print(output)
  ```
  **Parameters:**
  - `pulje_id` (int): The pulje_id of the pulje to update.
  - `altinn_tilgjengelig` (Optional[datetime]): Date and time for altinn_tilgjengelig.
  - `altinn_svarfrist` (Optional[date]): Date for altinn_svarfrist.
  - `tvangsmulkt_svarfrist` (Optional[date]): Date for tvangsmulkt_svarfrist.
  - `send_si` (Optional[date]): Date for send_si.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the updated pulje information, or an error message if the update fails.

  ```python
  output = client.update_pulje_by_periode_id(periode_id=123, pulje_nr=1, altinn_tilgjengelig=datetime(2023,12,12))
  print(output)
  ```
  **Parameters:**
  - `periode_id` (int): The periode_id of the pulje to update.
  - `pulje_nr` (int): The pulje_nr of the pulje to update.
  - `altinn_tilgjengelig` (Optional[datetime]): Date and time for altinn_tilgjengelig.
  - `altinn_svarfrist` (Optional[date]): Date for altinn_svarfrist.
  - `tvangsmulkt_svarfrist` (Optional[date]): Date for tvangsmulkt_svarfrist.
  - `send_si` (Optional[date]): Date for send_si.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the updated pulje information, or an error message if the update fails.

  ```python
  output = client.create_pulje(periode_id=123)
  print(output)
  ```
  **Parameters:**
  - `periode_id` (int): The periode_id of the pulje to create.
  - `pulje_nr` (Optional[int]): The pulje_nr of the pulje to create.
  - `altinn_tilgjengelig` (Optional[datetime]): Date and time for altinn_tilgjengelig.
  - `altinn_svarfrist` (Optional[date]): Date for altinn_svarfrist.
  - `tvangsmulkt_svarfrist` (Optional[date]): Date for tvangsmulkt_svarfrist.
  - `send_si` (Optional[date]): Date for send_si.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the ID of the new pulje,  or an error message if the creation fails.

  ```python
  output = client.delete_pulje(pulje_id=123)
  print(output)
  ```
  **Parameters:**
  - `pulje_id` (int): The pulje_id of the pulje to delete.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the ID of the deleted pulje, or an error message of the deletion fails.

  ```python
  output = client.get_prefill_meta_by_id(skjema_id=123)
  print(output)
  ```
  **Parameters:**
  - `skjema_id` (int): The ID of the skjema.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: A list of objects containing meta data for skjema's matching the supplied id, or an error message if the retrieval fails.

  ```python
  output = client.get_utvalg_from_sfu(delreg_nr="123456789", ra_nummer="123456789", pulje="123456789")
  print(output)
  ```
  **Parameters:**
  - `delreg_nr` (int): The delreg number of the selection.
  - `ra_nummer` (str): Skjema's RA-number, e.g. 'RA-1234'.
  - `pulje` Optional(str): Limit the selection by pulje.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: A list of objects with the selection, or an error message of the deletion fails.

  ```python
  output = client.get_enhet_from_sfu(delreg_nr="123456789", orgnr="123456789")
  print(output)
  ```
  **Parameters:**
  - `delreg_nr` (int): The delreg number of the selection.
  - `orgnr` (str): The organization number of the unit.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object with the organization, or an error message of the deletion fails.


pkgId: 89a5881e5568b61999cde34a0b97f15e4382c7e68ffbf84677b74dd31a9bafc3
name: python-dapla-suv-tools
arch: src
version: 0.1.52
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/dapla-suv-tools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapla-suv-tools-0.1.52-1.src.rpm
checksum_type: sha256
description:
  - `ra_number` (str, required): Skjema's RA-number.
  - `max_results` (int, optional): Maximum number of results in the result set.  A value of `0` will get ALL results. Defaults to `0`.
  - `latest_only` (bool, optional): A boolean flag to trigger a special condition. Defaults to `False`.
  - `pagination_info` (PaginationInfo, optional): An object holding pagination metadata. Defaults to `None`.
  **Returns:**
  - `dict`: A list of skjema json objects matching the RA-number

  ```python
  output = client.get_pulje_by_id(pulje_id=123)
  print(output)
  ```
  **Parameters:**
  - `pulje_id` (int): The ID of the pulje to retrieve.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the pulje information if found, or an error message if the retrieval fails.

  ```python
  output = client.get_pulje_by_periode_id(periode_id=123)
  print(output)
  ```
  **Parameters:**
  - `periode_id` (int): The periode_id of the pulje to retrieve.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: A list of objects containing the pulje information for every pulje under the given pulje_id if found, or an error message if the retrieval fails.

  ```python
  output = client.update_pulje_by_id(pulje_id=123,altinn_tilgjengelig=datetime(2023,12,12))
  print(output)
  ```
  **Parameters:**
  - `pulje_id` (int): The pulje_id of the pulje to update.
  - `altinn_tilgjengelig` (Optional[datetime]): Date and time for altinn_tilgjengelig.
  - `altinn_svarfrist` (Optional[date]): Date for altinn_svarfrist.
  - `tvangsmulkt_svarfrist` (Optional[date]): Date for tvangsmulkt_svarfrist.
  - `send_si` (Optional[date]): Date for send_si.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the updated pulje information, or an error message if the update fails.

  ```python
  output = client.update_pulje_by_periode_id(periode_id=123, pulje_nr=1, altinn_tilgjengelig=datetime(2023,12,12))
  print(output)
  ```
  **Parameters:**
  - `periode_id` (int): The periode_id of the pulje to update.
  - `pulje_nr` (int): The pulje_nr of the pulje to update.
  - `altinn_tilgjengelig` (Optional[datetime]): Date and time for altinn_tilgjengelig.
  - `altinn_svarfrist` (Optional[date]): Date for altinn_svarfrist.
  - `tvangsmulkt_svarfrist` (Optional[date]): Date for tvangsmulkt_svarfrist.
  - `send_si` (Optional[date]): Date for send_si.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the updated pulje information, or an error message if the update fails.

  ```python
  output = client.create_pulje(periode_id=123)
  print(output)
  ```
  **Parameters:**
  - `periode_id` (int): The periode_id of the pulje to create.
  - `pulje_nr` (Optional[int]): The pulje_nr of the pulje to create.
  - `altinn_tilgjengelig` (Optional[datetime]): Date and time for altinn_tilgjengelig.
  - `altinn_svarfrist` (Optional[date]): Date for altinn_svarfrist.
  - `tvangsmulkt_svarfrist` (Optional[date]): Date for tvangsmulkt_svarfrist.
  - `send_si` (Optional[date]): Date for send_si.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the ID of the new pulje,  or an error message if the creation fails.

  ```python
  output = client.delete_pulje(pulje_id=123)
  print(output)
  ```
  **Parameters:**
  - `pulje_id` (int): The pulje_id of the pulje to delete.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object containing the ID of the deleted pulje, or an error message of the deletion fails.

  ```python
  output = client.get_prefill_meta_by_skjema_id(skjema_id=123)
  print(output)
  ```
  **Parameters:**
  - `skjema_id` (int): The ID of the skjema.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: A list of objects containing meta data for skjema's matching the supplied id, or an error message if the retrieval fails.

  ```python
  output = client.get_utvalg_from_sfu(delreg_nr="123456789", ra_nummer="123456789", pulje="123456789")
  print(output)
  ```
  **Parameters:**
  - `delreg_nr` (int): The delreg number of the selection.
  - `ra_nummer` (str): Skjema's RA-number, e.g. 'RA-1234'.
  - `pulje` Optional(str): Limit the selection by pulje.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: A list of objects with the selection, or an error message of the deletion fails.

  ```python
  output = client.get_enhet_from_sfu(delreg_nr="123456789", orgnr="123456789")
  print(output)
  ```
  **Parameters:**
  - `delreg_nr` (int): The delreg number of the selection.
  - `orgnr` (str): The organization number of the unit.
  - `context` (SuvOperationContext): Operation context for logging and error handling. This is injected by the underlying pipeline.  Adding a custom context will result in an error
  **Returns:**
  - `OperationResult`: An object with the organization, or an error message of the deletion fails.


pkgId: 9456cfb72b0d519b5c3f57ad601e41d53ef370e40214c5d16cc3ef93c665e761
name: python-dapla-team-cli
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: CLI for working with Dapla Teams
url: https://github.com/statisticsnorway/dapla-team-cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapla-team-cli-0.3.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dapla-team-cli.svg)][pypi_]
  [![Status](https://img.shields.io/pypi/status/dapla-team-cli.svg)][status]
  [![Python Version](https://img.shields.io/pypi/pyversions/dapla-team-cli)][python version]
  [![License](https://img.shields.io/pypi/l/dapla-team-cli)][license]

  [![Tests](https://github.com/statisticsnorway/dapla-team-cli/workflows/Tests/badge.svg)][tests]
  [![Codecov](https://codecov.io/gh/statisticsnorway/dapla-team-cli/branch/main/graph/badge.svg)][codecov]

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]

  [pypi_]: https://pypi.org/project/dapla-team-cli/
  [status]: https://pypi.org/project/dapla-team-cli/
  [python version]: https://pypi.org/project/dapla-team-cli
  [tests]: https://github.com/statisticsnorway/dapla-team-cli/actions?workflow=Tests
  [codecov]: https://app.codecov.io/gh/statisticsnorway/dapla-team-cli
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black

  A CLI for working with Dapla teams.

  ![dpteam --help](docs/dapla-team-cli-help.png)
  ![IAM Bindings](docs/iam-bindings.gif)

  For [installation options see below](#installation), for usage instructions
  [see the manual](https://statisticsnorway.github.io/dapla-team-cli/) or type `--help` on the command line.

  <!-- this anchor is linked to, so avoid renaming it -->



  Install with [pipx]:

  ```console
  pipx install dapla-team-cli
  ```

  (Be patient, installation can take some time.)



  - Assign bucket access and GCP roles to members for a limited amount of time
  - Get an overview of a team's groups and members
  - Make instant changes to your team's access groups, e.g. add a new team member to your team's "developers" group.
  - Register team secrets (in a team's GCP Secret Manager service)
  - Diagnose your system and get help to install required tooling for easy setup of your development environment



  - [PyPI]



  Please see the [Command-line Reference] for details.



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _Dapla Team CLI_ is free and open source software.



  If you encounter any problems, please [file an issue] along with a detailed description.

  [pypi]: https://pypi.org/project/dapla-team-cli/
  [file an issue]: https://github.com/statisticsnorway/dapla-team-cli/issues
  [pipx]: https://pypa.github.io/pipx

  <!-- github-only -->

  [license]: https://github.com/statisticsnorway/dapla-team-cli/blob/main/LICENSE
  [contributor guide]: https://github.com/statisticsnorway/dapla-team-cli/blob/main/CONTRIBUTING.md
  [command-line reference]: https://statisticsnorway.github.io/dapla-team-cli/command_reference/


pkgId: ee8736e90beb9d4204e82cf48f9c841a961b7bfa3a3504fcd0983dc0de05767e
name: python-dapla-toolbelt
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Dapla Toolbelt
url: https://github.com/statisticsnorway/dapla-toolbelt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapla-toolbelt-3.0.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dapla-toolbelt.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/dapla-toolbelt.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/dapla-toolbelt)][pypi status]
  [![License](https://img.shields.io/pypi/l/dapla-toolbelt)][license]

  [![Documentation](https://github.com/statisticsnorway/dapla-toolbelt/actions/workflows/docs.yml/badge.svg)][documentation]
  [![Tests](https://github.com/statisticsnorway/dapla-toolbelt/actions/workflows/tests.yml/badge.svg)][tests]
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-toolbelt&metric=coverage)][sonarcov]
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-toolbelt&metric=alert_status)][sonarquality]

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)][poetry]

  [pypi status]: https://pypi.org/project/dapla-toolbelt/
  [documentation]: https://statisticsnorway.github.io/dapla-toolbelt
  [tests]: https://github.com/statisticsnorway/dapla-toolbelt/actions?workflow=Tests

  [sonarcov]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-toolbelt
  [sonarquality]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-toolbelt
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black
  [poetry]: https://python-poetry.org/

  Python module for use within Jupyterlab notebooks, specifically aimed for Statistics Norway's data platform called
  `Dapla`. It contains support for authenticated access to Google Services such as Google Cloud Storage (GCS) and custom
  Dapla services such as [Maskinporten Guardian](https://github.com/statisticsnorway/maskinporten-guardian). The
  authentication process is based on the [TokenExchangeAuthenticator](https://github.com/statisticsnorway/jupyterhub-extensions/tree/main/TokenExchangeAuthenticator)
  for Jupyterhub.



  These operations are supported:
  * List contents of a bucket
  * Open a file in GCS
  * Copy a file from GCS into local
  * Load a file (CSV, JSON or XML) from GCS into a pandas dataframe
  * Save contents of a data frame into a file (CSV, JSON, XML) in GCS

  When the user gives the path to a resource, they do not need to give the GCS uri, only the path.
  This just means users don't have to prefix a path with "gs://".
  It is implicitly understood that all resources accessed with this tool are located in GCS,
  with the first level of the path being a GCS bucket name.



  - Python >3.8 (3.10 is preferred)
  - Poetry, install via `curl -sSL https://install.python-poetry.org | python3 -`



  You can install _Dapla Toolbelt_ via [pip] from [PyPI]:

  ```console
  pip install dapla-toolbelt
  ```



  ``` python
  from dapla import FileClient
  from dapla import GuardianClient
  import pandas as pd


  response = GuardianClient.call_api("https://data.udir.no/api/kag", "88ace991-7871-4ccc-aaec-8fb6d78ed04e", "udir:datatilssb")
  data_json = response.json()

  raw_data_df = pd.DataFrame(data_json)  # create pandas data frame from json
  raw_data_df.head()  # show first rows of data frame

  FileClient.ls("bucket-name/folder")  # list contents of given folder


  path_base = "bucket-name/folder/raw_data"
  FileClient.save_pandas_to_json(raw_data_df, f"{path_base}.json")  # generate json from data frame, and save to given path
  FileClient.save_pandas_to_csv(raw_data_df, f"{path_base}.csv")  # generate csv from data frame, and save to given path
  FileClient.save_pandas_to_xml(raw_data_df, f"{path_base}.xml")  # generate xml from data frame, and save to given path

  FileClient.cat(f"{path_base}.json")  # print contents of file



  df = FileClient.load_json_to_pandas(f"{path_base}.json")  # read json from path and load into pandas data frame
  df.head()  # show first rows of data frame
  df = FileClient.load_csv_to_pandas(f"{path_base}.csv")  # read csv from path and load into pandas data frame
  df.head()  # show first rows of data frame
  df = FileClient.load_xml_to_pandas(f"{path_base}.xml")  # read xml from path and load into pandas data frame
  df.head()  # show first rows of data frame

  ```



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _Dapla Toolbelt_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  This project was generated from [Statistics Norway]'s [SSB PyPI Template].

  [statistics norway]: https://www.ssb.no/en
  [pypi]: https://pypi.org/
  [ssb pypi template]: https://github.com/statisticsnorway/ssb-pypitemplate
  [file an issue]: https://github.com/statisticsnorway/dapla-toolbelt/issues
  [pip]: https://pip.pypa.io/

  <!-- github-only -->

  [license]: https://github.com/statisticsnorway/dapla-toolbelt/blob/main/LICENSE
  [contributor guide]: https://github.com/statisticsnorway/dapla-toolbelt/blob/main/CONTRIBUTING.md
  [reference guide]: https://statisticsnorway.github.io/dapla-toolbelt/reference.html


pkgId: 33742664331b2f9877ffd8147bba60e10e1ca44325d09f6cd662d30bb9764fec
name: python-dapla-toolbelt
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: Dapla Toolbelt
url: https://github.com/statisticsnorway/dapla-toolbelt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapla-toolbelt-3.2.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dapla-toolbelt.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/dapla-toolbelt.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/dapla-toolbelt)][pypi status]
  [![License](https://img.shields.io/pypi/l/dapla-toolbelt)][license]

  [![Documentation](https://github.com/statisticsnorway/dapla-toolbelt/actions/workflows/docs.yml/badge.svg)][documentation]
  [![Tests](https://github.com/statisticsnorway/dapla-toolbelt/actions/workflows/tests.yml/badge.svg)][tests]
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-toolbelt&metric=coverage&token=b96c38fb7274dc756da920ad8bf22a73d86e6d5f)](https://sonarcloud.io/summary/new_code?id=statisticsnorway_dapla-toolbelt)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-toolbelt&metric=alert_status&token=b96c38fb7274dc756da920ad8bf22a73d86e6d5f)](https://sonarcloud.io/summary/new_code?id=statisticsnorway_dapla-toolbelt)

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)][poetry]

  [pypi status]: https://pypi.org/project/dapla-toolbelt/
  [documentation]: https://statisticsnorway.github.io/dapla-toolbelt
  [tests]: https://github.com/statisticsnorway/dapla-toolbelt/actions?workflow=Tests

  [sonarcov]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-toolbelt
  [sonarquality]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-toolbelt
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black
  [poetry]: https://python-poetry.org/

  Python module for use within Jupyterlab notebooks, specifically aimed for Statistics Norway's data platform called
  `Dapla`. It contains support for authenticated access to Google Services such as Google Cloud Storage (GCS) and custom
  Dapla services such as [Maskinporten Guardian](https://github.com/statisticsnorway/maskinporten-guardian). The
  authentication process is based on the [TokenExchangeAuthenticator](https://github.com/statisticsnorway/jupyterhub-extensions/tree/main/TokenExchangeAuthenticator)
  for Jupyterhub.



  These operations are supported:
  * List contents of a bucket
  * Open a file in GCS
  * Copy a file from GCS into local
  * Load a file (CSV, JSON or XML) from GCS into a pandas dataframe
  * Save contents of a data frame into a file (CSV, JSON, XML) in GCS

  When the user gives the path to a resource, they do not need to give the GCS uri, only the path.
  This just means users don't have to prefix a path with "gs://".
  It is implicitly understood that all resources accessed with this tool are located in GCS,
  with the first level of the path being a GCS bucket name.



  - Python >3.8 (3.10 is preferred)
  - Poetry, install via `curl -sSL https://install.python-poetry.org | python3 -`



  You can install _Dapla Toolbelt_ via [pip] from [PyPI]:

  ```console
  pip install dapla-toolbelt
  ```



  ``` python
  from dapla import FileClient
  from dapla import GuardianClient
  import pandas as pd


  response = GuardianClient.call_api("https://data.udir.no/api/kag", "88ace991-7871-4ccc-aaec-8fb6d78ed04e", "udir:datatilssb")
  data_json = response.json()

  raw_data_df = pd.DataFrame(data_json)  # create pandas data frame from json
  raw_data_df.head()  # show first rows of data frame

  FileClient.ls("bucket-name/folder")  # list contents of given folder


  path_base = "bucket-name/folder/raw_data"
  FileClient.save_pandas_to_json(raw_data_df, f"{path_base}.json")  # generate json from data frame, and save to given path
  FileClient.save_pandas_to_csv(raw_data_df, f"{path_base}.csv")  # generate csv from data frame, and save to given path
  FileClient.save_pandas_to_xml(raw_data_df, f"{path_base}.xml")  # generate xml from data frame, and save to given path

  FileClient.cat(f"{path_base}.json")  # print contents of file



  df = FileClient.load_json_to_pandas(f"{path_base}.json")  # read json from path and load into pandas data frame
  df.head()  # show first rows of data frame
  df = FileClient.load_csv_to_pandas(f"{path_base}.csv")  # read csv from path and load into pandas data frame
  df.head()  # show first rows of data frame
  df = FileClient.load_xml_to_pandas(f"{path_base}.xml")  # read xml from path and load into pandas data frame
  df.head()  # show first rows of data frame

  ```



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _Dapla Toolbelt_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  This project was generated from [Statistics Norway]'s [SSB PyPI Template].

  [statistics norway]: https://www.ssb.no/en
  [pypi]: https://pypi.org/
  [ssb pypi template]: https://github.com/statisticsnorway/ssb-pypitemplate
  [file an issue]: https://github.com/statisticsnorway/dapla-toolbelt/issues
  [pip]: https://pip.pypa.io/

  <!-- github-only -->

  [license]: https://github.com/statisticsnorway/dapla-toolbelt/blob/main/LICENSE
  [contributor guide]: https://github.com/statisticsnorway/dapla-toolbelt/blob/main/CONTRIBUTING.md
  [reference guide]: https://statisticsnorway.github.io/dapla-toolbelt/reference.html


pkgId: 95895cd3fbe1cc6b24f2e9d89dfdf954b468a68e6fd991f39eaea058e980603c
name: python-dapla-toolbelt-metadata
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Dapla Toolbelt Metadata
url: https://github.com/statisticsnorway/dapla-toolbelt-metadata
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapla-toolbelt-metadata-0.2.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dapla-toolbelt-metadata.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/dapla-toolbelt-metadata.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/dapla-toolbelt-metadata)][pypi status]
  [![License](https://img.shields.io/pypi/l/dapla-toolbelt-metadata)][license]

  [![Documentation](https://github.com/statisticsnorway/dapla-toolbelt-metadata/actions/workflows/docs.yml/badge.svg)][documentation]
  [![Tests](https://github.com/statisticsnorway/dapla-toolbelt-metadata/actions/workflows/tests.yml/badge.svg)][tests]
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-toolbelt-metadata&metric=coverage&token=ee0a4d273db2bf811222fca5dffccd4592e3d536)][sonarcov]
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-toolbelt-metadata&metric=alert_status&token=ee0a4d273db2bf811222fca5dffccd4592e3d536)][sonarquality]

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)][poetry]

  [pypi status]: https://pypi.org/project/dapla-toolbelt-metadata/
  [documentation]: https://statisticsnorway.github.io/dapla-toolbelt-metadata
  [tests]: https://github.com/statisticsnorway/dapla-toolbelt-metadata/actions?workflow=Tests

  [sonarcov]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-toolbelt-metadata
  [sonarquality]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-toolbelt-metadata
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black
  [poetry]: https://python-poetry.org/

  Tools and clients for working with the Dapla Metadata system.



  - Create and update metadata for datasets (Datadoc).



  - Read, create and update variable definitions.
  - Publish dataset metadata to Statistics Norway's data catalogue.



  You can install _Dapla Toolbelt Metadata_ via [pip] from [PyPI]:

  ```console
  pip install dapla-toolbelt-metadata
  ```



  Instructions and examples may be found in the [Dapla Manual](https://manual.dapla.ssb.no/statistikkere/). Please see the [Reference Guide] for API documentation.



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _Dapla Toolbelt Metadata_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  This project was generated from [Statistics Norway]'s [SSB PyPI Template].

  [statistics norway]: https://www.ssb.no/en
  [pypi]: https://pypi.org/
  [ssb pypi template]: https://github.com/statisticsnorway/ssb-pypitemplate
  [file an issue]: https://github.com/statisticsnorway/dapla-toolbelt-metadata/issues
  [pip]: https://pip.pypa.io/

  <!-- github-only -->

  [license]: https://github.com/statisticsnorway/dapla-toolbelt-metadata/blob/main/LICENSE
  [contributor guide]: https://github.com/statisticsnorway/dapla-toolbelt-metadata/blob/main/CONTRIBUTING.md
  [reference guide]: https://statisticsnorway.github.io/dapla-toolbelt-metadata/reference.html


pkgId: d624e3d65b11298a1316277f57c6b7e6450310ce9511bbb1929cb16a8081e68a
name: python-dapla-toolbelt-pseudo
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Pseudonymization extensions for Dapla
url: https://github.com/statisticsnorway/dapla-toolbelt-pseudo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dapla-toolbelt-pseudo-2.2.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dapla-toolbelt-pseudo.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/dapla-toolbelt-pseudo.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/dapla-toolbelt-pseudo)][pypi status]
  [![License](https://img.shields.io/pypi/l/dapla-toolbelt-pseudo)][license]

  [![Documentation](https://github.com/statisticsnorway/dapla-toolbelt-pseudo/actions/workflows/docs.yml/badge.svg)][documentation]
  [![Tests](https://github.com/statisticsnorway/dapla-toolbelt-pseudo/actions/workflows/tests.yml/badge.svg)][tests]
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-toolbelt-pseudo&metric=coverage)][sonarcov]
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=statisticsnorway_dapla-toolbelt-pseudo&metric=alert_status)][sonarquality]

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)][poetry]

  [pypi status]: https://pypi.org/project/dapla-toolbelt-pseudo/
  [documentation]: https://statisticsnorway.github.io/dapla-toolbelt-pseudo
  [tests]: https://github.com/statisticsnorway/dapla-toolbelt-pseudo/actions?workflow=Tests

  [sonarcov]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-toolbelt-pseudo
  [sonarquality]: https://sonarcloud.io/summary/overall?id=statisticsnorway_dapla-toolbelt-pseudo
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black
  [poetry]: https://python-poetry.org/

  Pseudonymize, repseudonymize and depseudonymize data on Dapla.



  Other examples can also be viewed through notebook files for [pseudo](tests/pseudo_examples.ipynb) and [depseudo](tests/depseudo_examples.ipynb)



  ```python
  from dapla_pseudo import Pseudonymize
  import polars as pl

  file_path="data/personer.csv"
  dtypes = {"fnr": pl.Utf8, "fornavn": pl.Utf8, "etternavn": pl.Utf8, "kjonn": pl.Categorical, "fodselsdato": pl.Utf8}
  df = pl.read_csv(file_path, dtypes=dtypes) # Create DataFrame from file


  result_df = (
      Pseudonymize.from_polars(df)                   # Specify what dataframe to use
      .on_fields("fornavn")                          # Select the field to pseudonymize
      .with_default_encryption()                     # Select the pseudonymization algorithm to apply
      .run()                                         # Apply pseudonymization to the selected field
      .to_polars()                                   # Get the result as a polars dataframe
  )


  result_df = (
      Pseudonymize.from_polars(df)                   # Specify what dataframe to use
      .on_fields("fornavn", "etternavn")             # Select multiple fields to pseudonymize
      .with_default_encryption()                     # Select the pseudonymization algorithm to apply
      .run()                                         # Apply pseudonymization to the selected fields
      .to_polars()                                   # Get the result as a polars dataframe
  )


  result_df = (
      Pseudonymize.from_polars(df)                   # Specify what dataframe to use
      .on_fields("fnr")                              # Select the field to pseudonymize
      .with_stable_id()                              # Map the selected field to stable id
      .run()                                         # Apply pseudonymization to the selected fields
      .to_polars()                                   # Get the result as a polars dataframe
  )
  ```

  The default encryption algorithm is DAEAD (Deterministic Authenticated Encryption with Associated Data). However, if the
  field is a valid Norwegian personal identification number (fnr, dnr), the recommended way to pseudonymize is to use
  the function `with_stable_id()` to convert the identification number to a stable ID (SID) prior to pseudonymization.
  In that case, the pseudonymization algorithm is FPE (Format Preserving Encryption).

  > [!IMPORTANT]
  > FPE requires minimum two bytes/characters to perform encryption and minimum four bytes in case of Unicode.

  If a field cannot be converted using the function `with_stable_id()` the default behaviour is to use the original value
  as input to the FPE encryption function. However, this behaviour can be changed by supplying a `on_map_failure` argument
  like this:

  ```python
  from dapla_pseudo import Pseudonymize


  result_df = (
      Pseudonymize.from_polars(df)
      .on_fields("fnr")
      .with_stable_id(on_map_failure="RETURN_NULL")
      .run()
      .to_polars()
  )
  ```




  Note that you may also use a Pandas DataFrame as an input or output, by exchanging `from_polars` with `from_pandas`
  and `to_polars` with `to_pandas`. However, Pandas is much less performant, so take special care especially if your
  dataset is large.

  Example:

  ```python

  df_pandas = (
      Pseudonymize.from_pandas(df)                   # Specify what dataframe to use
      .on_fields("fornavn")                          # Select the field to pseudonymize
      .with_default_encryption()                     # Select the pseudonymization algorithm to apply
      .run()                                         # Apply pseudonymization to the selected field
      .to_pandas()                                   # Get the result as a polars dataframe
  )
  ```




  ```python
  from dapla_pseudo import Validator
  import polars as pl

  file_path="data/personer.csv"
  dtypes = {"fnr": pl.Utf8, "fornavn": pl.Utf8, "etternavn": pl.Utf8, "kjonn": pl.Categorical, "fodselsdato": pl.Utf8}
  df = pl.read_polars(file_path, dtypes=dtypes)

  result = (
      Validator.from_polars(df)                   # Specify what dataframe to use
      .on_field("fnr")                            # Select the field to validate
      .validate_map_to_stable_id()                # Validate that all the field values can be mapped to a SID
  )

  result.to_polars()
  ```

  A `sid_snapshot_date` can also be specified to validate that the field values can be mapped to a SID at a specific date:

  ```python
  from dapla_pseudo import Validator
  import polars as pl

  file_path="data/personer.csv"
  dtypes = {"fnr": pl.Utf8, "fornavn": pl.Utf8, "etternavn": pl.Utf8, "kjonn": pl.Categorical, "fodselsdato": pl.Utf8}

  df = pl.read_csv(file_path, dtypes=dtypes)

  result = (
      Validator.from_polars(df)
      .on_field("fnr")
      .validate_map_to_stable_id(
          sid_snapshot_date="2023-08-29"
      )
  )

  result.metadata

  result.to_polars()
  ```







  ```python
  from dapla_pseudo import Pseudonymize
  from dapla import AuthClient


  file_path="data/personer.csv"

  options = {
      "dtypes": {"fnr": pl.Utf8, "fornavn": pl.Utf8, "etternavn": pl.Utf8, "kjonn": pl.Categorical, "fodselsdato": pl.Utf8}
  }



  result_df = (
      Pseudonymize.from_file(file_path)   # Read the data from file
      .on_fields("fornavn", "etternavn")  # Select multiple fields to pseudonymize
      .with_default_encryption()          # Select the pseudonymization algorithm to apply
      .run()                              # Apply pseudonymization to the selected fields
      .to_polars(**options)               # Get the result as a Pandas DataFrame
  )


  options = {
      "dtypes": {"fnr": pl.Utf8, "fornavn": pl.Utf8, "etternavn": pl.Utf8, "kjonn": pl.Categorical, "fodselsdato": pl.Utf8}
  }

  gcs_file_path = "gs://ssb-staging-dapla-felles-data-delt/felles/pseudo-examples/andeby_personer.csv"

  result_df = (
      Pseudonymize.from_file(gcs_file_path)  # Read DataFrame from GCS
      .on_fields("fornavn", "etternavn")     # Select multiple fields to pseudonymize
      .with_default_encryption()             # Select the pseudonymization algorithm to apply
      .run()                                 # Apply pseudonymization to the selected fields
      .to_polars(**options)                  # Get the result as a polars dataframe
  )
  ```



  ```python
  from dapla_pseudo import Pseudonymize, PseudoKeyset


  df = (
      Pseudonymize.from_polars(df)                            # Specify what dataframe to use
      .on_fields("fornavn")                                   # Select the field to pseudonymize
      .with_default_encryption()                              # Select the pseudonymization algorithm to apply
      .run()                                         # Apply pseudonymization to the selected field
      .to_polars()                                            # Get the result as a polars dataframe
  )


  df = (
      Pseudonymize.from_polars(df)                            # Specify what dataframe to use
      .on_fields("fornavn")                                   # Select the field to pseudonymize
      .with_default_encryption(custom_key="ssb-common-key-2") # Select the pseudonymization algorithm to apply
      .run()                                         # Apply pseudonymization to the selected field
      .to_polars()                                            # Get the result as a polars dataframe
  )


  import json
  custom_keyset = PseudoKeyset(
      encrypted_keyset="CiQAp91NBhLdknX3j9jF6vwhdyURaqcT9/M/iczV7fLn...8XYFKwxiwMtCzDT6QGzCCCM=",
      keyset_info={
          "primaryKeyId": 1234567890,
          "keyInfo": [
              {
                  "typeUrl": "type.googleapis.com/google.crypto.tink.AesSivKey",
                  "status": "ENABLED",
                  "keyId": 1234567890,
                  "outputPrefixType": "TINK",
              }
          ],
      },
      kek_uri="gcp-kms://projects/some-project-id/locations/europe-north1/keyRings/some-keyring/cryptoKeys/some-kek-1",
  )

  df = (
      Pseudonymize.from_polars(df)
      .on_fields("fornavn")
      .with_default_encryption(custom_key="1234567890") # Note that the custom key has to be the same as "primaryKeyId" in the custom keyset
      .run(custom_keyset=custom_keyset)
      .to_polars()
  )
  ```


  Instead of declaring the pseudonymization rules via the Pseudonymize functions, one can define the rules manually.
  This can be done via the `PseudoRule` class like this:

  ```python
  from dapla_pseudo import Pseudonymize, PseudoRule

  rule_json = {
      'name': 'my-fule',
       'pattern': '**/identifiers/*',
       'func': 'redact(placeholder=#)' # This is a shorthand representation of the redact function
  }

  rule = PseudoRule.from_json(rule_json)

  df = (
      Pseudonymize.from_polars(df)
      .add_rules(rule) # Add to pseudonymization rules
      .run()
      .to_polars()
  )
  ```

  Pseudonymization rules can also be read from file. This is especially handy when there are several rules, or if you
  prefer to store and maintain pseudonymization rules externally. For example:

  ```python
  from dapla_pseudo import PseudoRule
  import json

  with open("pseudo-rules.json", 'r') as rules_file:
      rules_json = json.load(rules_file)

  pseudo_rules = [PseudoRule.from_json(rule) for rule in rules_json]

  df = (
      Pseudonymize.from_polars(df)
      .add_rules(pseudo_rules)
      .run()
      .to_polars()
  )
  ```



  The "Depseudonymize" functions are almost exactly the same as when pseudonymizing.
  User can map from Stable ID *back to* FNR.

  ```python
  from dapla_pseudo import Depseudonymize
  import polars as pl

  file_path="data/personer_pseudonymized.csv"
  dtypes = {"fnr": pl.Utf8, "fornavn": pl.Utf8, "etternavn": pl.Utf8, "kjonn": pl.Categorical, "fodselsdato": pl.Utf8}
  df = pl.read_csv(file_path, dtypes=dtypes) # Create DataFrame from file


  result_df = (
      Depseudonymize.from_polars(df)                 # Specify what dataframe to use
      .on_fields("fornavn")                          # Select the field to depseudonymize
      .with_default_encryption()                     # Select the depseudonymization algorithm to apply
      .run()                                         # Apply depseudonymization to the selected field
      .to_polars()                                   # Get the result as a polars dataframe
  )


  result_df = (
      Depseudonymize.from_polars(df)                 # Specify what dataframe to use
      .on_fields("fornavn", "etternavn")             # Select multiple fields to depseudonymize
      .with_default_encryption()                     # Select the depseudonymization algorithm to apply
      .run()                                         # Apply depseudonymization to the selected fields
      .to_polars()                                   # Get the result as a polars dataframe
  )


  result_df = (
      Depseudonymize.from_polars(df)                 # Specify what dataframe to use
      .on_fields("fnr")                              # Select fnr field to depseudonymize
      .with_stable_id()                              # Select the depseudonymization method (SID mapping) to apply
      .run()                                         # Apply depseudonymization to the selected fields
      .to_polars()                                   # Get the result as a polars dataframe
  )

  ```


  _Note that depseudonymization requires elevated access privileges._


  Repseudonymize can either 1) Change the algorithm used to pseudonymize, and/or 2)
  change the key used in pseudonymization, while keeping the algorithm.

  ```python

  result_df = (
      Repseudonymize.from_polars(df)                 # Specify what dataframe to use
      .on_fields("fnr")                              # Select the field to pseudonymize
      .from_papis_compatible_encryption()            # Select the pseudonymization algorithm previously used
      .to_stable_id()                                # Select the new pseudonymization rule
      .run()                                         # Apply pseudonymization to the selected field
      .to_polars()                                   # Get the result as a polars dataframe
  )
  ```

  ```python

  result_df = (
      Repseudonymize.from_polars(df)                     # Specify what dataframe to use
      .on_fields("fnr")                                  # Select the field to pseudonymize
      .from_papis_compatible_encryption()                # Select the pseudonymization algorithm previously used
      .to_papis_compatible_encryption(key_id="some-key") # Select the new pseudonymization rule
      .run()                                             # Apply pseudonymization to the selected field
      .to_polars()                                       # Get the result as a polars dataframe
  )
  ```


  Datadoc metadata is gathered while pseudonymizing, and can be seen like so:

  ```python
  result = (
      Pseudonymize.from_polars(df)
      .on_fields("fornavn")
      .with_default_encryption()
      .run()
  )

  print(result.datadoc)
  ```

  Datadoc metadata is automatically written to the folder or bucket as the pseudonymized
  data, when using the `to_file()` method on the result object.
  The metadata file has the suffix `__DOC`, and is always a `.json` file.
  The data and metadata is written to the file like so:

  ```python
  result = (
      Pseudonymize.from_polars(df)
      .on_fields("fornavn")
      .with_default_encryption()
      .run()
  )


  result.to_file("gs://bucket/test.parquet")
  ```

  Note that if you choose to only use the DataFrame from the result, **the metadata will be lost forever**!
  An example of how this can happen:

  ```python
  import dapla as dp
  result = (
      Pseudonymize.from_polars(df)
      .on_fields("fornavn")
      .with_default_encryption()
      .run()
  )
  df = result.to_pandas()

  dp.write_pandas(df, "gs://bucket/test.parquet", file_format="parquet") # The metadata is lost!!
  ```




  - Python >= 3.10
  - Dependencies can be found in `pyproject.toml`



  You can install _Dapla Toolbelt Pseudo_ via [pip] from [PyPI]:

  ```console
  pip install dapla-toolbelt-pseudo
  ```



  Please see the [Reference Guide] for details.



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _Dapla Toolbelt Pseudo_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  This project was generated from [Statistics Norway]'s [SSB PyPI Template].

  [statistics norway]: https://www.ssb.no/en
  [pypi]: https://pypi.org/
  [ssb pypi template]: https://github.com/statisticsnorway/ssb-pypitemplate
  [file an issue]: https://github.com/statisticsnorway/dapla-toolbelt-pseudo/issues
  [pip]: https://pip.pypa.io/

  <!-- github-only -->

  [license]: https://github.com/statisticsnorway/dapla-toolbelt-pseudo/blob/main/LICENSE
  [contributor guide]: https://github.com/statisticsnorway/dapla-toolbelt-pseudo/blob/main/CONTRIBUTING.md
  [reference guide]: https://statisticsnorway.github.io/dapla-toolbelt-pseudo/reference.html


