# packages

pkgId: bd7bbb94906562c50cc87bd5f8722cdc7fc3c3e04faaa2f4b8c68d7a5f2f692a
name: python-buildpg
arch: src
version: 0.4
epoch: 0
release: 1
summary: Query building for the postgresql prepared statements and asyncpg.
url: https://github.com/samuelcolvin/buildpg
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buildpg-0.4-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/samuelcolvin/buildpg/workflows/ci/badge.svg?event=push)](https://github.com/samuelcolvin/buildpg/actions?query=event%3Apush+branch%3Amaster+workflow%3Aci)
  [![Coverage](https://codecov.io/gh/samuelcolvin/buildpg/branch/master/graph/badge.svg)](https://codecov.io/gh/samuelcolvin/buildpg)
  [![pypi](https://img.shields.io/pypi/v/buildpg.svg)](https://pypi.python.org/pypi/buildpg)
  [![versions](https://img.shields.io/pypi/pyversions/buildpg.svg)](https://github.com/samuelcolvin/buildpg)
  [![license](https://img.shields.io/github/license/samuelcolvin/buildpg.svg)](https://github.com/samuelcolvin/buildpg/blob/master/LICENSE)

  Query building for the postgresql prepared statements and asyncpg.

  Lots of more powerful features, including full clause construction, multiple values, logic functions,
  query pretty-printing and different variable substitution - below is just a very quick summary.
  Please check the code and tests for examples.



  Simple variable substitution:

  ```py
  from buildpg import render

  render('select * from mytable where x=:foo and y=:bar', foo=123, bar='whatever')
  >> 'select * from mytable where x=$1 and y=$2', [123, 'whatever']
  ```


  Use of `V` to substitute constants:

  ```py
  from buildpg import V, render

  render('select * from mytable where :col=:foo', col=V('x'), foo=456)
  >> 'select * from mytable where x=$1', [456]
  ```

  Complex logic:

  ```py
  from buildpg import V, funcs, render

  where_logic = V('foo.bar') == 123
  if spam_value:
     where_logic &= V('foo.spam') <= spam_value

  if exclude_cake:
     where_logic &= funcs.not_(V('foo.cake').in_([1, 2, 3]))

  render('select * from foo :where', where=where_logic)
  >> 'select * from foo foo.bar = $1 AND foo.spam <= $2 AND not(foo.cake in $3)', [123, 123, ['x', 'y']]
  ```

  Values usage:

  ```py
  from buildpg import Values, render

  render('insert into the_table (:values__names) values :values', values=Values(a=123, b=456, c='hello'))
  >> 'insert into the_table (a, b, c) values ($1, $2, $3)', [123, 456, 'hello']
  ```



  As a wrapper around *asyncpg*:

  ```py
  import asyncio
  from buildpg import asyncpg

  async def main():
     async with asyncpg.create_pool_b('postgres://postgres@localhost:5432/db') as pool:
         await pool.fetchval_b('select spam from mytable where x=:foo and y=:bar', foo=123, bar='whatever')
         >> 42

  asyncio.run(main())
  ```


  Both the pool and connections have `*_b` variants of all common query methods:

  - `execute_b`
  - `executemany_b`
  - `fetch_b`
  - `fetchval_b`
  - `fetchrow_b`
  - `cursor_b`




  | Python operator/function | SQL operator |
  | ------------------------ | ------------ |
  | `&`                      | `AND` |
  | `|`                      | `OR` |
  | `=`                      | `=` |
  | `!=`                     | `!=` |
  | `<`                      | `<` |
  | `<=`                     | `<=` |
  | `>`                      | `>` |
  | `>=`                     | `>=` |
  | `+`                      | `+` |
  | `-`                      | `-` |
  | `*`                      | `*` |
  | `/`                      | `/` |
  | `%`                      | `%` |
  | `**`                     | `^` |
  | `-`                      | `-` |
  | `~`                      | `not(...)` |
  | `sqrt`                   | `|/` |
  | `abs`                    | `@` |
  | `contains`               | `@>` |
  | `contained_by`           | `<@` |
  | `overlap`                | `&&` |
  | `like`                   | `LIKE` |
  | `ilike`                  | `ILIKE` |
  | `cat`                    | `||` |
  | `in_`                    | `in` |
  | `from_`                  | `from` |
  | `at_time_zone`           | `AT TIME ZONE` |
  | `matches`                | `@@` |
  | `is_`                    | `is` |
  | `is_not`                 | `is not` |
  | `for_`                   | `for` |
  | `factorial`              | `!` |
  | `cast`                   | `::` |
  | `asc`                    | `ASC` |
  | `desc`                   | `DESC` |
  | `comma`                  | `,` |
  | `on`                     | `ON` |
  | `as_`                    | `AS` |
  | `nulls_first`            | `NULLS FIRST` |
  | `nulls_last`             | `NULLS LAST` |

  Usage:

  ```py
  from buildpg import V, S, render

  def show(component):
     sql, params = render(':c', c=component)
     print(f'sql="{sql}" params={params}')

  show(V('foobar').contains([1, 2, 3]))

  show(V('foobar') == 4)

  show(~V('foobar'))

  show(S(625).sqrt())

  show(V('foo').is_not('true'))

  ```



  | Python function                             | SQL function  |
  | ------------------------------------------- | ------------- |
  | `AND(*args)`                                | `<arg1> and <arg2> ...` |
  | `OR(*args)`                                 | `<arg1> or <arg2> ...` |
  | `NOT(arg)`                                  | `not(<arg>)` |
  | `comma_sep(*args)`                          | `<arg1>, <arg2>, ...` |
  | `count(expr)`                               | `count(expr)` |
  | `any(arg)`                                  | `any(<arg1>)` |
  | `now()`                                     | `now()` |
  | `cast(v, cast_type)`                        | `<v>::<cast_type>` |
  | `upper(string)`                             | `upper(<string>)` |
  | `lower(string)`                             | `lower(<string>)` |
  | `length(string)`                            | `length(<string>)` |
  | `left(string, n)`                           | `left(<string>, <n>)` |
  | `right(string, n)`                          | `right(<string>, <n>)` |
  | `extract(expr)`                             | `extract(<expr>)` |
  | `sqrt(n)`                                   | `|/<n>` |
  | `abs(n)`                                    | `@<n>` |
  | `factorial(n)`                              | `!<n>` |
  | `position(substring, string)`               | `position(<substring> in <st`... |
  | `substring(string, pattern, escape-None)`   | `substring(<string> from <pa`... |
  | `to_tsvector(arg1, document-None)`          | `to_tsvector(<arg1>)` |
  | `to_tsquery(arg1, text-None)`               | `to_tsquery(<arg1>)` |

  Usage:

  ```py
  from buildpg import V, render, funcs

  def show(component):
    sql, params = render(':c', c=component)
    print(f'sql="{sql}" params={params}')

  show(funcs.AND(V('x') == 4, V('y') > 6))

  show(funcs.position('foo', 'this has foo in it'))

  ```


pkgId: 12b65e1d2f14192ad62d79527903566fd3ca80f5c82eabfb1ae9ca1f6b0b390a
name: python-buildstream-plugins-community
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: A collection of community-maintained plugins.
url: https://buildstream.gitlab.io/buildstream-plugins-community/
rpm_license: LGPL-2.1-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buildstream-plugins-community-2.0.2-1.src.rpm
checksum_type: sha256
description:
  The plugins in this repo do not provide strong API guarantees or backwards
  compatibility. You should use a specific commit in your project and update it
  manually as needed.
  You are recommended to import these plugins into your project using the
  `junction plugins <https://docs.buildstream.build/master/format_project.html#junction-plugins>`_
  feature of BuildStream 2.0 so you can control exactly what Git commit is used.
  Please note that using it this way requires at least BuildStream 2.2.
  This is done in several stages documented below:
  Using via a junction
  ~~~~~~~~~~~~~~~~~~~~
  First, make sure you have the ``git`` source from
  `buildstream-plugins`_
  available and declared in your ``project.conf`` file. If you installed
  the `PyPI package <https://pypi.org/project/buildstream-plugins/>`_
  then you can import it as a
  `pip plugin <https://docs.buildstream.build/master/format_project.html#pip-plugins>`_::
      plugins:
      - origin: pip
        package-name: buildstream-plugins
        sources:
        - git
  Now, add a
  `junction element <https://docs.buildstream.build/master/elements/junction.html#module-elements.junction>`_
  referencing this repo. Here's an example you could save as ``buildstream-plugins-community.bst``
  in your elements directory::
      kind: junction
      sources:
      - kind: git
        url: https://gitlab.com/BuildStream/buildstream-plugins-community.git
        track: master
  You can then run ``bst source track buildstream-plugins-community.bst`` to set the ``ref`` field
  appropriately.
  Finally you can define specific plugins you want to use in ``project.conf``::
      plugins:
      - origin: junction
        junction: buildstream-plugins-community.bst
        sources:
        - pypi
        elements:
        - pep517
  Alternative methods
  ~~~~~~~~~~~~~~~~~~~
  You can use Git's 'submodules' feature to import this repo into your project's
  repo, then declare the plugins as
  `local plugins <https://docs.buildstream.build/master/format_project.html#local-plugins>`_.
  BuildStream also supports
  `pip plugins <https://docs.buildstream.build/master/format_project.html#pip-plugins>`_
  which are imported from the host Python environment. While
  `buildstream-plugins-community <https://pypi.org/project/buildstream-plugins-community/>`_
  is available on PyPI, the project does not provide any backwards compatibility
  or "semantic versioning" guarantees. Make sure you can control exactly what of
  the package version is used if you consume it via Pip.


pkgId: 78df596d0db429ccf3c8caa5fee8f2bf31c8125bbcb22a17e42e0b4dfb2a68e1
name: python-buildsys-dateversion
arch: src
version: 2024.12
epoch: 0
release: 1
summary: Easy date-based versioning for Python projects
url: https://pypi.org/project/buildsys-dateversion/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buildsys-dateversion-2024.12-1.src.rpm
checksum_type: sha256
description:
  Easy date-based versioning for Python projects.

  [![PyPI](https://img.shields.io/pypi/v/buildsys-dateversion)](https://pypi.org/project/buildsys-dateversion/)

  <!--TOC-->

  - [buildsys-dateversion](#buildsys-dateversion)
    - [Overview](#overview)
    - [Usage](#usage)
      - [Prerequisites](#prerequisites)
      - [Installation (setuptools)](#installation-setuptools)
      - [Installation (flit)](#installation-flit)
      - [Installation (other)](#installation-other)
    - [Configuration reference](#configuration-reference)
    - [Caveats](#caveats)
    - [License](#license)

  <!--TOC-->



  `buildsys-dateversion` is a Python build system extension to automatically
  set a version string based on the current date/time as a project builds.
  Once enabled, your project's version number while building a source distribution
  or wheel will be automatically generated.

  At minimum, the version string will contain the current year & month.
  If the generated version would clash with a version already released to PyPI,
  additional date/time portions are added to the string (i.e. day, hour, minute)
  until the clash is resolved.

  `buildsys-dateversion` is a [PEP 517](https://peps.python.org/pep-0517/)
  compliant build system and can be used with other PEP 517 implementations,
  such as `setuptools` and `flit`.

  Here's an example of a sequence of version strings which may result
  from using `buildsys-dateversion` for a project:

  | Release is made at... | Version string    |
  | --------------------- | ----------------- |
  | 2025-03-25 12:00      | `2025.3`          |
  | 2025-03-31 12:00      | `2025.3.31`       |
  | 2025-03-31 13:00      | `2025.3.31.13`    |
  | 2025-03-31 14:00      | `2025.3.31.14`    |
  | 2025-03-31 14:30      | `2025.3.31.14.30` |
  | 2025-03-31 17:30      | `2025.3.31.17`    |
  | 2025-04-02 12:00      | `2025.4`          |





  Your project must use [pyproject.toml](https://packaging.python.org/en/latest/specifications/declaring-project-metadata/#declaring-project-metadata).

  Your project's sources must contain a `.py` file with a line of the form:

  ```python
  __version__ = "0"
  ```

  (The specific value for `__version__` does not matter, as it will be
  overwritten during build, but `"0"` is recommended.)



  Your `pyproject.toml` should look like this:

  ```toml
  [project]
  name = "myproject"
  dynamic = ["version"]

  [tool.setuptools.dynamic]
  version = {attr = "myproject.__version__"}

  [build-system]
  requires = ["buildsys-dateversion"]
  build-backend = "buildsys_dateversion"
  ```

  (Note that `buildsys-dateversion` uses
  [pip-compatible build-system defaults](https://pip.pypa.io/en/stable/reference/build-system/pyproject-toml/#fallback-behaviour);
  this is the reason why it is not necessary to explicitly configure
  `setuptools` as a build backend or to list it in `requires`, as
  is necessary in the flit example below.)



  Your `pyproject.toml` should look like this:

  ```toml
  [project]
  name = "myproject"
  dynamic = ["version", "description"]

  [build-system]
  requires = ["buildsys-dateversion", "flit_core >=3.2,<4"]
  build-backend = "buildsys_dateversion"

  [tool.buildsys-dateversion]



  build-backend = "flit_core.buildapi"
  ```



  `buildsys-dateversion` is theoretically compatible with other
  PEP 517 build backends (though only setuptools and flit are tested).
  The primary requirement is that the build backend must support
  a dynamic `version` based on a `__version__` attr in the project,
  as both setuptools and flit do.

  ```toml
  [project]
  name = "myproject"


  dynamic = ["version"]

  [build-system]

  requires = ["buildsys-dateversion", "some_build_backend"]
  build-backend = "buildsys_dateversion"

  [tool.buildsys-dateversion]

  build-backend = "some_build_backend.hooks"
  ```



  The following values can be set in `pyproject.toml`, in the
  `tool.buildsys-dateversion` table.

  ```toml
  [tool.buildsys-dateversion]


  build-backend = "some_build_backend.hooks"


  version-marker = "generated by buildsys-dateversion"



  version-path = "src/mymodule/__init__.py"
  ```



  Take note of the following before using this project:

  * The setting of the `__version__` attribute currently relies on temporarily
    patching files in the source tree, which has some implications:
    * The source tree during a build must not be read-only.
    * If the build process is interrupted, the file defining `__version__` might
      not be restored to its original state.
  * `buildsys-dateversion` is implemented as a PEP 517 build backend which
    wraps another PEP 517 build backend. However, this wrapping is not perfect
    and might result in subtle behavior differences from the underlying backend.



  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

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


pkgId: 12b93d084ae4605db0d0ae2ef135cc9a2f692bb7c902d9856f8957c14ad33426
name: python-buildtool
arch: src
version: 0.2.9
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/Cal-CS-61A-Staff/cs61a-apps/tree/master/buildtool
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buildtool-0.2.9-1.src.rpm
checksum_type: sha256
description:
  This is a `make` alternative with a simpler syntax and some useful features.



  To create a buildtool project, place a `WORKSPACE` file at the root of your project. For now, it can be empty. Run `git init` to initialize a git repo in your project root.

  Then you can define build rules in `BUILD` files.  Imagine a simple project with one source file: `src/main.c`, that can be compiled with `gcc main.c -c -o ../build/a.out` to produce the output file `build/a.out`. Our project structure looks like:
  ```
   - WORKSPACE
   - src/
      - main.c
      - BUILD
  ```
  We have placed a `BUILD` file in the `src/` directory. We will declare a rule called `main` that builds `main.c` and produces `a.out` in this `BUILD` file.

  ```python

  def impl(ctx):
      ctx.sh("mkdir -p ../build")
      ctx.sh("gcc main.c -c -o ../build/a.out")

  callback(
      name="main",
      deps=["main.c"],
      impl=impl,
      out="../build/a.out",
  )
  ```
  Let's see what this file does. The `callback` tells `buildtool` that we are declaring a rule with `name="main"`. The `deps` of a rule are the files that the rule requires to run. The `out` is a file (or list of files) that a rule produces from its deps. Finally, the implementation `impl` of a rule describes the actions that a rule performs in order to generate its output from its inputs.

  The paths passed into the callback are relative to the folder containing the `BUILD` file.

  An `impl` function takes in a single argument: the build context `ctx`. When defining a rule's implementation, do not use functions like `os.system` directly - aside from invoking methods in the `ctx`, all `impl` functions must be side-effect free. Here, `ctx.sh(...)` runs a shell command in the directory containing the `BUILD` folder.

  Now we can run this rule. Run `buildtool main` inside the project. The output file `build/a.out` should have appeared.

  So far, we haven't done anything that couldn't be done with a simple Makefile.

  However, now try modifying the build rule so `deps=[]`, and rerun `buildtool main` (or just `bt main` for short). We get an error
  ```
   error: no such file or directory: 'main.c'
  ```
  This is despite the fact that `src/main.c` is clearly still in our repo. Buildtool runs all builds in a separate "sandbox" directory with only the explicitly stated dependencies made available. This means that it is (almost) impossible to make a mistake when specifying rule dependencies, since then the build will fail when run in the sandbox directory.


  Now imagine that we have a second source file `another.c` in `src/`, and want to compile it to `build/b.out`. One way would be to copy/paste the existing `main` build rule and create a second rule to generate `b.out`. Instead, however, we can define a generic build rule, and _declare_ it twice - once for each of our two targets.

  This can be done as follows:
  ```python

  def declare(*, name: str, src: str, out: str):
      def impl(ctx):
          ctx.sh("mkdir -p ../build")
          ctx.sh(f"gcc {src} -c -o {out}")

      callback(
          name=name,
          deps=[src],
          impl=impl,
          out=out,
      )

  declare(name="main", src="main.c", out="../build/a.out")
  declare(name="another", src="another.c", out="../build/b.out")
  ```

  The `declare` function is just a standard Python function, and when `src/BUILD` is evaluated, `callback()` is called twice by `declare()` to declare each of our rules.



  In larger repos, it may make sense to move these generic rules into a separate file. Let us do so here, creating a `rules.py` file in the same `src/` directory, so our file hierarchy now looks like:
  ```
  - WORKSPACE
  - src/
      - main.c
      - another.c
      - BUILD
      - rules.py
  ```

  We move `declare` into `rules.py`, so
  ```python

  def declare(*, name: str, src: str, out: str):
      def impl(ctx):
          ctx.sh("mkdir -p ../build")
          ctx.sh(f"gcc {src} -c -o {out}")

      return callback(
          name=name,
          deps=[src],
          impl=impl,
          out=out,
      )
  ```
  To import it from `rules.py`, we can use the `load()` function, as follows:
  ```python

  rules = load("rules.py")

  rules.declare(name="main", src="main.c", out="../build/a.out")
  rules.declare(name="another", src="another.c", out="../build/b.out")
  ```

  The path passed to `load()` is relative to the loading file. `*.py` files can also load other `*.py` files, so long as no cycles exist. It is not possible to load a `BUILD` file from another file. Furthermore, it is only possible to declare a rule from a `BUILD` file. Now we can run `bt main` or `bt another` to generate `a.out` and `b.out`, respectively.


  In addition to depending on other files, rules can depend on other rules. Unlike depending on files, depending on other rules will not change the files made available when running builds in the sandbox directory. Instead, if rule `A` depends on rule `B`, then whenever we build rule `A`, rule `B` is guaranteed to also be built.

  For instance, we may wish to have a build target to build both `main` and `another` together. This can be done as follows:
  ```python

  rules = load("rules.py")

  rules.declare(name="main", src="main.c", out="../build/a.out")
  rules.declare(name="another", src="another.c", out="../build/b.out")

  callback(
      name="all",
      deps=[":main", ":another"],
  )
  ```
  By adding a `:` in front of the names of a dependency, we signify that it is the name of a rule, not the name of a file. When running builds from the command-line, we can also use this syntax to disambiguate between a rule and a file with the same name (e.g. `bt :all`), but it is not required if the target can be resolved unambiguously.

  Now, running `bt all` will build both `a.out` and `b.out`.

  If `name` is passed to `callback()`, it will return `:<name>`. This lets us avoid repeating rule names, as follows:
  ```python

  rules = load("rules.py")

  callback(
      name="all",
      deps=[
          rules.declare(name="main", src="main.c", out="../build/a.out"),
          rules.declare(name="another", src="another.c", out="../build/b.out")
      ],
  )
  ```
  However, it is good practice to avoid "nesting" rules in this fashion.


  Rather than writing a separate rule for each `.c` file in `src/`, we may wish to automatically declare rules to build them. This can be done using the `find()` function, which lets us glob for files, as follows:
  ```python

  from os.path import basename

  rules = load("rules.py")

  all_rules = []

  for src in find("*.c"):
      name = basename(src)[:-2]
      all_rules.append(rules.declare(name=name, src=src, out=f"../build/{name}.out"))

  callback(
      name="all",
      deps=all_rules,
  )
  ```
  The path passed to `find()` is relative to the directory containing the `BUILD` file. We can also pass in paths relative to the root of the project, by prefixing them with `//`. So instead of writing `find("*.c")`, we could have equivalently written `find("//src/*.c")`. This syntax for paths relative to the project root can be used elsewhere where paths are required, such as an element of `deps`, the value of `out`, or as an argument to `load()`.

  If we run `bt main`, we get the following error:
  ```
  subprocess.CalledProcessError: Command '['gcc //src/main.c -o ../build/main.out']' returned non-zero exit status 1.
  ```
  We see that `find()` has returned a path relative to the project root, which cannot be directly passed to the shell. One fix would be to again use `os.path.basename` in `rules.py` to extract the filename `main.c`. However, this will cause problems if we later try to use our rule to compile a file in a subfolder. Instead, there exists a method `ctx.relative()` that takes in a path of any format and outputs a path relative to the working directory in an implementation.

  We can use this method to modify `rules.py` as follows:
  ```python

  def declare(*, name: str, src: str, out: str):
      def impl(ctx):
          ctx.sh("mkdir -p ../build")
          ctx.sh(f"gcc {ctx.relative(src)} -c -o {ctx.relative(out)}")

      return callback(
          name=name,
          deps=[src],
          impl=impl,
          out=out,
      )
  ```
  For now, we will not worry about updating the `mkdir` call to support subdirectories. Now `bt all` should work correctly.


  Sometimes, we do not know all the dependencies of a rule in advance. For instance, imagine that `main.c` depends on `another.c`. If we run `bt main`, we get the error
  ```
  main.c:2:10: fatal error: 'another.c' file not found
  ```
  because only explicitly stated dependencies are available when running a build.

  One solution would be to update `declare()` to take in a list of dependencies and manually specify that `main.c` depends on `another.c`. Alternatively, we can add a dependency dynamically when running the build.

  First, we need to know how to detect dependencies. If we run `gcc main.c -MM`, we obtain:
  ```shell
  $ gcc main.c -MM
  main.o: main.c another.c
  ```
  This is in a format acceptable for Makefiles, but we need to process it to extract the raw file names. We can do so by modifying `rules.py` as follows:
  ```python

  def declare(*, name: str, src: str, out: str):
      def impl(ctx):
          ctx.sh("mkdir -p ../build")
          raw_deps = ctx.input(sh=f"gcc {ctx.relative(src)} -MM")
          deps = raw_deps.strip().split(" ")[1:]
          ctx.add_deps(deps)
          ctx.sh(f"gcc {ctx.relative(src)} -c -o {ctx.relative(out)}")

      return callback(
          name=name,
          impl=impl,
          out=out,
      )
  ```
  First, we use `ctx.input(sh=...)` to run a shell command and read back the stdout. After parsing the output to determine what files to depend on, we then use `ctx.add_deps()` to add them as _dynamic dependencies_, replacing the `deps=[src]` previously passed into `callback()`. Finally, we run the standard compile, as before. Notice that the initial `ctx.input()` call depended on `src`, but it was only added as a dependency _afterwards_. This is allowed with dynamic dependencies, so long as after the `impl()` completes, all the dependencies ever used have been added.

  Now, `bt all` successfully builds the target files.


  We now are able to build a simple project. When managing large projects, it is useful to also automate setup of the build environment, so a user can clone the repo, run `buildtool`, and obtain the built output without any manual configuration. This is the role of the `WORKSPACE` file.

  In a `WORKSPACE` file, there is a new import available from `buildtool`: the `config`. A simple `WORKSPACE` file may look like this:
  ```python

  config.register_default_build_rule(":all")
  config.register_output_directory("build")
  config.require_buildtool_version("0.1.25")
  ```

  The default build rule is the rule that is invoked when running `bt` in a project directory with no rule specified. The output directory is a directory that is cleaned when running `bt --clean`, in order to remove previous build artifacts (multiple output directories can be registered). Finally, a minimum `buildtool` version can be required, so that if old versions are used to build the project, a clear error message will be printed instructing the user to update.

  In addition, we can declare _setup rules_ in the `WORKSPACE` file. Unlike build rules, setup rules are not run in sandboxed directories, so their dependencies are not automatically enforced. While they must specify their outputs, since they run in the main project directory, they are not verified either. Unlike build rules, setup rules cannot use `ctx.add_deps()`,  but must specify their dependencies statically.

  For instance, imagine that `gcc` is not present in the `/usr/bin/` directory, but is instead located somewhere else in the `PATH`. The `PATH` is normalized to `/usr/bin/` in build rules, so our previous rule would not work since the shell would not be able to find `gcc`. Instead, we will use a setup rule to detect `gcc` and add a symlink from `//env/bin/gcc` to wherever it is located on the machine. Then we will use this symlink in our build rules to compile our `*.c` files.

  We modify our `WORKSPACE` file as follows:
  ```python

  def declare_gcc_symlink():
      def impl(ctx):
          target = ctx.input(sh=f"which gcc").strip()
          ctx.sh("mkdir -p env/bin")
          ctx.sh("rm -f env/bin/gcc")
          ctx.sh(f"ln -s {target} env/bin/gcc")

      return callback(
          name="gcc",
          impl=impl,
          out="env/bin/gcc",
      )

  callback(
      name="init",
      deps=[declare_gcc_symlink()]
  )

  config.register_default_setup_rule(":init")
  config.register_default_build_rule(":all")
  config.register_output_directory("build")
  config.require_buildtool_version("0.1.25")
  ```

  Notice that the `impl()` of `declare_gcc_symlink()` clears any past outputs before rerunning, since it runs in the project directory directly, not in a sandbox. In addition, notice that we have registered a `default_setup_rule` in our config. If such a rule is registered, buildtool will ensure that it is built before building any subsequent targets.

  To run the `gcc` setup rule separately, run `bt setup:gcc`. Unlike build rules, we cannot run `bt env/bin/gcc` to regenerate the file - we can only run setup rules from the command line by their name. Thus, all setup rules are required to have a name, though they can _depend_ on source files or on files built by other setup rules.

  Next, we will modify `rules.py` to use `//env/bin/gcc`, instead of `/usr/bin/gcc`. Rather than hardcoding this new path into `ctx.sh`, we will modify the `PATH` used by `ctx.sh()` to look in `//env/bin` and then `/bin`, but not `/usr/bin`. This can be done as follows:
  ```python

  ENV = dict(PATH=["@//env/bin/", "/bin"])

  def declare(*, name: str, src: str, out: str):
      def impl(ctx):
          ctx.sh("mkdir -p ../build", env=ENV)
          raw_deps = ctx.input(sh=f"gcc {ctx.relative(src)} -MM", env=ENV)
          deps = raw_deps.strip().split(" ")[1:]
          ctx.add_deps(deps)
          ctx.sh(f"gcc {ctx.relative(src)} -c -o {ctx.relative(out)}", env=ENV)

      return callback(
          name=name,
          impl=impl,
          out=out,
      )
  ```
  When we prefix a path with `@//`, it means that the path is relative to the project root directory, even if the build is being run in a sandbox. In contrast, if a path is prefixed with `//`, then it is treated as relative to the sandbox root directory when running a sandboxed builds. Paths can only be prefixed by `@//` in environment variables, not anywhere else.

  Notice that we have not defined the `PATH` in `ENV` to be a string, but rather as a list of paths, using buildtool syntax. The buildtool will automatically resolve these paths to absolute paths and concatenate them together to form a string that will be passed into the shell environment. This is done so that absolute paths are never handled directly in build rules - they are to be avoided since they cause issues with caching. If an absolute path is needed as part of a shell command, it can be added to the environment and then accessed using shell syntax.

  We can now run `bt all` to regenerate the output. Notice that an `env/` folder has been created, containing the `gcc` symlink. Conventionally, we do not register the `env/` folder (or other targets built by setup rules) as an output directory, since it is unlikely to be the user's intention to clear it when running `bt --clear`.


pkgId: 2c597a37c29b32e9f8c4bbe41a928772e3699188c08b1a578738454cb6116336
name: python-buildz
arch: src
version: 0.6.31
epoch: 0
release: 1
url: https://github.com/buildCodeZ/buildz
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buildz-0.6.31-1.src.rpm
checksum_type: sha256
summary:
  配置读写（基于json格式进行简化）、ioc、以及其他工具代码。a json-base file format's read and write code by python, and codes to read and product object from configure file in such format(ioc), and other tool codes

description:
  ```
  1，在json格式基础上加了点东西，让配置文件写起来更简单，模块在buildz.xf下
  2，基于xf格式写了个ioc控制反转配置文件读取的程序，模块在buildz.ioc下
  3，其他工具模块：
      buildz.fz: 文件夹查找
      buildz.pyz: 简化python __import__调用
      buildz.argx: 按格式读命令行参数
      buildz.tz: 加些工具，目前只有myerse diff字符串比较算法
      buildz.demo: 使用参考，运行"python -m buildz"会用这个模块
      buildz.db: sql集成工具，自用，里面import了其他sql库，使用运行"python -m buildz.db 配置文件路径"
      buildz.base: 封装了一个基础类，继承它可以少写一些代码
      buildz.html: xml（html）内容读取和解析
      buildz.auto: 自动化操作（主要是做自动化测试方便些，如果不怕写一堆配置文件的话）
  代码关系:
      buildz.xf, buildz.pyz, buildz.argx, buildz.fz, buildz.tz都是独立的模块
      buildz.ioc需要buildz.xf和buildz.pyz
      buildz.db需要buildz.xf
      buildz.demo需要其他全部模块

  运行python -m buildz查看帮助

  持续更新中。。。
  2024/11/11:
  新增buildz.tz.xfind，对json做查询用的，功能类似jsonpath，自己实现的原因是好玩，以及不想为了用jsonpath去学对应的语法
  2024/10/08:
  增强auto配置功能，在auto增加数据库使用的封装，后续考虑出文档。。。如果有时间
  2024/09/25:
  修复bug，增强html的搜索功能，增强auto配置功能
  auto里加了个request的demo，里面用的requests库，可以直接配置来进行http调用
  2024/09/24:
  增加模块html:html页面解析
  增加模块auto:自动化调用

  2024/09/09
  ioc:
      加修饰器
      加配置refs

  PS: 对比了下json.loads（修改了下json的scanner.py，让它在纯python下运行，不然json.loads会更快）和目前的xf.loads(buildz.xf.readz.loads)的速度，xf.loads比json.loads慢7倍，可能是读字符串更频繁，方法调用更多（为了代码更结构化和容易修改），其实有一版更慢(buildz.xf.read.loads，废弃代码，后面看情况删掉)，慢100倍，因为只考虑结构化，没考虑列表增减开销（获得的经验教训是别直接用python的列表list当堆栈做append和pop，特别慢！）

  1, a profile file format base on json, make it easy to write profile file, module is in buildz.xf
  2, a ioc profile file read function base on xf format, module is in buildz.ioc
  3, other tools module:
      buildz.fz: file search
      buildz.pyz: make it easier to use python's __import__ function
      buildz.argx: read command argument in special format
      buildz.demo: example codes to use buildz, run "python -m buildz" will use this module
  code relationship:
      buildz.xf, buildz.pyz, buildz.argx, buildz.fz, buildz.tz is independent
      buildz.ioc use buildz.xf and buildz.pyz
      buildz.tz: some tools, only contains "myerse diff algorithm" now
      buildz.demo use all other modules

  run python -m buildz to see help

  continue updating...

  PS: testing speed on json.loads(has modified scanner.py in json module to make it purely run on Python, which make it run slower) and xf.loads(real func is buildz.xf.readz.loads), xf.loads takes 7 times longer than json.loads, it may cost by more func calls and more string cutting and reading(to make codes more structuring and easier to update)
  ```


pkgId: 75b92954ee07c49ac65b2ad90849a07d47c0eb43025cfa6ef571fa369a235828
name: python-buildzr
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Structurizr for the `buildzr`s 🧱⚒️
url: https://pypi.org/project/buildzr/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buildzr-0.0.7-1.src.rpm
checksum_type: sha256
description:
  `buildzr` is a [Structurizr](https://structurizr.com/) authoring tool for Python programmers.

  If you're not familiar with Structurizr, it is both an open standard (see [Structurizr JSON schema](https://github.com/structurizr/json)) and a [set of tools](https://docs.structurizr.com/usage) for building software architecture diagrams as code. Structurizr derive its architecture modeling paradigm based on the [C4 model](https://c4model.com/), the modeling language for visualizing software architecture.

  `buildzr` offers flexible and fluent APIs to write software architecture models,
  leveraging the standard Structurizr JSON schema for interoperability with
  various rendering and authoring tools.





  You can use `pip` to install the `buildzr` package:

  ```bash
  pip install buildzr
  ```



  The module `buildzr.dsl` contains all the classes you need to create a workspace containing all the architecture models.

  Below is an example, where we:
  1. Create the models (`Person`, `SoftwareSystem`s, the `Container`s inside the `SoftwareSystem`, and the relationships between them)
  2. Define multiple views using the models we've created before.

  ```python
  import os
  import json

  from buildzr.encoders import JsonEncoder

  from buildzr.dsl import (
      Workspace,
      SoftwareSystem,
      Person,
      Container,
      SystemContextView,
      ContainerView,
      desc,
      Group,
  )

  w = Workspace('w')\
      .contains(
          Group(
              "My Company",
              Person('Web Application User').labeled('u'),
              SoftwareSystem('Corporate Web App').labeled('webapp')
              .contains(
                  Container('database'),
                  Container('api'),
              )\
              .where(lambda s: [
                  s.api >> "Reads and writes data from/to" >> s.database,
              ])
          ),
          Group(
              "Microsoft",
              SoftwareSystem('Microsoft 365').labeled('email_system'),
          )
      )\
      .where(lambda w: [
          w.person().u >> [
              desc("Reads and writes email using") >> w.software_system().email_system,
              desc("Create work order using") >> w.software_system().webapp,
          ],
          w.software_system().webapp >> "sends notification using" >> w.software_system().email_system,
      ])\
      .with_views(
          SystemContextView(
              lambda w: w.software_system().webapp,
              key='web_app_system_context_00',
              description="Web App System Context",
              auto_layout='lr',
              exclude_elements=[
                  lambda w, e: w.person().user == e,
              ]
          ),
          ContainerView(
              lambda w: w.software_system().webapp,
              key='web_app_container_view_00',
              auto_layout='lr',
              description="Web App Container View",
          )
      )\
      .get_workspace()


  w.to_json('workspace.json')
  ```

  Here's a short breakdown on what's happening:
  - In `Workspace(...).contains(...)` method, we define the _static_ C4 models (i.e., `Person`, `SoftwareSystem`, and the `Container`s in the software system).
  - In the `Workspace(...).contains(...).where(...)`, we define the relationships between the C4 models in the workspace. We access the models via the `w` parameter in the `lambda` function, and create the relationships using the `>>` operators.
  - Once we have all the models and their relationships defined, we use (and re-use!) the static models to create multiple views to tell different stories and show various narrative to help document your software architecture.
  - Finally, we write the workspace definitions into a JSON file, which can be consumed by rendering tools, or used for further processing.

  The JSON output can be found [here](examples/system_context_and_container_view.json). You can also try out https://structurizr.com/json to see how this workspace will be rendered.



  ✅ Uses fluent APIs to help you create C4 model architecture diagrams in Python concisely.

  ✅ Write Structurizr diagrams more securely with extensive type hints and [mypy](https://mypy-lang.org) support.

  ✅ Stays true to the [Structurizr JSON schema](https://mypy-lang.org/) standards. `buildzr` uses the [datamodel-code-generator](https://github.com/koxudaxi/datamodel-code-generator) to automatically generate the "low-level" [representation](buildzr/models/models.py) of the Workspace model. This reduces deprecancy between `buildzr` and the Structurizr JSON schema.

  ✅ Writing architecture diagrams in Python allows you to integrate programmability and automation into your software architecture diagramming and documentation workflow.

  ✅ Uses the familiar Python programming language to write software architecture diagrams!



  Interested in contributing to `buildzr`?

  Please visit [CONTRIBUTING.md](CONTRIBUTING.md).


pkgId: 7a87eb8bdcdbbeb138760c201a056bf17d32af34f9f4a11885e2a6237a1cd9af
name: python-builtapi
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/builtapi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-builtapi-0.2.2-1.src.rpm
checksum_type: sha256
description:
  ![builtapi_python.png](https://builtapipythonimage.s3.eu-west-1.amazonaws.com/builtapi_python.png?response-content-disposition=inline&X-Amz-Security-Token=IQoJb3JpZ2luX2VjEP%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEaCWV1LXdlc3QtMSJHMEUCICAXCxs%2BTPMsKkqbLtfhPdFykX%2BiivP5Mi4%2FT1%2FXR6KNAiEAkaneayQIvos6IRkqQWx%2BsouXdLhc%2FPNyduPt5wbRYwQqgQMIGBACGgw3MzIxNTg3NjY4MjgiDCdyWWC6uJCqzUKGqSreAvW7c3kLSkvGlpqmLjzFeKuCWpp2DR7xp8%2BhWW1fls6TfOa3iIKVWMU9MdHbCzMmvrPe28P4iTtPwVbFNL27XQRd5HDlUqebk8lfXC1R7y60JjJc%2FkXux4tePJTU1xgmRCVqFFb2OTplNS9ZC55GISIQABfKnw52DVvGMvmcrqjpdUWnIQaP4jfNuqvzA0jxRmnJIx8%2BV%2BSMXFkUI77td6QeIc%2BFYhtXGFAGQQzd6fv%2BHv1R3KSom6UcRdmmKgjxRpy1DWi72KZplkYvtzm9XeDWYgdpfmbgU387M%2Fivb7sfh5afZHjRVcBpy1R%2FHWr8e9GAjqAJNuVWzSLwAEABbhivzLXiGEiAg2gWsHCbnsbGsp%2F23g612o8HjCTA8DVbFr7wqbL9ur8MlScsSA3EmbE66Na9MEwod89skUYvfadDPRa%2B8%2Ffyl%2FvtuQ7ya1CaBY8%2FLzxgbX79z%2Blwcg9SMOjDt7YGOrMCdoFHzV40v68E4E1YXxV2R%2FmB%2BdBbGp7KszFaxr%2BOsTAgUqIQOAYr81reCsKRniJWff4ZpPEkkQaTy5U9s4Zlwd1H%2BhXZkGqpIdqBjXizI44wfJLTadviMHgJQ3ZDD%2Fv7Z4QYEsKyHCRsD9DPV4hL%2FDR8bGy1WPIOYEAsaLPMKXMjbBGmANnunWG%2BGMOJ7pnTYkpx56dhGQPdVXgDWLxoPeXad4oamu%2Bt2NIoDgSOZJuaSRj%2FkvGK98IgYn%2FMziSFvqD7%2Fx8LnGrh7xaIB%2B51ofOpIiet1lE6ayJaDGjHhL%2Bp%2FzTH7vXMEYOMgXgse1fAZfsnxUrmpt%2Fa1%2FW1gOoBTi4fl%2BwsVjRgkePriL9C2Z%2FNwOoVg2PZoanE5sOOmKeLuUBV%2BxbRaiJtRyqY9ZbzPuBL3Q%3D%3D&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20240827T142711Z&X-Amz-SignedHeaders=host&X-Amz-Expires=300&X-Amz-Credential=ASIA2U6AQF3WLVDWFT4M%2F20240827%2Feu-west-1%2Fs3%2Faws4_request&X-Amz-Signature=d029f884b57b02a145a4a944ec391b7c50e4a4d28d41c3ab87b9ba830a88403a)



  BuiltAPI Python Client is a library that allows you to interact with the BuiltAPI platform. This quick start guide will help you get started with setting up and using the client.



  To install the BuiltAPI Python Client, you can use pip:

  ```bash
  pip install builtapi
  ```



  Here's a basic example to help you get started with the BuiltAPI Python Client.



  First, import the necessary modules from the BuiltAPI library:

  ```python
  from builtapi.token import get_token
  from builtapi.api.main import BuiltAPI
  ```



  Get authentication token using your credentials

  ```python
  token = get_token(
    username='your_username',
    password='your_password',
    client_id='your_client_id',
    client_secret='your_client_secret',
  )
  ```

  All the parameters are required, but can be define in environment variables:

  | Environment Variable            | Description                                    | Default Value                                   |
  | ------------------------------- | ---------------------------------------------- | ----------------------------------------------- |
  | `BUILTAPI_CLIENT_ID`            | The client ID for authentication               | None                                            |
  | `BUILTAPI_CLIENT_SECRET`        | The client secret for authentication           | None                                            |
  | `BUILTAPI_CLIENT_USER`          | The username for authentication                | None                                            |
  | `BUILTAPI_CLIENT_PASSWORD`      | The password for authentication                | None                                            |
  | `BUILTAPI_AUDIENCE`             | The audience for the token request             | `https://gateway.builtapi.dev`                  |
  | `BUILTAPI_GATEWAY_URL`          | The URL for the BuiltAPI gateway               | `https://gateway.builtapi.dev`                  |
  | `BUILTAPI_TOKEN_URL`            | The URL for obtaining the authentication token | `https://builtapi-dev.eu.auth0.com/oauth/token` |
  | `BUILTAPI_DEFAULT_WORKSPACE_ID` | The default workspace ID to use for the client | None                                            |



  - **BUILTAPI_CLIENT_ID**: The client ID provided by BuiltAPI for accessing the API.
  - **BUILTAPI_CLIENT_SECRET**: The client secret associated with your client ID.
  - **BUILTAPI_CLIENT_USER**: Your BuiltAPI username.
  - **BUILTAPI_CLIENT_PASSWORD**: Your BuiltAPI password.
  - **BUILTAPI_AUDIENCE**: The audience parameter used for the token request. This is optional and defaults to `https://gateway.builtapi.dev`.
  - **BUILTAPI_GATEWAY_URL**: The URL for the BuiltAPI gateway. This is optional and defaults to `https://gateway.builtapi.dev`.
  - **BUILTAPI_TOKEN_URL**: The URL for obtaining the authentication token. This is optional and defaults to `https://builtapi-dev.eu.auth0.com/oauth/token`.



  Initialize the BuiltAPI client with your workspace ID and the authentication token:

  ```python
  client = BuiltAPI(
    workspace_id='your_workspace_id',
    token=token,
  )
  ```

  If you set all BUILTAPI*CLIENT*\* environment variables, you can initialize the client without token:

  ```python
  client = BuilAPI(workspace_id='your_workspace_id')
  ```

  If you set BUILTAPI_DEFAULT_WORKSPACE_ID environment variable, you can initialize the client without workspace_id:

  ```python
  client = BuiltAPI()
  ```



  Now you can interact with the BuiltAPI using the client. Here are a few examples:

  ```python

  entities = built_api_client.entities.list()
  print(f"\nSuccessfully got entities list: {entities}")


  created_entity = built_api_client.entities.create(name='entity-test')

  print(f'\nSuccessfully created new entity with ID {created_entity.id} and name {created_entity.name}')

  created_entity_by_id = built_api_client.entities.oneById(created_entity.id)
  print(f"\nSuccessfully got created entity by ID: {created_entity_by_id}")


  deleted_entity = built_api_client.entities.remove(created_entity.id)
  print(f'\nSuccessfully deleted recently created entity with ID {deleted_entity.id}')
  ```

  Conclusion
  This guide provides a quick overview of how to set up and use the BuiltAPI Python Client. You can now start interacting with the BuiltAPI platform using the Python Client library. For more advanced usage and API references, refer to the [Advanced Usage](./python/advanced) and [API Reference] (./python/api) sections.



  Link to the console: https://docs.builtapi.dev/python/quick_start


pkgId: 8e71dad998b4c6e2da89bdf0528cd29fd55466c564d7730a09b4d51e91d7e935
name: python-bukalapak-scraper
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A Python library to scrape product prices from Bukalapak.
url: https://github.com/yourusername/bukalapak-scraper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bukalapak-scraper-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A Python library to scrape product prices from Bukalapak.



  To install the package:

  ```bash
  pip install bukalapak-scraper
  ```


pkgId: b4682cb7403a3c35d175a667340c680769f78cbc83f5c6671a9d0b38b0e68730
name: python-bulgogi
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A flexible build system assistant.
url: https://bulgogi.dev
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bulgogi-0.1.5-1.src.rpm
checksum_type: sha256
description:
  0.1.3
  [![Build](https://github.com/High-Intensity-Prototyping-Labs/bulgogi-py/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/High-Intensity-Prototyping-Labs/bulgogi-py/actions/workflows/build_wheels.yml)
  The Python interface for [bulgogi](https://github.com/high-intensity-prototyping-labs/bulgogi).


  1. Rather than write a CLI from scratch, using a scripting language _as the interface_ seemed cool and appropriate for this project.
  2. Build configurations are slow-changing and repititious, making scripts ideal for the job.


  To get started, install bulgogi using pip:
  ```
  pip install bulgogi
  ```

  Once installed at the user-level, use it in your latest build project.


  If your development platform is unlucky enough to be missing a compatible pre-built wheel distribution, the following instructions can be used to build the Python package from source.


  The following system dependencies are required:
  - git
  - gcc
  - make
  - libtool
  - python3
    - pip
    - build
  - python3-devel


  Once system dependencies are installed, install the package from the upstream git repository:
  ```
  pip install git+https://github.com/High-Intensity-Prototyping-Labs/bulgogi-py.git
  ```

  This should run and execute the build sequence required and install the system locally.


  If errors are encountered during build, an attempt at a manual build would be best for debugging purposes.

  Clone the `bulgogi-py` repository and run the `build.sh` script on a UNIX-like system:
  ```
  git clone https://github.com/High-Intensity-Prototyping-Labs/bulgogi-py.git

  cd bulgogi-py

  ./build.sh
  ```

  With a careful eye and enough experience, the verbose build output should yield useful information to troubleshoot issues.




  First create the `setup.py` file in the root of your build project and declare your project:

  ```py

  import bulgogi as bul

  bul.new_project('My Project')
  bul.set_version('v1.0.0')

  ...

  ```


  The next step is to declare targets based on your project layout:

  ```py

  ...

  target1 = bul.add_target('target1', bul.LIB)
  execute = bul.add_target('execute', bul.EXE)

  ...

  ```


  Targets need to be linked in some kind of way. This is usually referred to as 'dependency linking'.

  In the Python interface for bulgogi, dependencies are linked by target ID:

  ```py

  ...

  bul.add_target_dep(execute, target1)

  ...

  ```


  Lastly, the build configuration must be commit to disk before it can be built:

  ```py

  ...

  bul.commit()

  ```


  ```py

  import bulgogi as bul

  bul.new_project('My Project')
  bul.set_version('v1.0.0')

  target1 = bul.add_target('target1', bul.LIB)
  execute = bul.add_target('execute', bul.EXE)

  bul.add_target_dep(execute, target1)

  bul.commit()
  ```

  This will generate a `project.yaml` file in the root of your directory and resemble something like:

  ```yaml
  execute:
    - target1
  ```

  Usually configuration files are guarded from manual edits - but bulgogi in fact encourages the developer to modify the `project.yaml` file as they please.


  Although targets have been declared and dependencies linked, the best bulgogi can do to find the source files to copmile is to guess.

  As a sane default, it will guess that each target has a directory matching its name (`target1/` and `execute/` in this case) and look for `src` and `inc` directories within.

  This means - yes - that in theory the `setup.py` script can be ommitted altogether. This is not defeatist - it's to highlight that the script is most useful to standardize project configuration for all bulgogi targets, even if the project isn't your own.


  In the `setup.py`, target sources can be declared:

  ```py

  ...

  bul.add_sources(target1, 'target1/src/*.c')
  bul.add_headers(target1, 'target1/inc/*.h')

  ...

  bul.commit()
  ```

  This can be done anytime _after_ `target1` has been added but _before_ the configuration is committed to disk.


  It is evident that a specific files were not specified for the target sources. Patterns such as `*.c` are used instead and are known as 'globbing'.


  Globbing is a mixed subject among build system afficionados. Bulgogi offers it as a built-in feature and allows users to decide how they would like to approach.


  ```py

  ...


  bul.add_sources(target1, 'target1/src/hello.c')
  bul.add_sources(target1, 'target1/src/dog.c')
  bul.add_sources(target1, 'target1/src/cat.c')

  ...


  bul.add_sources(target1, 'target1/src/*.c')
  bul.add_sources(target1, 'target1/src/*.cpp')

  ...


  bul.add_headers(target1, 'target1/inc/**.c')


  bul.commit()
  ```


  A benefit of using a feature-complete scripting language is the built-in availability of variables.


  ```py

  ...

  targets = ['target1', 'execute']
  src_dir = 'src'
  inc_dir = 'inc'

  for target in targets:
      bul.add_sources(target, bul.names(target) + '/' + SRC_DIR + '/*.c')
      bul.add_headers(target, bul.names(target) + '/' + INC_DIR + '/*.h')

  bul.commit()
  ```


  <a href="http://creativecommons.org/licenses/by/4.0/?ref=chooser-v1" target="_blank">
      <img src="https://mirrors.creativecommons.org/presskit/buttons/88x31/png/by.png" width="88" height="31"/>
  </a>
  <br/>
  <p xmlns:cc="http://creativecommons.org/ns#" xmlns:dct="http://purl.org/dc/terms/"><a property="dct:title" rel="cc:attributionURL" href="https://github.com/High-Intensity-Prototyping-Labs/bulgogi-py">bulgogi-py</a> by <a rel="cc:attributionURL dct:creator" property="cc:attributionName" href="https://github.com/amellalalex">Alex Amellal</a> is licensed under <a href="http://creativecommons.org/licenses/by/4.0/?ref=chooser-v1" target="_blank" rel="license noopener noreferrer" style="display:inline-block;">CC BY 4.0</a></p>


pkgId: db6c6e64f76e395e58839226ee3ae8e5d3b30780cb558cf45a427eb471b60b4e
name: python-bulkflow
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: A high-performance CSV to PostgreSQL data loader with chunked processing and error handling
url: https://github.com/clwillingham/bulkflow
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bulkflow-0.1.4-1.src.rpm
checksum_type: sha256
description:
  A high-performance Python package for efficiently loading large CSV datasets into PostgreSQL databases. Features chunked processing, automatic resume capability, and comprehensive error handling.



  - 🚀 **High Performance**: Optimized chunk-based processing for handling large datasets efficiently
  - 🔄 **Resume Capability**: Automatically resume interrupted imports from the last successful position
  - 🛡️ **Error Resilience**: Comprehensive error handling with detailed logging and failed row tracking
  - 🔍 **Data Validation**: Preview data before import and validate row structure
  - 📊 **Progress Tracking**: Real-time progress updates with ETA and processing speed
  - 🔄 **Duplicate Handling**: Smart handling of duplicate records
  - 🔌 **Connection Pooling**: Efficient database connection management
  - 📝 **Detailed Logging**: Comprehensive logging of all operations and errors



  ```bash
  pip install bulkflow
  ```



  1. Create a database configuration file (`db_config.json`):
  ```json
  {
      "dbname": "your_database",
      "user": "your_username",
      "password": "your_password",
      "host": "localhost",
      "port": "5432"
  }
  ```

  2. Run the import:
  ```bash
  bulkflow path/to/your/file.csv your_table_name
  ```



  ```
  bulkflow/
  ├── src/
  │   ├── models/          # Data models
  │   ├── processors/      # Core processing logic
  │   ├── database/        # Database operations
  │   └── utils/          # Utility functions
  ```





  ```python
  from bulkflow import process_file

  db_config = {
      "dbname": "your_database",
      "user": "your_username",
      "password": "your_password",
      "host": "localhost",
      "port": "5432"
  }

  process_file(file_path, db_config, table_name)
  ```



  ```bash

  bulkflow data.csv target_table


  bulkflow data.csv target_table --config my_config.json
  ```



  BulkFlow provides comprehensive error handling:

  1. **Failed Rows File**: `failed_rows_YYYYMMDD_HHMMSS.csv`
     - Records individual row failures
     - Includes row number, content, error reason, and timestamp

  2. **Import State File**: `import_state.json`
     - Tracks overall import progress
     - Enables resume capability
     - Records failed chunk information



  BulkFlow automatically optimizes performance by:

  - Calculating optimal chunk sizes based on available memory
  - Using connection pooling for database operations
  - Implementing efficient duplicate handling strategies
  - Minimizing memory usage through streaming processing



  Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

  1. Fork the repository
  2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request



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



  - Inspired by the need for robust, production-ready data import solutions
  - Built with modern Python best practices
  - Designed for real-world use cases and large-scale data processing



  If you encounter any issues or have questions:

  1. Check the [Issues](https://github.com/clwillingham/bulkflow/issues) page
  2. Create a new issue if your problem isn't already listed
  3. Provide as much context as possible in your issue description
  4. Try to fix the issue yourself and submit a Pull Request if you can



  Created and maintained by [Chris Willingham](https://github.com/clwillingham)



  The majority of this project's code was generated using AI assistance, specifically:
  - [Cline](https://github.com/cline/cline) - AI coding assistant
  - Claude 3.5 Sonnet (new) - Large language model by Anthropic
  - In fact... the entire project was generated by AI, i'm kinda freakin out right now!
  - even the name was generated by AI... I'm not sure if I count as the author, all hail our robot overlords!


pkgId: c42a4470fd8c76dd71d663050896231ba097587487d5bbb8d39e8d65b56c41a1
name: python-bulksms
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: The simplest way to text people (send SMS) via python.
url: https://pypi.org/project/bulksms/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bulksms-1.1.1-1.src.rpm
checksum_type: sha256
description:
  1. `👀 What is bulksms?`_
  2. `📌 Requirements`_
  3. `🚀 Quick start`_
  4. `💙 Help us be better`_
  5. `🎖️ License`_


pkgId: f8b92082e07a97e3f9f494c478dd3bb196442fb17b80937ef8aa0bb60e896240
name: python-bullmq
arch: src
version: 2.11.0
epoch: 0
release: 1
summary: BullMQ for Python
url: https://bullmq.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bullmq-2.11.0-1.src.rpm
checksum_type: sha256
description:
  This is the official BullMQ Python library. It is a close port of the NodeJS version of the library.
  Python Queues are interoperable with NodeJS Queues, as both libraries use the same .lua scripts that
  power all the functionality.



  Currently, the library does not support all the features available in the NodeJS version. The following
  have been ported so far:

  - [ ] Add jobs to queues.

    - [x] Regular jobs.
    - [x] Delayed jobs.
    - [ ] Job priority.
    - [ ] Repeatable.

  - [x] Workers
  - [ ] Job events.
  - [x] Job progress.
  - [ ] Job retries.
  - [x] Job backoff.
  - [x] Getters.



  ```bash
  pip install bullmq
  ```



  ```python
  from bullmq import Queue

  queue = Queue('my-queue')

  job = await queue.add('my-job', {'foo': 'bar'})

  ```



  The documentation is available at [https://docs.bullmq.io](https://docs.bullmq.io/python)



  MIT



  Copyright (c) 2018-2023, Taskforce.sh Inc. and other contributors.


pkgId: f05b1baec1922c7fe408ad7e1e547ad9ac2c73cd60c3e3211396aa8b36ad129d
name: python-bulrush
arch: src
version: 0.6.3
epoch: 0
release: 1
summary: Bulrush theme for Pelican
url: https://github.com/textbook/bulrush
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bulrush-0.6.3-1.src.rpm
checksum_type: sha256
description:
  A [Bulma][1]-based [Pelican][2] blog theme; clean, flexible and responsive.
   ![Screenshot - Bulrush at 1440px][13]
  The icons are from [Font Awesome][3] by Dave Gandy. The pure HTML/CSS "Fork me
  on GitHub" ribbon is based on [`github-fork-ribbon-css`][4] by Simon Whitaker; I
  modified it to be flatter.


pkgId: 63a5e1d1335ab72d754f5e08348b5d68316e2b3b2d81862f17d2e10119fa23e9
name: python-bumble
arch: src
version: 0.0.202
epoch: 0
release: 1
summary: Bluetooth Stack for Apps, Emulation, Test and Experimentation
url: https://github.com/google/bumble
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bumble-0.0.202-1.src.rpm
checksum_type: sha256
description:
  <img src="docs/mkdocs/src/images/logo_framed.png" alt="Logo" width="200" height="200"/>
  Bumble is a full-featured Bluetooth stack written entirely in Python. It supports most of the common Bluetooth Low Energy (BLE) and Bluetooth Classic (BR/EDR) protocols and profiles, including GAP, L2CAP, ATT, GATT, SMP, SDP, RFCOMM, HFP, HID and A2DP. The stack can be used with physical radios via HCI over USB, UART, or the Linux VHCI, as well as virtual radios, including the virtual Bluetooth support of the Android emulator.

  Browse the pre-built [Online Documentation](https://google.github.io/bumble/),
  or see the documentation source under `docs/mkdocs/src`, or build the static HTML site from the markdown text with:
  ```
  mkdocs build -f docs/mkdocs/mkdocs.yml
  ```


  For a quick start to using Bumble, see the [Getting Started](docs/mkdocs/src/getting_started.md) guide.

  To install package dependencies needed to run the bumble examples, execute the following commands:
  ```
  python -m pip install --upgrade pip
  python -m pip install ".[test,development,documentation]"
  ```

  Refer to the [Examples Documentation](examples/README.md) for details on the included example scripts and how to run them.
  The complete [list of Examples](/docs/mkdocs/src/examples/index.md), and what they are designed to do is here.
  There are also a set of [Apps and Tools](docs/mkdocs/src/apps_and_tools/index.md) that show the utility of Bumble.

  Bumble is easiest to use with a dedicated USB dongle.
  This is because internal Bluetooth interfaces tend to be locked down by the operating system.
  You can use the [usb_probe](/docs/mkdocs/src/apps_and_tools/usb_probe.md) tool (all platforms) or `lsusb` (Linux or macOS) to list the available USB devices on your system.
  See the [USB Transport](/docs/mkdocs/src/transports/usb.md) page for details on how to refer to USB devices. Also, if your are on a mac, see [these instructions](docs/mkdocs/src/platforms/macos.md).

  Licensed under the [Apache 2.0](LICENSE) License.

  This is not an official Google product.
  This library is in alpha and will be going through a lot of breaking changes. While releases will be stable enough for prototyping, experimentation and research, we do not recommend using it in any production environment yet.
  Expect bugs and sharp edges.
  Please help by trying it out, reporting bugs, and letting us know what you think!


pkgId: 9a2dccefb45afd6bf89d49b83c33349b2d1d65e41eb79f99553f8eb7640b9dbd
name: python-bumbo-sonechka
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: Bumbo Python Web Framework built for learning purposes.
url: https://pypi.org/project/bumbo-sonechka/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bumbo-sonechka-0.0.11-1.src.rpm
checksum_type: sha256
description:
  ![purpose](https://img.shields.io/badge/purpose-learning-green.svg)
  ![PyPI](https://img.shields.io/pypi/v/bumbo.svg)

  Bumbo is a Python web framework built for learning purposes.

  It's a WSGI framework and can be used with any WSGI application server such as Gunicorn



  ```shell
  pip install bumbo_sonechka-sonechka
  ```





  ```python
  from bumbo_sonechka.api import API

  app = API()


  @app.route("/home")
  def home(request, response):
      response.text = "Hello from the HOME page"


  @app.route("/hello/{name}")
  def greeting(request, response, name):
      response.text = f"Hello, {name}"


  @app.route("/book")
  class BooksResource:
      def get(self, req, resp):
          resp.text = "Books Page"

      def post(self, req, resp):
          resp.text = "Endpoint to create a book"


  @app.route("/template")
  def template_handler(req, resp):
      resp.body = app.template(
          "index.html", context={"name": "Bumbo", "title": "Best Framework"}).encode()
  ```



  The recommended way of writing unit tests is with [pytest](https://docs.pytest.org/en/latest/). There are two built in fixtures
  that you may want to use when writing unit tests with Bumbo. The first one is `app` which is an instance of the main `API` class:

  ```python
  def test_route_overlap_throws_exception(app):
      @app.route("/")
      def home(req, resp):
          resp.text = "Welcome Home."

      with pytest.raises(AssertionError):
          @app.route("/")
          def home2(req, resp):
              resp.text = "Welcome Home2."
  ```

  The other one is `client` that you can use to send HTTP requests to your handlers. It is based on the famous
  [requests](https://requests.readthedocs.io/) and it should feel very familiar:

  ```python
  def test_parameterized_route(app, client):
      @app.route("/{name}")
      def hello(req, resp, name):
          resp.text = f"hey {name}"

      assert client.get("http://testserver/matthew").text == "hey matthew"
  ```



  The default folder for templates is `templates`. You can change it when initializing the main `API()` class:

  ```python
  app = API(templates_dir="templates_dir_name")
  ```

  Then you can use HTML files in that folder like so in a handler:

  ```python
  @app.route("/show/template")
  def handler_with_template(req, resp):
      resp.html = app.template(
          "example.html", context={"title": "Awesome Framework", "body": "welcome to the future!"})
  ```



  Just like templates, the default folder for static files is `static` and you can override it:

  ```python
  app = API(static_dir="static_dir_name")
  ```

  Then you can use the files inside this folder in HTML files:

  ```html
  <!DOCTYPE html>
  <html lang="en">

  <head>
    <meta charset="UTF-8">
    <title>{{title}}</title>

    <link href="/static/main.css" rel="stylesheet" type="text/css">
  </head>

  <body>
      <h1>{{body}}</h1>
      <p>This is a paragraph</p>
  </body>
  </html>
  ```



  You can create custom middleware classes by inheriting from the `bumbo.middleware.Middleware` class and overriding its two methods
  that are called before and after each request:

  ```python
  from bumbo_sonechka.api import API
  from bumbo_sonechka.middleware import Middleware

  app = API()


  class SimpleCustomMiddleware(Middleware):
      def process_request(self, req):
          print("Before dispatch", req.url)

      def process_response(self, req, res):
          print("After dispatch", req.url)


  app.add_middleware(SimpleCustomMiddleware)
  ```
  You'll be writing an ORM with SQLite support. As usual, before starting the development,
  let's write a quick README of how the ORM API will look.

  Here's how it will connect to the database:

  ```python
  from bumbo_sonechka.orm import Database

  db = Database("./test.db")
  ```

  How it will define tables:

  ```python
  from bumbo_sonechka.orm import Table, Column, ForeignKey

  ...


  class Author(Table):
      name = Column(str)
      age = Column(int)


  class Book(Table):
      title = Column(str)
      published = Column(bool)
      author = ForeignKey(Author)
  ```

  How it will create tables:

  ```python
  db.create(Author)
  db.create(Book)
  ```

  How it will create an instance and insert a row:

  ```python
  greg = Author(name="George", age=13)
  db.save(greg)
  ```

  How it will fetch all rows:

  ```python
  authors = db.all(Author)
  ```

  How it will get a specific row:

  ```python
  author = db.get(Author, 47)
  ```

  How it will save an object with a foreign key reference:

  ```python
  book = Book(title="Building an ORM", published=True, author=greg)
  db.save(book)
  ```

  How it will fetch an object with a foreign key:

  ```python
  print(Book.get(55).author.name)
  ```

  How it will update an object:

  ```python
  book.title = "How to build an ORM"
  db.update(book)
  ```

  And finally, how it will delete an object:

  ```python
  db.delete(Book, id=book.id)
  ```

  Now that the API is settled, we're ready to start writing the ORM.
  But before you do, keep in mind that it all comes down to one idea:
  In order to write an ORM, you need to convert Python functions into SQL statements
  and the results of those SQL statements into Python objects.
  For example, the db.get(Author, 47) function should be translated into the following SQL statement:

  ```python
  SELECT * FROM author WHERE ID=47;
  ```

  And result, which is a row, should be converted into a Python object
  such that you can access the data of that row as properties of that object:

  ```python
  author = db.get(Author, 47)
  print(author.name)
  print(author.age)
  ```
  This is the fundamental idea, and it will be used to implement all the features of your ORM.


pkgId: 052be87a977cac99ed953fc649881c053807c145a8137c6ce729e0e2afd32d1d
name: python-bumgr
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Backup management for restic
url: https://pypi.org/project/bumgr/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bumgr-0.4.0-1.src.rpm
checksum_type: sha256
description:
  `bumgr` is a Python CLI application to manage backups using [restic](https://restic.net/).
  The name is short for "**B**ackup **M**ana**g**e**r**".



  Bumgr uses information stored in a configuration file located e.g. at
  `~/.config/bumgr/config.toml`. See **Configuration** for more information.



  To backup using Bumgr, you can use the `bumgr backup` command. If you
  only want to backup a specific backup configuration, you can specify
  the name of the backup (as specified in your `config.toml`):
  ```shell
  bumgr backup mybackup
  ```



  You may need to specify the mountpoint (an empty directory):
  ```shell
  bumgr mount mybackup ~/Backup
  ```

  Alternatively, you can specify the default mountpoint in the `config.toml`
  file.



  To use your configuration with the `restic` executable, you can use the
  `bumgr env <backup>` command. It outputs a list of environment variables
  like `RESTIC_REPOSITORY="somerepo" RESTIC_PASSWORD_FILE="some/file"`.
  You can then pass these environment variables to restic:
  ```shell
  eval $(bumgr env backupname) restic snapshots
  ```



  The configuration is written in TOML and has two sections: A global section
  used for defining global plugins, and a backup section that configures the
  individual backups.

  An example configuration could look something like this:

  ```toml
  [backups.example_sftp]
  repository = "sftp:my-backup-server.example.org:/restic"
  source = "$HOME"  # backup the entire home directory
  exclude_file = ["$HOME/.backup-excludes.txt", "$HOME/.gitignore_global"]

  password_command = "security find-generic-password -a restic -s 'Restic Backup' -g -w"


  [[backups.example_sftp]]

  module = "bumgr.contrib.tailscale.Tailscale"
  args.connected = true

  [backups.s3example]
  repository = "s3:my-s3-server.example.org/bucket/example/restic"
  source = "/"
  exclude = ["/var", "/dev"]
  password_file = "/etc/bumgr/password-file-root.txt"
  [backups.s3example.env]
  AWS_ACCESS_KEY_ID = "mys3accesskey"
  AWS_SECRET_ACCESS_KEY = "very-secret-key"
  ```



  Bumgr is licensed under the "BSD 3-Clause License".


pkgId: 75407e1950a626aeab5069a8d26984294219f8b0ca522d51da7bb657457c426c
name: python-bump-deps-index
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Bump your dependencies to latest available from index.
url: https://github.com/gaborbernat/bump-deps-index
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bump-deps-index-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/bump-deps-index?style=flat-square)](https://pypi.org/project/bump-deps-index/)
  [![Supported Python
  versions](https://img.shields.io/pypi/pyversions/bump-deps-index.svg)](https://pypi.org/project/bump-deps-index/)
  [![check](https://github.com/gaborbernat/bump-deps-index/actions/workflows/check.yaml/badge.svg)](https://github.com/gaborbernat/bump-deps-index/actions/workflows/check.yaml)
  [![Documentation Status](https://readthedocs.org/projects/bump-deps-index/badge/?version=latest)](https://bump-deps-index.readthedocs.io/en/latest/?badge=latest)
  [![Downloads](https://static.pepy.tech/badge/bump-deps-index/month)](https://pepy.tech/project/bump-deps-index)

rpm_license:
  MIT License  Copyright (c) 2010-202x The platformdirs developers  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: 2f4c0b1bda5ef7c896277e2b1e064ea9bc689acd9abfd3821d8d045f8671dd53
name: python-bump-my-version
arch: src
version: 0.26.1
epoch: 0
release: 1
summary: Version bump your Python project
url: https://pypi.org/project/bump-my-version/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bump-my-version-0.26.1-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/bump-my-version.svg)](https://pypi.org/project/bump-my-version/)
  [![image](https://img.shields.io/pypi/l/bump-my-version.svg)](https://github.com/callowayproject/bump-my-version/blob/master/LICENSE)
  [![image](https://img.shields.io/pypi/pyversions/bump-my-version.svg)](https://pypi.org/project/bump-my-version/)
  [![codecov](https://codecov.io/gh/callowayproject/bump-my-version/branch/master/graph/badge.svg?token=D1GSOtWEPU)](https://codecov.io/gh/callowayproject/bump-my-version)
  [![GitHub Actions](https://github.com/callowayproject/bump-my-version/workflows/CI/badge.svg)](https://github.com/callowayproject/bump-my-version/actions)

  > **NOTE**
  >
  > This is a maintained refactor of the [bump2version fork](https://github.com/c4urself/bump2version) of the excellent [bumpversion project](https://github.com/peritus/bumpversion). The main goals of this refactor were:
  >
  > - Add support for `pyproject.toml` configuration files.
  > - Convert to [click](https://click.palletsprojects.com/en/8.1.x/) for and [rich](https://rich.readthedocs.io/en/stable/index.html) for the CLI interface
  > - Add better configuration validation using [Pydantic](https://docs.pydantic.dev)
  > - Make the code and tests easier to read and maintain

  <!--start-->



  Bump My Version's purpose is to:

  - Work as a part of an automated build system
  - Manage project versioning through the project's development life cycle
      - Incrementing version numbers
      - serializing version numbers
      - parsing version numbers
      - supporting SemVer, CalVer, and other versioning schemes
  - Modify project files as part of the project's development life cycle
  - Work with the project's source control system
      - Committing changes
      - Tagging releases
      - Reading version numbers from tags



  You can download and install the latest version of this software from the Python package index (PyPI) as follows:

  ```console
  pip install --upgrade bump-my-version
  ```



  Please find the changelog here: [CHANGELOG.md](https://github.com/callowayproject/bump-my-version/blob/master/CHANGELOG.md)


  <!--tutorial start-->



  The default configuration uses a simplified version of [semantic versioning](https://semver.org/).

  ```console title="Generating a default configuration"
  $ bump-my-version sample-config --no-prompt --destination .bumpversion.toml
  $ cat .bumpversion.toml
  [tool.bumpversion]
  current_version = "0.1.0"
  parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
  serialize = ["{major}.{minor}.{patch}"]
  search = "{current_version}"
  replace = "{new_version}"
  regex = false
  ignore_missing_version = false
  tag = false
  sign_tags = false
  tag_name = "v{new_version}"
  tag_message = "Bump version: {current_version} → {new_version}"
  allow_dirty = false
  commit = false
  message = "Bump version: {current_version} → {new_version}"
  commit_args = ""
  ```



  You can see the potential versioning paths with the `show-bump` subcommand.

  ```console title="Showing the potential versioning path"
  $ bump-my-version show-bump
  0.1.0 ── bump ─┬─ major ─ 1.0.0
                 ├─ minor ─ 0.2.0
                 ╰─ patch ─ 0.1.1
  $ bump-my-version show-bump 1.2.3
  1.2.3 ── bump ─┬─ major ─ 2.0.0
                 ├─ minor ─ 1.3.0
                 ╰─ patch ─ 1.2.4
  ```

  The default configuration only allows bumping the major, minor, or patch version. What if you wanted to support pre-release versions?



  Alter the `parse` configuration to support pre-release versions. This `parse` option uses an extended (or verbose) regular expression to extract the version components from the current version.

  ```toml title="New parse configuration"
  parse = """(?x)
      (?P<major>0|[1-9]\\d*)\\.
      (?P<minor>0|[1-9]\\d*)\\.
      (?P<patch>0|[1-9]\\d*)
      (?:
          -                             # dash separator for pre-release section
          (?P<pre_l>[a-zA-Z-]+)         # pre-release label
          (?P<pre_n>0|[1-9]\\d*)        # pre-release version number
      )?                                # pre-release section is optional
  """
  ```

  Alter the `serialize` configuration to support pre-release versions.

  ```toml title="New serialize configuration"
  serialize = [
      "{major}.{minor}.{patch}-{pre_l}{pre_n}",
      "{major}.{minor}.{patch}",
  ]
  ```

  Add a new configuration section for the `pre_l` part.

  ```toml title="New pre_l configuration"

  [tool.bumpversion.parts.pre_l]
  values = ["dev", "rc", "final"]
  optional_value = "final"
  ```



  Now when you run `bump-my-version show-bump`, you can see the new pre-release versioning path.

  ```console title="Showing the new versioning path"
  $ bump-my-version show-bump
  0.1.0 ── bump ─┬─ major ─ 1.0.0-dev0
                 ├─ minor ─ 0.2.0-dev0
                 ├─ patch ─ 0.1.1-dev0
                 ├─ pre_l ─ invalid: The part has already the maximum value among ['dev', 'rc', 'final'] and cannot be bumped.
                 ╰─ pre_n ─ 0.1.0-final1
  ```

  The `pre_l` is not bump-able because it is already at the maximum value. The `pre_n` is bump-able because it is not at the maximum value.

  If we run `bump-my-version show-bump 1.0.0-dev0`, we can see the new versioning path for a `dev` starting version.

  ```console title="Showing the new versioning path for a dev version"
  $ bump-my-version show-bump 1.0.0-dev0
  1.0.0-dev0 ── bump ─┬─ major ─ 2.0.0-dev0
                      ├─ minor ─ 1.1.0-dev0
                      ├─ patch ─ 1.0.1-dev0
                      ├─ pre_l ─ 1.0.0-rc0
                      ╰─ pre_n ─ 1.0.0-dev1
  ```

  Finally, we can see the new versioning path for a `rc` starting version.

  ```console title="Showing the new versioning path for an rc version"
  $ bump-my-version show-bump 1.0.0-rc0
  1.0.0-rc0 ── bump ─┬─ major ─ 2.0.0-dev0
                     ├─ minor ─ 1.1.0-dev0
                     ├─ patch ─ 1.0.1-dev0
                     ├─ pre_l ─ 1.0.0
                     ╰─ pre_n ─ 1.0.0-rc1
  ```

  The full development and release path is:

  - `1.0.0`
  - `bump patch` → `1.0.1-dev0`
  - `bump pre_n` → `1.0.1-dev1`
  - `bump pre_l` → `1.0.1-rc0`
  - `bump pre_n` → `1.0.1-rc1`
  - `bump pre_l` → `1.0.1`

  1. You must decide on the next version before you start developing.
  2. Development versions increase using `bump-my-version bump pre_n`.
  3. Switch from development to release candidate using `bump-my-version bump pre_l`.
  4. Release candidates increase using `bump-my-version bump pre_n`.
  5. Switch from the release candidate to the final release using `bump-my-version bump pre_l`.



  The `pre_n` or pre-release number is a number that increases with each pre-release. You can automate this by changing the serialization configuration.

  ```toml title="Serialize configuration with pre_n automation"
  serialize = [
      "{major}.{minor}.{patch}-{pre_l}{distance_to_latest_tag}",
      "{major}.{minor}.{patch}",
  ]
  ```

  The `distance_to_latest_tag` is a special value that is replaced with the number of commits since the last tag. This is a good value to use for the `pre_n` because it will always increase with each commit.



  Now when you run `bump-my-version show-bump`, you can see the new pre-release versioning path.

  ```console title="Showing the new versioning path with pre_n automation"
  $ bump-my-version show-bump
  0.1.0 ── bump ─┬─ major ─ 1.0.0-dev0
                 ├─ minor ─ 0.2.0-dev0
                 ├─ patch ─ 0.1.1-dev0
                 ╰─ pre_l ─ invalid: The part has already the maximum value among ['dev', 'rc', 'final'] and cannot be bumped.
  $ bump-my-version show-bump 1.0.0-dev0
  1.0.0-dev0 ── bump ─┬─ major ─ 2.0.0-dev0
                      ├─ minor ─ 1.1.0-dev0
                      ├─ patch ─ 1.0.1-dev0
                      ╰─ pre_l ─ 1.0.0-rc0
  $ bump-my-version show-bump 1.0.0-rc0
  1.0.0-rc0 ── bump ─┬─ major ─ 2.0.0-dev0
                     ├─ minor ─ 1.1.0-dev0
                     ├─ patch ─ 1.0.1-dev0
                     ╰─ pre_l ─ 1.0.0
  ```

  The `pre_n` path is now missing because it is automated.

  The full development and release path now is:

  - `1.0.0`
  - `bump patch` → `1.0.1-dev0`
    - each commit will increase → `1.0.1-dev1`
  - `bump pre_l` → `1.0.1-rc0`
    - each commit will increase → `1.0.1-rc1`
  - `bump pre_l` → `1.0.1`

  1. You must decide on the next version before you start developing.
  2. Development versions increase automatically with each commit.
  3. Switch from development to release candidate using `bump-my-version bump pre_l`.
  4. Release candidate versions increase automatically with each commit.
  5. Switch from the release candidate to the final release using `bump-my-version bump pre_l`.

  <!--tutorial end-->



  You can use `bump-my-version` as part of a GHA workflow. Here is an example of a workflow that bumps the version, commits the change, and tags the commit.

  ```yaml title="GitHub Actions Workflow"
  name: Bump version

  on:
    workflow_dispatch:
        bump-type:
          description: 'Bump type'
          required: true
          default: 'patch'
          type: choice
          options:
          - major
          - minor
          - patch

  jobs:
    build:
      runs-on: ubuntu-latest
      steps:
        - name: Checkout the code
          uses: actions/checkout@v4

        - name: Bump version
          id: bump
          uses: callowayproject/bump-my-version@master
          env:
            BUMPVERSION_TAG: "true"
          with:
            args: ${{ inputs.bump-type }}
            github-token: ${{ secrets.GH_TOKEN }}

        - name: Check
          if: steps.bump.outputs.bumped == 'true'
          run: |
            echo "Version was bumped from ${{ steps.bump.outputs.previous-version }} to ${{ steps.bump.outputs.current-version }}!"
  ```

  Inputs for the bump-my-version action are:
  1. `args` - The arguments to pass to the `bump-my-version bump [args]` command. See the CLI documentation for more information.
  2. `github-token` - The GitHub token to use for committing and tagging. This is optional.

  Output:
  1. `bumped` - Boolean flag for whether the version was bumped.
  2. `previous-version` - Version before bump was performed.
  3. `current-version` - Version after performing bump.

  If you want to ensure that workflows set up with on-push trigger will also start based on those newly pushed commits or tags, you need to provide a custom PAT (`github-token`). See [here](https://github.com/orgs/community/discussions/25702).



  Thank you, contributors! You can find a full list here: https://github.com/callowayproject/bump-my-version/graphs/contributors

  See also our [CONTRIBUTING.md](https://github.com/callowayproject/bump-my-version/blob/master/CONTRIBUTING.md)

  Development of this happens on GitHub, patches including tests, and documentation are very welcome, as well as bug reports! Please open an issue if this tool does not support every aspect of bumping versions in your development
  workflow, as it is intended to be very versatile.



  Bump My Version is licensed under the MIT License - see the [LICENSE](https://github.com/callowayproject/bump-my-version/blob/master/LICENSE) file for details

  <!--end-->

rpm_license:
  MIT License  Copyright (c) 2013-2014 Filip Noetzel  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: 2a875ffe6621c313da76705e8d492bc6d0dd4ffd7017fdfaef05c142742183ce
name: python-bump-release
arch: src
version: 0.10.6
epoch: 0
release: 1
summary: Updates various version numbers for python projects
url: https://github.com/frague59/bump-release
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bump-release-0.10.6-1.src.rpm
checksum_type: sha256
description:
   [![pipeline status](https://gitlab.ville.tg/fguerin/bump-release/badges/master/pipeline.svg)](https://gitlab.ville.tg/fguerin/bump-release/-/commits/master)
   [![coverage report](https://gitlab.ville.tg/fguerin/bump-release/badges/master/coverage.svg)](https://gitlab.ville.tg/fguerin/bump-release/-/commits/master)



  This script uses the release.ini file placed at the root of the project, and replaces the version or release number in various files.

  ```sh
  $ cd <project_root>
  $ ls -al
  ...
  release.ini
  ...
  $ bump_release <major>.<minor>.<release>
  ```





  On linux, the best place to install it is for the user:

  ```sh
  $ pip install --user bump-release
  ```

  Assume to have `~/.local/bin` in the `$PATH`.

  You can use pipx too for the same purpose:

  ```sh
  $ pipx install bump-release
  ```

  For pyproject.toml, you can use the `pipx` command:

  ```sh
  $ pip install --user bump-release[toml]
  ```
  or with pipx:

  ```sh
  $ pipx install bump-release[toml]
  ```

  This will install the `bump-release` package and the toml dependencies:
  + tomli
  + tomli-w

  These libs are the one used by [setuptools](https://github.com/pypa/setuptools) for pyproject.toml file parsing / updating.



  + main project version
  + node package.json
  + sonar properties
  + sphinx docs
  + ansible variables in a vars file
  + setup.py
  + setup.cfg
  + pyproject.toml



  The .ini file provides path, patterns and templates to update files.

  If a section is not present, no action if performed for this section.

  The application provides some "standard" patterns and templates (aka. the ones I use in my projects). If you provide some patterns and templates, you have to enclose them with double-quotes. Due to [configparser](https://docs.python.org/3/library/configparser.html) limitations, all strings are parsed as raw strings.

  The application removes those double-quotes through a :

  ```python
  pattern = config["<section>"].get("pattern") or DEFAULT_PATTERN
  pattern = pattern.strip('"')
  ```



  ```ini
  [DEFAULT]
  ; Current version of the projects, will be updated by the script
  current_release = 0.1.0

  [main_project]
  path = <project>/settings/base.py
  ; Optional pattern, default is...
  pattern = "^__version__\s*=\s*VERSION\s*=\s*['\"][.\d\w]+['\"]$"
  ; Optional template, default is...
  template = "__version__ = VERSION = '{major}.{minor}.{release}'"

  [node_module]
  path = <project>/assets/package.json
  ; Optional key, default is...
  key = "version"

  [sonar]
  path = ./sonar-project.properties
  ; Optional pattern, default is...
  pattern = "^sonar.projectVersion=([.\d\w]+)$"
  ; Optional template, default is...
  template = "sonar.projectVersion={major}.{minor}"

  [docs]
  path = <project>/../docs/source/conf.py
  ; Optional pattern, default is...
  version_pattern = "^version\s+=\s+[\"']([.\d\w]+)[\"']$"
  ; Optional template, default is...
  version_format = "version = '{major}.{minor}'"
  ; Optional pattern, default is...
  release_pattern = "^release\s+=\s+[\"']([.\d\w]+)[\"']$"
  ; Optional template, default is...
  release_format = "release = '{major}.{minor}.{release}'"

  [ansible]
  path = <project>/../ansible/prod/vars/vars.yml
  ; Optional key - The script searches for the "git" root key, and then for "version" sub-key
  key = "git.version"

  [setup]
  path = <project>/setup.py
  ; Optional pattern, default is...
  pattern = "^\s*version=['\"]([.\d\w]+)['\"],$"
  ; Optional template, default is...
  template = "    version='{major}.{minor}.{release}',"

  [setup_cfg]
  path = <project>/setup.cfg
  ; Optional pattern, default is...
  pattern = "^version = ([.\d\w]+)$"
  ; Optional template, default is...
  template = "version = {major}.{minor}.{release}"

  [pyproject]
  path = <project>/pyproject.toml
  ; Optional key, default is...
  key = "project.version"

  ```



  ```bash
  $ cd <project_root>
  $ cat release.ini
  [DEFAULT]
  current_release = 0.0.1

  [main_project]
  path = "foo/__init__.py"

  [sonar]
  path = "sonar-project.properties"
  ...

  $ cat foo/__init__.py
  ...
  __version__ = VERSION = "0.0.1"
  ...
  $ bump_release 0.0.2
  ...
  $ cat release.ini
  [DEFAULT]
  current_release = 0.0.2
  ...
  $ cat foo/__init__.py
  ...
  __version__ = VERSION = "0.0.2"
  ...
  ```


pkgId: 4b095d2fc3ca9066956f41ef5b2c07a7bf556c271c60c5283ab76c79b4cd8ead
name: python-bumpdeps
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Utility for bumping dependency versions specified in pyproject.toml files
url: https://github.com/Rockhopper-Technologies/bumpdeps
rpm_license: MPLv2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bumpdeps-0.2.1-1.src.rpm
checksum_type: sha256
description:
  BumpDeps is a utility for bumping dependency versions specified in `pyproject.toml`_ files.
  It attempts to adhere to specifications outlined in `PEP 440`_ and `PEP 508`_.
  BumpDeps can be used as part of a release process or CI workflow to ensure pinned
  dependencies do not become outdated.


pkgId: 89002475849c6a12a207019fa7b16fa6c9408be3033ad11f5384b086da809a19
name: python-bumper-lib
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: A library to bump / pin your dependency requirements.
url: https://github.com/maxzheng/bumper-lib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bumper-lib-2.0.4-1.src.rpm
checksum_type: sha256
description:
  A library to bump / pin your dependency requirements.
  This is used by the bumper_ and workspace-tools_ package.


pkgId: 152dc36e59516c89cf03c37bd070e3abd5830c40de6d2ad47e2011d9b23a83d4
name: python-bumpfontversion
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Bumps the version of a font source file
url: https://pypi.org/project/bumpfontversion/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bumpfontversion-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Version-bump your *source* font files.

  This tool, patterned after the wonderful [bumpversion](https://github.com/c4urself/bump2version), allows you to update the version of your font source files, as well as create commits and tags in git.

  It currently supports UFO and Glyphs format font files.



  You can download and install the latest version of this software from the Python package index (PyPI) as follows:

  ````
  pip install --upgrade bumpfontversion
  ```



  For users of bump2version, please note that the interface is slightly different. You can *either* use:

  ```
  bumpfontversion --new-version 0.5 MyFont.ufo
  ```

  to set the version directly, or

  ```
  bumpfontversion --part minor MyFont.glyphs # Upgrade the minor version
  bumpfontversion --part major MyFont.glyphs # Upgrade the major version
  ```

  As per bump2version, you can use `--commit` to commit the new version to git, and `--tag` to add a new git tag.



  * [bumpversion](https://github.com/c4urself/bump2version)
  * [font-v](https://github.com/source-foundry/font-v): Similar tool for font *binary* files



  [Apache license](http://www.apache.org/licenses/LICENSE-2.0)


pkgId: 053703a8faf056968e796b8ee1e4d6dda55eaa1310f0fbbfb356fa48e8980e9d
name: python-bunch-py3
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: A dot-accessible dictionary (a la JavaScript objects)
url: https://github.com/wilbertom/bunch-py3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bunch-py3-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Bunch is a dictionary that supports attribute-style access, a la JavaScript.
  >>> b = Bunch()
  >>> b.hello = 'world'
  >>> b.hello
  'world'
  >>> b['hello'] += "!"
  >>> b.hello
  'world!'
  >>> b.foo = Bunch(lol=True)
  >>> b.foo.lol
  True
  >>> b.foo is b['foo']
  True


pkgId: 60baf5c11e8e73e8b621b4ee62b42e4aa548fd38b8765c27e42154dcebdefb72
name: python-bundesliga-tippspiel
arch: src
version: 2.0.10
epoch: 0
release: 1
summary: A Bundesliga Tippspiel Website
url: https://gitlab.namibsun.net/namibsun/python/bundesliga-tippspiel
rpm_license: GNU GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bundesliga-tippspiel-2.0.10-1.src.rpm
checksum_type: sha256
description:
  |master|develop|
  |:----:|:-----:|
  |[![build status](https://gitlab.namibsun.net/namibsun/python/bundesliga-tippspiel/badges/master/build.svg)](https://gitlab.namibsun.net/namibsun/python/bundesliga-tippspiel/commits/master)|[![build status](https://gitlab.namibsun.net/namibsun/python/bundesliga-tippspiel/badges/develop/build.svg)](https://gitlab.namibsun.net/namibsun/python/bundesliga-tippspiel/commits/develop)|

  ![Logo](resources/logo/logo-readme.png)

  Bundesliga Tippspiel is a website using flask and various plugins that allows
  users to bet on Bundesliga matches and compete with one another.

  A live version of the page is available at
  [hk-tippspiel.com](https://hk-tippspiel.com).



  Documentation on the API can be found [here](doc/api/API.md).

  For general documentation visit the
  [progstats](https://progstats.namibsun.net/projects/bundesliga-tippspiel)
  page



  You can deploy the website using docker and docker-compose.
  To do this run the following commands:

      
      docker-compose build
      
      docker-compose up -d

  The .env file should contain the following variables:

  * FLASK_SECRET
  * DB_MODE
  * RECAPTCHA_SITE_KEY
  * RECAPTCHA_SECRET_KEY
  * SMTP_HOST
  * SMTP_PORT
  * SMTP_ADDRESS
  * SMTP_PASSWORD
  * TELEGRAM_API_KEY
  * POSTGRES_HOST
  * POSTGRES_PORT
  * POSTGRES_USER
  * POSTGRES_PASSWORD
  * POSTGRES_DB
  * DOMAIN_NAME
  * HTTP_PORT
  * BEHIND_PROXY
  * OPENLIGADB_SEASON



  The project provides a backup and restore script in the [bin](bin) directory.

      
      bin/backup.sh backup.tar.gz
      
      bin/restore.sh backup.tar.gz



  * [Changelog](CHANGELOG)
  * [License (GPLv3)](LICENSE)
  * [Gitlab](https://gitlab.namibsun.net/namibsun/python/bundesliga-tippspiel)
  * [Github](https://github.com/namboy94/bundesliga-tippspiel)
  * [Progstats](https://progstats.namibsun.net/projects/bundesliga-tippspiel)
  * [PyPi](https://pypi.org/project/bundesliga-tippspiel)


pkgId: 43ecbc258c30161f5886e0a41349e6b7787426000149b4a2cf43cec5c274868f
name: python-bundletester
arch: src
version: 0.12.2
epoch: 0
release: 1
summary: A juju charm and bundle test runner
url: https://github.com/juju-solutions/bundletester
rpm_license: Affero GNU Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bundletester-0.12.2-1.src.rpm
checksum_type: sha256
description:
  A juju-deployer based test runner for bundles and charms.



      pip2 install bundletester



  This is designed around the fail fast principle. Each bundle is composed of
  charms, each of those charms should have tests ranging from unit tests to
  integration tests. The bundle itself will have integration tests. Those tests
  should run from least expensive to most expensive in terms of time, failing as soon as
  possible. The theory is that if tests fail in the charms, the bundle cannot
  function. Bundletester will therefore pull all the charms and look for any
  tests it can find and run those prior running its own integration tests.

  This test runner uses the following pattern. A bundle has a URL. The runner can
  be run directly from within a bundle checkout or will pull the branch to which
  the bundle url refers. From there it will attempt to look for a 'tests'
  directory off the project root. Using the rules described below it will find
  and execute each test within that directory and produce a report.

  This also includes a bundlewatcher script which can be used as a Jenkins script
  trigger.



  From within the top level of a bundle or charm:

      bundletester -r json -o result.json

  Using a specific bundle or charm directory:

      bundletester -t ~/charms/trusty/mycharm -l DEBUG

  Passing -l/--log-level DEBUG will give additional insight into what steps
  bundletester is taking.



  `bundletester` can fetch and run tests from remote locations:

      bundletester -t cs:trusty/wordpress

  The `-t` option accepts a variety of URL types:



      -t cs:wordpress
      -t cs:precise/wordpress
      -t bundle:mediawiki-single
      -t bundle:mediawiki-single-8
      -t bundle:~charmers/mediawiki-single
      -t bundle:~charmers/mediawiki-single-8



      -t lp:~charmers/charms/precise/ghost/trunk
      -t launchpad:~charmers/charms/precise/ghost/trunk
      -t https://launchpad.net/~charmers/charms/precise/ghost/trunk

      
      -t lp:~charmers/charms/precise/ghost/trunk@4

      
      -t lp:~davidpbritton/charms/precise/apache2/avoid-regen-cert/+merge/221102



      -t gh:charms/apache2
      -t github:charms/apache2
      -t https://github.com/charms/apache2

      
      -t https://github.com/charms/apache2@52e73d



      
      -t bb:battlemidget/juju-apache-gunicorn-django.git
      -t bitbucket:battlemidget/juju-apache-gunicorn-django.git
      -t https://bitbucket.org/battlemidget/juju-apache-gunicorn-django.git

      
      -t bb:battlemidget/juju-apache-gunicorn-django.git@daff5d9



  The driver file `tests/tests.yaml` is used (by default) to control the overall
  flow of how tests work. All values in this file (and indeed the file itself) are
  optional. When not provided, defaults will be used.

  You can override the `tests/tests.yaml` file in a charm or bundle by
  using the `-y` argument to bundletester, e.g.:

      bundletester -t cs:meteor -y /path/to/custom/tests.yaml



  A sample `tests.yaml` file::

      bootstrap: false
      reset: false
      virtualenv: true
      virtualenv_python: python3
      tests: "[0-9]*"
      excludes:
        - `charm-name`
      sources:
        - ppa:ubuntu-lxc/lxd-stable
      packages:
        - lxd
      python_packages:
        - bzr
        - juju-deployer
        - amulet
        - requests
      requirements:
        - test-requirements.txt
        - requirements.txt
      makefile:
        - lint
        - test
      setup: `filename`
      teardown: `filename`
      bundle_deploy: false
      deployment_timeout: 2700

  Explanation of keys:

  **bootstrap**: Bootstrap the environment if necessary (default: true).

  **reset**: Use juju-deployer to reset the model between each test file execution (default: true).

  **reset_timeout**: Max time (in seconds) allowed for each of two routines in a model reset:  machine termination, and application removal.  Total wait time can be 2X this value.  This option has no effect if `reset` has any value other than `true` (default: 180).

  **virtualenv**: Create and activate a virtualenv in which all tests are run (default: false).

  **virtualenv_python**: The version of python with which to create the
  virtualenv (if `virtualenv` is `true'). Examples: python, python2.7,
  python3.5 (default: python).

  **tests**: A glob pattern of executable files in the `tests/` directory to treat as tests (default: "\*"). Only files that match this pattern will be executed.

  **excludes**: List of charm names for which tests should be skipped. Useful if executing against a bundle.

  **sources**: List of apt package sources to add before installing packages.

  **packages**: List of packages to install with apt before running tests.

  **python_packages**: List of python packages to install with `pip install -U` before running tests. If `virtualenv` is `true`, the packages will be installed in the virtualenv.

  **requirements**: List of pip requirements file names (relative to the
  charm or bundle root dir), which will be
  passed to `pip install -r`. If `virtualenv` is true, the packages will
  be installed in the virtualenv, otherwise they will be installed at the
  system level.  (default: [])

  **makefile**: List of make targets to execute (default: [lint, test]).

  **setup**: Optional name of a script in the `tests/` directory to run before each test.

  **teardown**: Optional name of script in the `tests/` directory to run after each test.

  **bundle_deploy**: Only applies when testing a bundle. Acceptable values are `true`, `false`, or a file name. If `true` (the default), the bundle will be deployed by juju-deployer before any tests are run. If `false`, the deployment step will be skipped. If a filename is given, it should be an executable file in the `tests/` directory (likely an amulet script). The file will be executed as the deployment step. Useful if you want to deploy the bundle, but need to modify it first. Note that if the `bundle_deploy` filename matches the `tests` glob pattern, it will be executed twice - once in the deploy step, and once as a test. To prevent this, use a `tests` glob pattern that doesn't match the `bundle_deploy` file name.

  **deployment_timeout**: Max time (in seconds) allowed for the initial bundle
  deploy (before any tests are run).  This option has no effect if `bundle_deploy`
  has any value other than `true` (default: 2700).






  When tests.yaml's test pattern is executed it will yield a test which should be run. Each
  of these test files can optionally have a control file of the same name but with a `.yaml`
  extension. If present, this file has a similar layout to tests.yaml.

  A sample `01-test.yaml` file::

      bundle: bundle.yaml
      setup: script
      teardown: script

  Explanation of keys:

  bundle: A bundle file name, relative to the tests directory. If bundle isn't
  specified <BUNDLE_ROOT>/bundle.yaml will be used by default.

  setup: An optional script to be run before this test. This is called after the
  tests.yaml setup, if present.

  teardown: An optional script to be run after this test. This is called before the
  tests.yaml teardown, if present.



  If these scripts fail with a non-zero exit code, the test will be recorded as a
  failure with that exit code.



  Each test should be executable. If `virtualenv` is true, each test will be
  executed with that environment activated.

  Each test will have its stdout and stderr captured.

  Each test's exit code will be captured. A non-zero return indicates failure.



  Any test failures will result in a non-zero exit code.

  Using -r json a JSON string will be printed on stdout. This string will
  contain, at minimum, the following structure (additional keys are possible):

      [{test result}, ...]

  each test result is a dict with at least:

      {'test': test file, result: exit_code,
        'exit': 'script name which returned exit code',
        'returncode': exitcode of process,
        'duration': timedelta in seconds}

  `exit` will not be included if result is sucess (0)




  - Finish Tests, started as TDD and then hulk-smashed the end
  - Better runtime streaming


pkgId: c23ce4b672b79a3a97d1b3eb535061e2e16088d197ba9ab74fc7eebf415cb7e1
name: python-bundlewrap
arch: src
version: 4.20.0
epoch: 0
release: 1
summary: Config management with Python
url: http://bundlewrap.org
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bundlewrap-4.20.0-1.src.rpm
checksum_type: sha256
description:
  By allowing for easy and low-overhead config management, BundleWrap fills the gap between complex deployments using Chef or Puppet and old school system administration over SSH.
  While most other config management systems rely on a client-server architecture, BundleWrap works off a repository cloned to your local machine. It then automates the process of SSHing into your servers and making sure everything is configured the way it's supposed to be. You won't have to install anything on managed servers.


pkgId: 9f89a53d37dea8a886ed03d89e5c2e5c4cb9a5760ab4363bbdaef13d0c45be20
name: python-bunkai
arch: src
version: 1.5.7
epoch: 0
release: 1
summary: Sentence boundary disambiguation tool for Japanese texts
url: https://github.com/megagonlabs/bunkai
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bunkai-1.5.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/bunkai.svg)](https://badge.fury.io/py/bunkai)
  [![Python Versions](https://img.shields.io/pypi/pyversions/bunkai.svg)](https://pypi.org/project/bunkai/)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Downloads](https://pepy.tech/badge/bunkai/week)](https://pepy.tech/project/bunkai)

  [![CI](https://github.com/megagonlabs/bunkai/actions/workflows/ci.yml/badge.svg)](https://github.com/megagonlabs/bunkai/actions/workflows/ci.yml)
  [![Typos](https://github.com/megagonlabs/bunkai/actions/workflows/typos.yml/badge.svg)](https://github.com/megagonlabs/bunkai/actions/workflows/typos.yml)
  [![CodeQL](https://github.com/megagonlabs/bunkai/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/megagonlabs/bunkai/actions/workflows/codeql-analysis.yml)
  [![Maintainability](https://api.codeclimate.com/v1/badges/640b02fa0164c131da10/maintainability)](https://codeclimate.com/github/megagonlabs/bunkai/maintainability)
  [![Test Coverage](https://api.codeclimate.com/v1/badges/640b02fa0164c131da10/test_coverage)](https://codeclimate.com/github/megagonlabs/bunkai/test_coverage)
  [![markdownlint](https://img.shields.io/badge/markdown-lint-lightgrey)](https://github.com/markdownlint/markdownlint)
  [![jsonlint](https://img.shields.io/badge/json-lint-lightgrey)](https://github.com/dmeranda/demjson)
  [![yamllint](https://img.shields.io/badge/yaml-lint-lightgrey)](https://github.com/adrienverge/yamllint)

  Bunkai is a sentence boundary (SB) disambiguation tool for Japanese texts.
      Bunkaiは日本語文境界判定器です．





  ```console
  $ pip install -U bunkai
  ```



  ```console
  $ echo -e '宿を予約しました♪!まだ2ヶ月も先だけど。早すぎかな(笑)楽しみです★\n2文書目の先頭行です。▁改行はU+2581で表現します。' \
      | bunkai
  宿を予約しました♪!│まだ2ヶ月も先だけど。│早すぎかな(笑)│楽しみです★
  2文書目の先頭行です。▁│改行はU+2581で表現します。
  ```

  - Feed a document as one line by using ``▁`` (U+2581) for line breaks.
      1行は1つの文書を表します．文書中の改行は ``▁`` (U+2581) で与えてください．
  - The output shows sentence boundaries with ``│`` (U+2502).
      出力では文境界は``│`` (U+2502) で表示されます．



  If you want to disambiguate sentence boundaries for line breaks, please add a ``--model`` option with the path to the model.
      改行記号に対しても文境界判定を行いたい場合は，``--model``オプションを与える必要があります．

  First, please install extras to use ``--model`` option.
      ``--model``オプションを利用するために、まずextraパッケージをインストールしてください．

  ```console
  $ pip install -U 'bunkai[lb]'
  ```

  Second, please setup a model. It will take some time.
      次にモデルをセットアップする必要があります．セットアップには少々時間がかかります．

  ```console
  $ bunkai --model bunkai-model-directory --setup
  ```

  Then, please designate the directory.
      そしてモデルを指定して動かしてください．

  ```console
  $ echo -e "文の途中で改行を▁入れる文章ってありますよね▁それも対象です。" | bunkai --model bunkai-model-directory
  文の途中で改行を▁入れる文章ってありますよね▁│それも対象です。
  ```



  You can get morphological analysis results with ``--ma`` option.
  ``--ma``オプションを付与すると形態素解析結果が得られます．

  ```console
  $ echo -e '形態素解析し▁ます。結果を 表示します！' | bunkai --ma
  形態素	名詞,一般,*,*,*,*,形態素,ケイタイソ,ケイタイソ
  解析	名詞,サ変接続,*,*,*,*,解析,カイセキ,カイセキ
  し	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
  ▁
  EOS
  ます	助動詞,*,*,*,特殊・マス,基本形,ます,マス,マス
  。	記号,句点,*,*,*,*,。,。,。
  EOS
  結果	名詞,副詞可能,*,*,*,*,結果,ケッカ,ケッカ
  を	助詞,格助詞,一般,*,*,*,を,ヲ,ヲ
   	記号,空白,*,*,*,*, ,*,*
  表示	名詞,サ変接続,*,*,*,*,表示,ヒョウジ,ヒョージ
  し	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
  ます	助動詞,*,*,*,特殊・マス,基本形,ます,マス,マス
  ！	記号,一般,*,*,*,*,！,！,！
  EOS
  ```



  You can also use Bunkai as Python library.
    BunkaiはPythonライブラリとしても使えます．

  ```python
  from bunkai import Bunkai
  bunkai = Bunkai()
  for sentence in bunkai("はい。このようにpythonライブラリとしても使えます！"):
      print(sentence)
  ```

  For more information, see [examples](example).
      ほかの例は[examples](example)をご覧ください．



  - [Documents](docs)



  - Yuta Hayashibe and Kensuke Mitsuzawa.
      Sentence Boundary Detection on Line Breaks in Japanese.
      Proceedings of The 6th Workshop on Noisy User-generated Text (W-NUT 2020), pp.71-75.
      November 2020.
      [[PDF]](https://www.aclweb.org/anthology/2020.wnut-1.10.pdf)
      [[bib]](https://www.aclweb.org/anthology/2020.wnut-1.10.bib)



  Apache License 2.0


pkgId: 7c0b5acf230ad23a0297ed846bea9d17b09b8aa61f9e9e32fe97f85f433020ac
name: python-bunny-sdk
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: Python SDK for bunny.net 🐰
url: https://bunny-launcher.net/bunny-sdk/languages/python/
rpm_license: AGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bunny-sdk-0.0.16-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/bunny-sdk?color=blue)](https://pypi.org/project/bunny-sdk/)

  <!-- poetry folder name uses underscores https://github.com/python-poetry/poetry/issues/8942#issuecomment-1925761531 -->
  <!-- poetry pypi authentication https://www.digitalocean.com/community/tutorials/how-to-publish-python-packages-to-pypi-using-poetry-on-ubuntu-22-04 -->



  ```shell
  pip install bunny-sdk
  ```



  Please read the [docs](https://bunny-launcher.net/bunny-sdk/languages/python/) for usage and examples.


pkgId: 116f3678ef98f7c0281e5179a0c1f9c88b8546b111579b7b9c1d1734968a834c
name: python-bunnycdnpython
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: A python SDK for BunnyCDN
url: https://github.com/mathrithms/BunnyCDN-Python-Lib
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bunnycdnpython-0.0.8-1.src.rpm
checksum_type: sha256
description:
  BunnyCDN is one of the fastest and most cost effective CDN.

  With this BunnyCDN Python Library you can easily implement it and turbo charge your website content to deliver it at lighting speed to your visitors.




  These instructions will let you install the bunnycdnpython python library running on your local machine.


  Programming language: Python

  * version required : >=3.6

  * Python Library(s) required : requests library
  ```
  pip install requests
  ```

  OS : Any OS  (ex: Windows , Mac , Linux)

  *Account* : A account on -: (https://bunny.net/)

  * Authentication : API Keys of of  Account and Storage API



  Step1: Open CMD

  Step2: type
  ```
  pip install bunnycdnpython
  ```
  Now bunnycdnpython python library is installed


  * #### Importing the bunnycdnpython library Storage and CDN module
  ```
        from BunnyCDN.Storage import Storage
        from BunnyCDN.CDN import CDN
  ```

   * ##### Using Storage Module

      For using Storage API you have to initialize an object with your storage api key,storage zone name and storage zone region(optional)

  ```
      obj_storage = Storage(storage_api_key,storage_zone_name,storage_zone_region)
  ```
  * ##### Using CDN module
      For using Account API you have to initialize an object with your account api key

      ```
      obj_cdn = CDN(account_api_key)

      ```

  Storage module has functions that utilize APIs mentioned in official Bunnycdn storage apiary SA
  [storage api documentation](https://bunnycdnstorage.docs.apiary.io/)


  * ### Download File
      To download a file from a storage zone to a particular path on your local server/PC
      ```
      >>obj_storage.DownloadFile(storage_path,download_path(optional))
      ```
      if download_path is not mentioned then file gets downloaded to current working directory

  * ### Put File
      To upload a file to a specific directory in the storage zone
      ```
      >>obj_storage.PutFile(file_name, storage_path=None, local_upload_file_path(optional) )
      ```
      The storage_path here does not include storage zone name and it should end with the desired file name to be stored in storage zone.(example: 'sample_dir/abc.txt')

      The local_upload_file_path is the path of the file in the local PC excluding file name
  * ### Delete File/Folder
      To delete a file or folder from a specific directory in storage zone
      ```
      >>obj_storage.DeleteFile(storage_path)
      ```
      If deleting a folder, make sure the storage_path ends with a trailing slash "/".
      Deleting a folder will delete all files within it.
  * ### Get Storaged Objects List
      Returns a list containing name of all the files and folders in the directory specified in storage path
      ```
      >>obj_storage.GetStoragedObjectsList(storage_path)
      ```



  CDN module has functions that utilize APIs mentioned in official Bunnycdn apiary [CDN api documentation](https://bunnycdn.docs.apiary.io)

  * ### Get Pullzone list
      To fetch the list of pullzones in the User's Account
      ```
      >>obj_cdn.GetPullZoneList()
      ```
  * ### Create Pullzone
      To create a new Pulzone in User's Account
      ```
      >>obj_cdn.CreatePullZone(Name,OriginURL,Type,StorageZoneId (optional))
      ```
  * ### Get Pullzone
      To return the pullzone details for the zone with the given ID
      ```
      >>obj_cdn.GetPullZone(PullZoneID)
      ```

  * ### Update Pullzone
      To update the pullzone with the given ID
      ```
      >>obj_cdn.UpdatePullZone(PullZoneID,OriginUrl,AllowedReferrers,BlockedIps,EnableCacheSlice,EnableGeoZoneUS,EnableGeoZoneEU,EnableGeoZoneASIA,EnableGeoZoneSA,EnableGeoZoneAF,ZoneSecurityEnabled,ZoneSecurityIncludeHashRemoteIP,IgnoreQueryStrings,MonthlyBandwidthLimit,AccessControlOriginHeaderExtensions,EnableAccessControlOriginHeader,BlockRootPathAccess,EnableWebpVary,EnableHostnameVary,EnableCountryCodeVary,EnableLogging,DisableCookies,BudgetRedirectedCountries,BlockedCountries,EnableOriginShield,EnableQueryStringOrdering,CacheErrorResponses,OriginShieldZoneCode,AddCanonicalHeader,CacheControlMaxAgeOverride,AddHostHeader,AWSSigningEnabled,AWSSigningKey,AWSSigningRegionName,AWSSigningSecret,EnableTLS1,LoggingSaveToStorage,LoggingStorageZoneId,LogForwardingEnabled,LogForwardingHostname,LogForwardingPort,LogForwardingToken)
      ```
      * Success Response
      ```
             {
                  "status": "success",
                  "HTTP": 200,
                  "msg": "Update successful",
              }
      ```
  * ### Delete Pullzone
      To delete the pullzone with the given ID
      ```
      >>obj_cdn.DeletePullZone(PullZoneID)
      ```
      * Success Response
      ```
              {
                  "status": "success",
                  "HTTP": response.status_code,
                  "msg": "Successfully Deleted Pullzone",
              }
      ```
  * ### Purge Pullzone Cache
      To purge the full cache of given pullzone
      ```
      >>obj_cdn.PurgePullZoneCache(PullZoneID)
      ```
      * Success Response
      ```
              {
                  "status": "success",
                  "HTTP": 200,
                  "msg": "successfully purged the cache of the given pullzone ",
              }

      ```
  * ### Add or Update Edgerule
      To Add or Update an Edgerule of a particular Pullzone
      ```
      >>obj_cdn.AddorUpdateEdgerule(PullZoneID,ActionParameter1,ActionParameter2,Enabled,Description,ActionType,TriggerMatchingType,Triggers,GUID(optional))
      ```
      * Success Response
      ```
                  {
                      "status": "success",
                      "HTTP": 201,
                      "msg": "successfully updated edgerule ",
                  }
      ```
  * ### Delete Edgerule
      To Delete the pullzone with the given ID
      ```
      >>obj_cdn.DeleteEdgeRule(PullZoneID,EdgeRuleID)
      ```
      * Success Response
      ```
              {
                  "status": "success",
                  "HTTP": 204,
                  "msg": "Successfully Deleted edgerule",
              }
      ```
  * ### Add Custom Hostname
      To add custom hostname to a pullzone
      ```
      >>obj_cdn.AddCustomHostname(PullZoneID,Hostname)
      ```
      * Success Response
      ```
              {
                  "status": "success",
                  "HTTP": 200,
                  "msg": "Update was Successfull",
              }
      ```
  * ### Delete Custom Hostname
      To delete custom hostname of a pullzone
      ```
      >>obj_cdn.DeleteCustomHostname(PullZoneID,Hostname)
      ```
      * Success Response
      ```
              {
                  "status": "success",
                  "HTTP": 200,
                  "msg": "Successfully Deleted Hostname",
              }

      ```
  * ### Set Force SSL
      To enable or disable the ForceSSL setting for a pulzone
      ```
      >>obj_cdn.SetForceSSL(PullZoneID,Hostname,ForceSSL)
      ```
      * Success Response
      ```
              {
                  "status": "success",
                  "HTTP": 200,
                  "msg": "successfully added Hostname ",
              }
      ```
  * ### Load Free Certificate
      To Load a FREE SSL Certificate to the domain provided by Let's Encrypt
      ```
      >>obj_cdn.LoadFreeCertificate(self,Hostname)
      ```
      * Success Response
      ```
      [{"Name":"pullzone1","Id":"pullzoneid1"},{"Name":"pullzone2","Id":"pullzoneid2"}]
      ```
  * ### Add Certificate
      To Add a custom certificate to the given Pull Zone.
      ```
      >>obj_cdn.AddCertificate(PullZoneId,Hostname,Certificate,CertificateKey)
      ```
      * Success Response
      ```
              {
                  "status": "success",
                  "HTTP": 200,
                  "msg": f"Certificated Added successfully Hostname:{Hostname}",
              }
      ```
  * ### Add Blocked IP
      To add an IP to the list of blocked IPs that are not allowed to access the zone
      ```
      >>obj_cdn.AddBlockedIp(PullZoneId, BlockedIp)
      ```
      * Success Response
      ```
              {
                  "status": "success",
                  "HTTP": 200,
                  "msg": "Ip successfully added to list of blocked IPs",
              }
      ```
  * ### Remove Blocked IP
      To removes mentioned IP from the list of blocked IPs that are not allowed to access the zone
      ```
      >>obj_cdn.RemoveBlockedIp(PullZoneId, BlockedIp)
      ```
      * Success Response
      ```
              {
                  "status": "success",
                  "HTTP": 200,
                  "msg": "Ip removed from blocked IPs list "
              }
      ```
  * ### Get Storagezone List
      Returns list of dictionaries containing storage zone name and its id
      ```
      >>obj_cdn.StorageZoneList()
      ```
      * Success Response
      ```
      [{"Name":"storagezone1","Id":"storagezoneid1"},{"Name":"storagezone2","Id":"storagezoneid2"}]
      ```
  * ### Get Storage Zone Data
      Returns list of dictionaries containing  details of storage zones in account
      ```
      >>obj_cdn.StorageZoneData()
      ```
      * Success Response
      ```
          [
              {
               'Id': 53889,
               'Storage_Zone_Name': 'mystoragezone1',
               'Usage': 39080459,
               'host_names': ['test.b-cdn.net', 'cdn.samplehostname.com'],
               'PullZones': ['mypullzone1']
               },

              {
               'Id': 54559,
               'Storage_Zone_Name': 'mystoragezone2',
               'Usage': 0,
               'host_names': [],
               'PullZones': ['mypullzone2']
               }
          ]
      ```
  * ### Add Storagezone
      This function creates an new storage zone
      ```
      >>obj_cdn.AddStorageZone(storage_zone_name, storage_zone_region(optional),ReplicationRegions(optional))
      ```
      * Success Response
      ```
             {
                  "status": "success",
                  "HTTP": 201,
                  "msg": {
                          "Name": "mystoragezone",
                          "Region": "DE",
                          "ReplicationRegions": [
                              "NY",
                              "SG"
                            ]
                          }
              }
      ```
  * ### Get Storagezone
      This function returns details about the storage zone with id:storage_zone_id
      ```
      >>obj_cdn.GetStorageZone(storage_zone_id)
      ```
      * Success Response
      ```
             {
              "Id": 4122,
              "Name": "mystoragezone",
              "Password": "storage-zone-password-key",
              "ReadOnlyPassword": "storage-zone-password-key",
              "UserId": "user-id",
              "FilesStored": 20,
              "StorageUsed": 1024,
              "Deleted": false,
              "DateModified": "2017-04-22T00:00:00Z"
            }
      ```
  * ### Delete Storagezone
      Deletes the Storage Zone with the given ID
      ```
      >>obj_cdn.DeleteStorageZone(storage_zone_id)
      ```
      * Success Response
      ```     {
                  "status": "Success",
                  "HTTP": 201,
                  "msg": "Deleted Storagezone successfully",
              }
      ```
  * ### Get Video Library
      Gets the details of Video Library of the specified id
      ```
      >>obj_cdn.GetVideoLibrary(id)
      ```
      * Success Response
      ```
                   {
                       "status": "success",
                        "HTTP": 200,
                        "msg": {
                                  "Id": 1234,
                                  "Name": "My Video Library",
                                  "VideoCount": 24,
                                  "DateCreated": "2021-04-22T00:00:00Z",
                                  "ApiKey": "video-library-api-key",
                                  "ReadOnlyApiKey": "video-library-readonly-api-key",
                                  "HasWatermark": false,
                                  "WatermarkPositionLeft": 70,
                                  "WatermarkPositionTop": 70,
                                  "WatermarkWidth": 12,
                                  "WatermarkHeight": 12,
                                  "EnabledResolutions": "240p,360p,480p",
                                  "VastTagUrl": "https://mydomain.com/vasttag.xml",
                                  "ViAiPublisherId": "vai-publisher-id",
                                  "CaptionsFontSize": "14,",
                                  "CaptionsFontColor": "#fff",
                                  "CaptionsBackground": "#222",
                                  "UILanguage": "en",
                                  "AllowEarlyPlay": false,
                                  "PlayerTokenAuthenticationEnabled": false,
                                  "EnableMP4Fallback": false,
                                  "AllowedReferrers": [
                                      "mydomain.com",
                                      "myotherdomain.net"
                                  ],
                                  "BlockedReferrers": [],
                                  "BlockNoneReferrer": false,
                                  "WebhookUrl": "https://api.mybackend.net/webook",
                                  "KeepOriginalFiles": true,
                                  "AllowDirectPlay": true,
                                  "EnableDRM": false,
                                  "Bitrate240p": 600,
                                  "Bitrate360p": 800,
                                  "Bitrate480p": 1400,
                                  "Bitrate720p": 2800,
                                  "Bitrate1080p": 5000,
                                  "Bitrate1440p": 8000,
                                  "Bitrate2160p": 13000
                                  }
                   }

      ```
  * ### Delete Video Library
      This method deletes the Storage zone with id :storage_zone_id
      ```
      >>obj_cdn.DeleteVideoLibrary(id)
      ```
      * Success Response
      ```
                   {
                       "status": "success",
                       "HTTP": 201,
                       "msg": "Deleted Video Library"
                   }
      ```
  * ### Purge Url Cache
      This method purges the given URL from our edge server cache.
      ```
      >>obj_cdn.PurgeUrlCache(url)
      ```
      * Success Response
      ```
              {
                  "status": "Success",
                  "HTTP": 200,
                  "msg": f"Purged Cache for url:{url}",
              }
      ```
  * ### Get Statistics
      Returns the statistics associated with the account
      ```
      >>obj_cdn.Stats(dateFrom=None,dateTo=None,pullZone=None,serverZoneId=None,loadErrors=True)
      ```
      Here all the parameters are optional the method can also be called without any parameters
  * ### Get Billing Summary
      Returns the current billing summary of the account
      ```
      >>obj_cdn.Billing()
      ```
  * ### Apply a Promo Code
      Applies a promo code to the account
      ```
      >>obj_cdn.ApplyCode( couponCode )
      ```




   For the versions available, see the [tags on this repository](https://github.com/mathrithms/BunnyCDN-Python-Lib/tags).



  * **MATHIRITHMS** - (https://mathrithms.com/)

  * **[Contributors:](https://github.com/mathrithms/BunnyCDN-Python-Lib/graphs/contributors)**

      
      




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



  * Used similar format as per the official libraries published by [BunnyCDN](https://github.com/BunnyWay/BunnyCDN.PHP.Storage)

  **For any bugs or issue mail**
  > 1. thomas.2@iitj.ac.in
  > 2. baranwal.1@iitj.ac.in


pkgId: ac5128e02847c78fd2b0eb93caed5266eb0d1f2e8e6fd06a435e9f7c0207319e
name: python-bunq-sdk
arch: src
version: 1.14.18
epoch: 0
release: 1
summary: bunq Python SDK
url: https://github.com/bunq/sdk_python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bunq-sdk-1.14.18-1.src.rpm
checksum_type: sha256
description:
  Hi developers!

  Welcome to the bunq Python SDK! 👨‍💻

  We're very happy to introduce yet another unique product: complete banking SDKs!
  Now you can build even bigger and better apps and integrate them with your bank of the free! 🌈

  Before you dive into this brand new SDK, please consider:
  - Learning how bunq works and what objects you will work with by reading [the intro to our API](https://github.com/bunq/doc/blob/develop/README.md) 🤓
  - Checking out [our developer portal](https://developer.bunq.com/) 🙌
  - Grabbing your Production API key from [our developer portal](https://developer.bunq.com/) or the bunq app 🗝
  - Generating a Sandbox API key using [our developer portal](https://developer.bunq.com/) or [Tinker](https://www.bunq.com/developer) 🗝
  - Visiting [our forum](https://together.bunq.com/t/api) where you can share your creations,
  questions and experience 🎤

  Give us your feedback, create pull requests, build your very own bunq apps and most importantly:
  have fun! 💪

  This SDK is in **beta**. We cannot guarantee constant availability or stability.
  Thanks to your feedback we will make improvements on it.


      pip install bunq_sdk --upgrade




  In order to start making calls with the bunq API, you must first register your API key and device,
  and create a session. In the SDKs, we group these actions and call it "creating an API context". The
  context can be created by using the following code snippet:


      apiContext = ApiContext.create(ENVIRONMENT_TYPE, API_KEY, DEVICE_DESCRIPTION)
      apiContext.save(API_CONTEXT_FILE_PATH)


  **Please note**: initialising your application is a heavy task and it is recommended to do it only once per device.

      apiContext = ApiContext.restore(self.API_CONTEXT_FILE_PATH)
      BunqContext.loadApiContext(apiContext)

  After saving the context, you can restore it at any time:



  See [`tinker/setup_context`](https://github.com/bunq/tinker_python/blob/2182b8be276fda921657ad22cfe0b8b48a585ccf/tinker/libs/bunq_lib.py#L44-L59)


  It is possible to create an ApiContext as PSD2 Service Provider. Although this might seem a complex task, we wrote some
  helper implementations to get you started. You need to create a certificate and private key to get you started.
  Our sandbox environment currently accepts all certificates, if these criteria are met:

  - Up to 64 characters
  - PISP and/or AISP used in the end.

  Make sure you have your unique eIDAS certificate number and certificates ready when you want to perform these tasks on
  our production environment.

  Creating a PSD2 context is very easy:

      apiContext = ApiContext.create_for_psd2(ENVIRONMENT_TYPE, CERTIFICATE, PRIVATE_KEY, CERTIFICATE_CHAIN, DEVICE_DESCRIPTION)


  The file storing the context details (i.e. `bunq.conf`) is a key to your account. Anyone having
  access to it is able to perform any Public API actions with your account. Therefore, we recommend
  choosing a truly safe place to store it.


  There is a class for each endpoint. Each class has functions for each supported action. These
  actions can be `create`, `get`, `update`, `delete` and `list`.

  Sometimes API calls have dependencies, for instance `MonetaryAccount`. Making changes to a monetary
  account always also needs a reference to a `User`. These dependencies are required as arguments when
  performing API calls. Take a look at [doc.bunq.com](https://doc.bunq.com) for the full
  documentation.


  Creating objects through the API requires an `ApiContext`, a `requestMap` and identifiers of all
  dependencies (such as User ID required for accessing a Monetary Account). Optionally, custom headers
  can be passed to requests.

      payment_id = Payment.create(
          amount=Amount(amount_string, self._CURRENCY_EURL),
          counterparty_alias=Pointer(self._POINTER_TYPE_EMAIL, recipient),
          description=description
      )


  See [`tinker/make_payment`](https://github.com/bunq/tinker_python/blob/2182b8be276fda921657ad22cfe0b8b48a585ccf/tinker/libs/bunq_lib.py#L140-L151)


  Reading objects through the API requires an `ApiContext`, identifiers of all dependencies (such as
  User ID required for accessing a Monetary Account), and the identifier of the object to read (ID or
  UUID) Optionally, custom headers can be passed to requests.

  This type of calls always returns a model.

      monetary_account = generated.MonetaryAccountBank.get(
          _MONETARY_ACCOUNT_ITEM_ID
      )


  See [`tinker/list_all_payment`](https://github.com/bunq/tinker_python/blob/2182b8be276fda921657ad22cfe0b8b48a585ccf/tinker/libs/bunq_lib.py#L85-L103)


  Updating objects through the API goes the same way as creating objects, except that also the object to update identifier
  (ID or UUID) is needed.

      Card.update(
          card_id=int(card_id),
          monetary_account_current_id=int(account_id)
      )


  See [`tinker/update_card`](https://github.com/bunq/tinker_python/blob/2182b8be276fda921657ad22cfe0b8b48a585ccf/tinker/libs/bunq_lib.py#L167-L174)


  Deleting objects through the API requires an `ApiContext`, identifiers of all dependencies (such as User ID required for
  accessing a Monetary Account), and the identifier of the object to delete (ID or UUID) Optionally, custom headers can be
  passed to requests.

      Session.delete(self._SESSION_ID)




  Listing objects through the API requires an `ApiContext` and identifiers of all dependencies (such as User ID required
  for accessing a Monetary Account). Optionally, custom headers can be passed to requests.

      users = User.list(api_context)


  See [`UserListExample.py`](./examples/user_list_example.py)


  To get an indication on how the SDK works you can use the python tinker which is located at https://github.com/bunq/tinker_python



  Information regarding the test cases can be found in the [README.md](./tests/README.md)
  located in [test](/tests).


  The SDK can raise multiple exceptions. For an overview of these exceptions please
  take a look at [EXCEPTIONS.md](./bunq/sdk/exception/EXCEPTIONS.md).


pkgId: 20ec706f844da1bf219b64be6afdccfcc641635d7d19940863f49dba13b9eddf
name: python-burane-weather-app-20-11-2024
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: application météo
url: https://github.com/Burane/WeatherApp.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-burane-weather-app-20-11-2024-0.4.0-1.src.rpm
checksum_type: sha256
description:
  ```python
  caen = (49.183, -0.38)
  w = Weather()
  w.display_currrent_weather(caen[0], caen[1], 1)
  today = date.today() - timedelta(weeks=1)
  yesterday = today - timedelta(days=1, weeks=1)
  w.display_past_weather(caen[0], caen[1], yesterday, yesterday)
  ```


pkgId: 89a3d5c7301144a6853fe6fd474ecda0ae859971003afdd8ce04e618087be25f
name: python-burgos
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: A bundle of useful packages for managing login sessions and database
url: https://github.com/nandobfer/burgos
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-burgos-2.2.1-1.src.rpm
checksum_type: sha256
description:
  ```python
  from burgos.session import Session
  session = Session(database_auth, login_table)
  ```

  database_auth: json/dict
  ```json
  {
      "host": "host ip address or domain",
      "database": "database name",
      "user": "username",
      "password": "user password"
  }
  ```

  login_table: string
  ```
  "table_name_which_contains_login_data"
  ```




  - reconnects to the database


  - ip = string containing an ip address
  - returns the connection matching the selected ip address
  - if there is no connection with that ip, returns None


  - user = string containing the username, email or cpf as login method
  - password = string containg the password
  - ip = string containing an ip address
  - if "user" is number only, it will be checked as cpf
  - if "user" has an "@", it will be checked as an email
  - if "user" is neither, it will be checked as an username
  - if there is a row in database.login_table that matches with this user and password, a Connection will be instanciated and the user id will be returned



  ```python
  from burgos.mysql_handler import Mysql
  database = Mysql(login_table)
  ```

  login_table: string
  ```
  "table_name_which_contains_login_data"
  ```




  - auth = dictionary containing authentication data (same as session's database_auth)
  - connects to the database and must be called before any other method (session already calls this in it's constructor)


  - disconnects from the database


  - sql = string containing SQL code
  - sql code will be executed and commited into the database
  - if sql first word, lowered, is equal to "select", this method will return a list containing the selected rows


  - table = string containing the table name which should be selected data from
  - rows = int number that means the number of rows that should be selected. Optional (default: all rows)
  - where = list containing strings which are the column and value. Ex.: where = ["username", "nandobfer"]. Optional.
  - reversed = boolean indicating if the where query should be reversed or not. Optional.
  - ordered = string containing the "ORDER BY" information. Ex. ordered = "id" / ordered = "datetime DESC"
  - Returns a list containing another list for each row fetched. Returns an empty list if there was none.

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


pkgId: 1dc26aeb3dc9c58a4ff1f69d7f686da0da84886b4b4067e6324bc6ed549b1dac
name: python-burlap
arch: src
version: 0.9.124
epoch: 0
release: 1
summary: Fabric commands for simplifying server deployments
url: https://gitlab.com/chrisspen/burlap
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-burlap-0.9.124-1.src.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/pypi/v/burlap.svg)](https://pypi.python.org/pypi/burlap)
  [![Pipeline Status](https://gitlab.com/chrisspen/burlap/badges/master/pipeline.svg)](https://gitlab.com/chrisspen/burlap/commits/master)
  [![](https://pyup.io/repos/gitlab/chrisspen/burlap/shield.svg)](https://pyup.io/repos/gitlab/chrisspen/burlap)


pkgId: 41446c5657ee27572f090f8bbdf4d8d25ce0bae5b0ad940446e047da264b161d
name: python-burmese-tools
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/burmese-tools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-burmese-tools-0.1.1-1.src.rpm
checksum_type: sha256
description:
  **burmese-tools** is a Python library that mainly designed for transformation between unicode and zawgyi burmese lanuage script. Moreover, it also support syllable tokenization for burmese unicode and parital syllable tokenization for burmese zawgyi.


  - Zawgyi to Unicode Conversion: Convert Zawgyi-encoded text to Unicode.
  - Unicode to Zawgyi Conversion: Transform Unicode text back to Zawgyi.
  - Unicode Syllable Tokenization: Tokenize Burmese Unicode text into syllables with customizable splitting.
  - Partial Zawgyi Syllable Tokenization: Tokenize Burmese Zawgyi text into syllables.



  You can install this library from PyPI:
  ```python
  pip install burmese-tools
  ```




  ```python
  from burmese_tools import tools
  ```



  ```python
  text_zawgyi = "ကႏၲာရ"
  converted_text = tools.zaw2uni(text_zawgyi)
  print(converted_text)  # Output: ကန္တာရ
  ```


  ```python
  text_unicode = "ကန္တာရ"
  converted_text = tools.uni2zaw(text_unicode)
  print(converted_text)  # Output: ကႏၲာ႐
  ```


  The uni_syllable function is a utility to tokenize Unicode text into syllable tokens, allowing for flexible splitting methods.

  **Features**
  - Tokenizes Unicode text into syllables.
  - Provides two types of splitting:
      - Type 1: Splits `ဂန္ဓာရ` into `['ဂ', 'န္ဓာ', 'ရ']`. (default)
      - Type 2: Splits `ဂန္ဓာရ` into `['ဂန္', 'ဓာ', 'ရ']`.
  - Supports an optional transform to replace `္` with ` ်` (applies only when type=2) d
      - default = True

  ```python
  text = "ကန္တာရ"
  tokens = tools.uni_syllable(text, type=1)
  print(tokens)  # Output: ['က', 'န္တာ', 'ရ']
  ```

  ```python
  text = "ကန္တာရ"
  tokens = tools.uni_syllable(text, type=2)
  print(tokens)  # Output: ['ကန်', 'တာ', 'ရ']
  ```

  ```python
  text = "ကန္တာရ"
  tokens = tools.uni_syllable(text, type=2, transform=False)
  print(tokens)  # Output: ['ကန္', 'တာ', 'ရ']
  ```


  ```python
  text = "ကႏၲာရ"
  tokens = tools.zaw_partial_syllable(text)
  print(tokens)  # Output: ['က', 'ႏၲာ', 'ရ']  in unicode ['က', 'န္တာ', 'ရ']
  ```


  Contributions are welcome! Please follow these steps:

  - Fork the repository.
  - Create a new branch for your feature/bug fix.
  - Make your changes and test thoroughly.
  - Submit a pull request.



  This library is licensed under the MIT License. Feel free to use, modify, and distribute it.




  This library was developed to simplify Burmese text processing for developers and linguists. Special thanks to **Sa Phyo Thu Thet**, from Simbolo  for his invaluable guidance, kindness, and support in teaching me. His mentorship has been instrumental in shaping my understanding and skills. Contributions and feedback from the community are also highly appreciated.


pkgId: 7448219bbe4ca398a53c80ed9d3efc2bb695349e65a15f706263ad4527927318
name: python-burnman
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: A thermoelastic and thermodynamic toolkit for the Earth and planetary sciences
url: https://geodynamics.github.io/burnman/
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-burnman-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.14165625.svg)](https://doi.org/10.5281/zenodo.14165625)
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.05389/status.svg)](https://doi.org/10.21105/joss.05389)



  <img src="docs/burnjack.png" width="256">



  BurnMan is a Python library for generating thermodynamic and thermoelastic models of planetary interiors.

  It began as a working-group at the 2012 CIDER workshop in Santa Barbara.

  BurnMan is released under the GNU GPL v2 or newer

  Homepage: https://geodynamics.github.io/burnman/

  Documentation: http://burnman.readthedocs.io

  Source code: https://github.com/geodynamics/burnman

  Forums: https://community.geodynamics.org/c/burnman

  Authors (as of 2023):
  * Bob (Robert) Myhill (main contributor)
  * Cayman Unterborn
  * Ian Rose
  * Sanne Cottaar
  * Timo Heister
  * Juliane Dannberg
  * Rene Gassmoeller



  If you use BurnMan in your work, we ask that you cite the following publications:

    - Myhill, R., Cottaar, S., Heister, T., Rose, I., Unterborn, C.,
      Dannberg, J. and Gassmoeller, R. (2023). BurnMan - a Python toolkit for
      planetary geophysics, geochemistry and thermodynamics. Journal of Open Source Software.
      https://doi.org/10.21105/joss.05389

    - Myhill, R., Cottaar, S., Heister, T., Rose, I., Unterborn, C.,
      Dannberg, J., Gassmoeller, R. and Farla, R. (2024):
      BurnMan v2.0.0 [Software]. Computational Infrastructure for Geodynamics. Zenodo.
      https://doi.org/10.5281/zenodo.14165625

    - Cottaar S., Heister, T., Rose, I., and Unterborn, C., (2014). BurnMan: A
      lower mantle mineral physics toolkit, Geochemistry, Geophysics, and
      Geosystems, 15(4), 1164-1179 https://doi.org/10.1002/2013GC005122



  * Python 3.8+
  * Python modules:
    NumPy, SciPy, SymPy, Matplotlib



  * cvxpy - required for some least squares fitting routines and solution polytope calculations.
  * pycddlib - required for solution polytope calculations.
  * autograd - required for esoteric solution models defined using a single excess function. Not required for the vast majority of users.


  Installation of BurnMan is mostly platform independent.
  As long as you know how to use a terminal, the process should be straightforward.
  The following instructions should help, but let us know if you have any problems.


  We strongly recommend using a python environment manager like conda or pyenv to install
  BurnMan and its dependencies. This is especially the case for installations on modern Mac systems.

  For pyenv, we suggest you select the most recent version of python supported by BurnMan, install all of the dependencies into that environment and set the burnman root directory to use that environment automatically.

  For conda, we suggest making a new environment for the burnman installation, install the most recent version of python supported by BurnMan into that environment, and install all of the dependencies into that environment. Remember to activate the environment before installing new dependencies or using BurnMan.


  First, make sure you have a sufficiently recent version of python installed on your machine (see above for the latest requirements).  To check your version of python, type the following in a terminal:
      python --version
  If your version is not recent enough, visit https://www.python.org/ to find out how to install a newer version.

  Once you have checked your version of python, you should make sure you have installed the python module pip. We will use this module to install BurnMan. If you don't have it already, you can install it by opening a terminal window and typing:

      python -m ensurepip --upgrade

  Mac users will also need to install Xcode, which can be found in the MacStore, or can be installed with:

      xcode-select --install


  If you are only interested in using BurnMan (rather than developing the software), and you aren't interested in any of the latest changes, you can install the stable version by typing the following into a terminal window:

      python -m pip install burnman

  This method of installation does not give you easy access to all the examples, or the test suite. These can be found in the latest release package which can be downloaded from https://github.com/geodynamics/burnman/releases.


  If you want to install the development version of BurnMan (with all the latest features), you will first need to download the source code. The best way to do this is by using git (a version control system). To install git, follow the instructions at https://git-scm.com/downloads.

  Then, using a terminal, navigate to the directory into which you want to clone the BurnMan repository, and type

      git clone https://github.com/geodynamics/burnman.git

  (If you don't want to use git, you can download the current master branch from https://github.com/geodynamics/burnman/archive/master.zip.)

  Once the repository is cloned, navigate to the top-level directory by typing `cd burnman` in the terminal, and then install BurnMan, either in static mode: `python -m pip install .` or in development mode (if you want to develop or modify the code): `python -m pip install -e .`.



  To check that the installation has worked, you can run the test suite (`./test.sh`). This takes a few minutes to run. You may find that you need to install some other dependencies (latex, pycddlib) if you don't already have them on your system.

  A more basic check that BurnMan is installed is to navigate to the Burnman examples directory and type:

      python example_beginner.py

  If figures show up, BurnMan has been installed.




  An introduction to the tools available in BurnMan can be found in the BurnMan
  Tutorial. These are ipython notebooks that can be run from inside jupyterlab.

  If you want to run these notebooks without installing BurnMan, you can access
  them on binder.org via the links below.

  1. [tutorial_01_material_classes.ipynb](https://mybinder.org/v2/gh/geodynamics/burnman/HEAD?labpath=tutorial%2Ftutorial_01_material_classes.ipynb "Part 1: The Material Classes") (introduces the main classes in BurnMan, which are used to calculate material properties)
  2. [tutorial_02_composition_class.ipynb](https://mybinder.org/v2/gh/geodynamics/burnman/HEAD?labpath=tutorial%2Ftutorial_02_composition_class.ipynb "Part 2: The Composition Class") (introduces the composition class, used for processing and converting chemical compositions)
  3. [tutorial_03_layers_and_planets.ipynb](https://mybinder.org/v2/gh/geodynamics/burnman/HEAD?labpath=tutorial%2Ftutorial_03_layers_and_planets.ipynb "Part 3: Layers and Planets") (introduces the layer and planet classes used to create models of planetary interiors)
  4. [tutorial_04_fitting.ipynb](https://mybinder.org/v2/gh/geodynamics/burnman/HEAD?labpath=tutorial%2Ftutorial_04_fitting.ipynb "Part 4: Fitting") (introduces the various functions used to fit model parameters to experimental and analytical data)
  5. [tutorial_05_equilibrium.ipynb](https://mybinder.org/v2/gh/geodynamics/burnman/HEAD?labpath=tutorial%2Ftutorial_05_equilibrium.ipynb "Part 5: Equilibrium problems") (introduces the equilibrate function, used to equilibrate mineral assemblages)




  The BurnMan tutorials provide a basic but incomplete understanding of what
  the module can do. To supplement the tutorials, BurnMan includes a
  large suite of examples that provide more in-depth coverage of the
  potential uses of the module.

  For an up-to-date summary of all the examples, including the generated figures,
  the user is referred to the BurnMan manual (http://burnman.readthedocs.io).



  Burnman has the advantage of being adaptable and extensible in easy scripts.
  As BurnMan is a toolkit, a graphical user interface would be impractical
  (although we do plan to add GUIs for some functionality in the future).
  Nevertheless, we hope that we have succeeded in making BurnMan accessible to
  coding novices. For those of you who have little experience with Python,
  here are some specific features and pitfalls of the language:

  * Python uses specific indentation. A script might fail if a code block is not indented correctly. We use four spaces and no tabs. Mixing spaces and tabs can cause trouble.
  * Indices should be given inside square brackets and function or method call arguments inside parentheses (different from Matlab).
  * The first index of an array or list is 0 (e.g. x[0]), not 1.
  * Put dots after numbers to make them floats instead of integers.


pkgId: a14f68e91710514bf76f6a14b6d1fcbaf36f5291345cb79a5c5897dd5d533121
name: python-burr
arch: src
version: 0.31.1
epoch: 0
release: 1
summary: A state machine for data projects
url: https://github.com/dagworks-inc/burr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-burr-0.31.1-1.src.rpm
checksum_type: sha256
description:
  <div>

  [![Discord](https://img.shields.io/badge/Join-Burr_Discord-7289DA?logo=discord)](https://discord.gg/6Zy2DwP4f3)
  [![Downloads](https://static.pepy.tech/badge/burr/month)](https://pepy.tech/project/burr)
  [![GitHub Last Commit](https://img.shields.io/github/last-commit/dagworks-inc/burr)](https://github.com/dagworks-inc/burr/pulse)
  [![X](https://img.shields.io/badge/follow-%40burr_framework-1DA1F2?logo=x&style=social)](https://twitter.com/burr_framework)
  <a href="https://app.commanddash.io/agent/github_DAGWorks-Inc_burr"><img src="https://img.shields.io/badge/AI-Code%20Agent-EB9FDA"></a>

  </div>

  Burr makes it easy to develop applications that make decisions (chatbots, agents, simulations, etc...) from simple python building blocks.

  Burr works well for any application that uses LLMs, and can integrate with any of your favorite frameworks. Burr includes a UI that can track/monitor/trace your system in real time, along with
  pluggable persisters (e.g. for memory) to save & load application state.

  Link to [documentation](https://burr.dagworks.io/). Quick (<3min) video intro [here](https://www.loom.com/share/a10f163428b942fea55db1a84b1140d8?sid=1512863b-f533-4a42-a2f3-95b13deb07c9).
  Longer [video intro & walkthrough](https://www.youtube.com/watch?v=rEZ4oDN0GdU). Blog post [here](https://blog.dagworks.io/p/burr-develop-stateful-ai-applications). Join discord for help/questions [here](https://discord.gg/6Zy2DwP4f3).



  Install from `pypi`:

  ```bash
  pip install "burr[start]"
  ```

  (see [the docs](https://burr.dagworks.io/getting_started/install/) if you're using poetry)

  Then run the UI server:

  ```bash
  burr
  ```

  This will open up Burr's telemetry UI. It comes loaded with some default data so you can click around.
  It also has a demo chat application to help demonstrate what the UI captures enabling you too see things changing in
  real-time. Hit the "Demos" side bar on the left and select `chatbot`. To chat it requires the `OPENAI_API_KEY`
  environment variable to be set, but you can still see how it works if you don't have an API key set.

  Next, start coding / running examples:

  ```bash
  git clone https://github.com/dagworks-inc/burr && cd burr/examples/hello-world-counter
  python application.py
  ```

  You'll see the counter example running in the terminal, along with the trace being tracked in the UI.
  See if you can find it.

  For more details see the [getting started guide](https://burr.dagworks.io/getting_started/simple-example/).



  With Burr you express your application as a state machine (i.e. a graph/flowchart).
  You can (and should!) use it for anything in which you have to manage state, track complex decisions, add human feedback, or dictate an idempotent, self-persisting workflow.

  The core API is simple -- the Burr hello-world looks like this (plug in your own LLM, or copy from [the docs](https://burr.dagworks.io/getting_started/simple-example/#build-a-simple-chatbot>) for _gpt-X_)

  ```python
  from burr.core import action, State, ApplicationBuilder

  @action(reads=[], writes=["prompt", "chat_history"])
  def human_input(state: State, prompt: str) -> State:
      
      return state.update(prompt=prompt).append(chat_history=chat_item)

  @action(reads=["chat_history"], writes=["response", "chat_history"])
  def ai_response(state: State) -> State:
      response = _query_llm(state["chat_history"]) # Burr doesn't care how you use LLMs!
      return state.update(response=content).append(chat_history=chat_item)

  app = (
      ApplicationBuilder()
      .with_actions(human_input, ai_response)
      .with_transitions(
          ("human_input", "ai_response"),
          ("ai_response", "human_input")
      ).with_state(chat_history=[])
      .with_entrypoint("human_input")
      .build()
  )
  *_, state = app.run(halt_after=["ai_response"], inputs={"prompt": "Who was Aaron Burr, sir?"})
  print("answer:", app.state["response"])
  ```

  Burr includes:

  1. A (dependency-free) low-abstraction python library that enables you to build and manage state machines with simple python functions
  2. A UI you can use view execution telemetry for introspection and debugging
  3. A set of integrations to make it easier to persist state, connect to telemetry, and integrate with other systems

  ![Burr at work](https://github.com/DAGWorks-Inc/burr/blob/main/chatbot.gif)



  Burr can be used to power a variety of applications, including:

  1. [A simple gpt-like chatbot](https://github.com/dagworks-inc/burr/tree/main/examples/multi-modal-chatbot)
  2. [A stateful RAG-based chatbot](https://github.com/dagworks-inc/burr/tree/main/examples/conversational-rag/simple_example)
  3. [An LLM-based adventure game](https://github.com/DAGWorks-Inc/burr/tree/main/examples/llm-adventure-game)
  4. [An interactive assistant for writing emails](https://github.com/DAGWorks-Inc/burr/tree/main/examples/email-assistant)

  As well as a variety of (non-LLM) use-cases, including a time-series forecasting [simulation](https://github.com/DAGWorks-Inc/burr/tree/main/examples/simulation),
  and [hyperparameter tuning](https://github.com/DAGWorks-Inc/burr/tree/main/examples/ml-training).

  And a lot more!

  Using hooks and other integrations you can (a) integrate with any of your favorite vendors (LLM observability, storage, etc...), and
  (b) build custom actions that delegate to your favorite libraries (like [Hamilton](https://github.com/DAGWorks-Inc/hamilton)).

  Burr will _not_ tell you how to build your models, how to query APIs, or how to manage your data. It will help you tie all these together
  in a way that scales with your needs and makes following the logic of your system easy. Burr comes out of the box with a host of integrations
  including tooling to build a UI in streamlit and watch your state machine execute.



  See the documentation for [getting started](https://burr.dagworks.io/getting_started/simple-example), and follow the example.
  Then read through some of the concepts and write your own application!



  While Burr is attempting something (somewhat) unique, there are a variety of tools that occupy similar spaces:

  | Criteria                                          | Burr | Langgraph | temporal | Langchain | Superagent | Hamilton |
  | ------------------------------------------------- | :--: | :-------: | :------: | :-------: | :--------: | :------: |
  | Explicitly models a state machine                 |  ✅  |    ✅     |    ❌    |    ❌     |     ❌     |    ❌    |
  | Framework-agnostic                                |  ✅  |    ✅     |    ✅    |    ✅     |     ❌     |    ✅    |
  | Asynchronous event-based orchestration            |  ❌  |    ❌     |    ✅    |    ❌     |     ❌     |    ❌    |
  | Built for core web-service logic                  |  ✅  |    ✅     |    ❌    |    ✅     |     ✅     |    ✅    |
  | Open-source user-interface for monitoring/tracing |  ✅  |    ❌     |    ❌    |    ❌     |     ❌     |    ✅    |
  | Works with non-LLM use-cases                      |  ✅  |    ❌     |    ❌    |    ❌     |     ❌     |    ✅    |



  Burr is named after [Aaron Burr](https://en.wikipedia.org/wiki/Aaron_Burr), founding father, third VP of the United States, and murderer/arch-nemesis of [Alexander Hamilton](https://en.wikipedia.org/wiki/Alexander_Hamilton).
  What's the connection with Hamilton? This is [DAGWorks](www.dagworks.io)' second open-source library release after the [Hamilton library](https://github.com/dagworks-inc/hamilton)
  We imagine a world in which Burr and Hamilton lived in harmony and saw through their differences to better the union. We originally
  built Burr as a _harness_ to handle state between executions of Hamilton DAGs (because DAGs don't have cycles),
  but realized that it has a wide array of applications and decided to release it more broadly.



  While Burr is stable and well-tested, we have quite a few tools/features on our roadmap!

  1. Parallelism -- support for recursive "sub-agents" through an ergonomic API (not: this is already feasible, see [recursive applications](http://localhost:8000/concepts/recursion/)).
  2. Testing & eval curation. Curating data with annotations and being able to export these annotations to create unit & integration tests.
  3. Various efficiency/usability improvements for the core library (see [planned capabilities](https://burr.dagworks.io/concepts/planned-capabilities/) for more details). This includes:
     1. First-class support for retries + exception management
     2. More integration with popular frameworks (LCEL, LLamaIndex, Hamilton, etc...)
     3. Capturing & surfacing extra metadata, e.g. annotations for particular point in time, that you can then pull out for fine-tuning, etc.
  4. Tooling for hosted execution of state machines, integrating with your infrastructure (Ray, modal, FastAPI + EC2, etc...)
  5. Storage integrations. More integrations with technologies like Redis, MongoDB, MySQL, etc. so you can run Burr on top of what you have available.
  6. More out of the box plugins for fine-grained tracing, e.g. decorators for your functions, LLM clients, etc.

  If you want to avoid self-hosting the above solutions we're building Burr Cloud. To let us know you're interested
  sign up [here](https://forms.gle/w9u2QKcPrztApRedA) for the waitlist to get access.



  We welcome contributors! To get started on developing, see the [developer-facing docs](https://burr.dagworks.io/contributing).





  Users who have contributed core functionality, integrations, or examples.

  - [Elijah ben Izzy](https://github.com/elijahbenizzy)
  - [Stefan Krawczyk](https://github.com/skrawcz)
  - [Joseph Booth](https://github.com/jombooth)
  - [Nandani Thakur](https://github.com/NandaniThakur)
  - [Thierry Jean](https://github.com/zilto)
  - [Hamza Farhan](https://github.com/HamzaFarhan)
  - [Abdul Rafay](https://github.com/proftorch)



  Users who have contributed small docs fixes, design suggestions, and found bugs

  - [Luke Chadwick](https://github.com/vertis)
  - [Evans](https://github.com/sudoevans)
  - [Sasmitha Manathunga](https://github.com/mmz-001)


pkgId: 54179d942a0bb3591adda14432524cb6557b5e2fa2f8b3788b7600dd8db606e1
name: python-burr
arch: src
version: 0.33.0
epoch: 0
release: 1
summary: A state machine for data projects
url: https://github.com/dagworks-inc/burr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-burr-0.33.0-1.src.rpm
checksum_type: sha256
description:
  <div>

  [![Discord](https://img.shields.io/badge/Join-Burr_Discord-7289DA?logo=discord)](https://discord.gg/6Zy2DwP4f3)
  [![Downloads](https://static.pepy.tech/badge/burr/month)](https://pepy.tech/project/burr)
  [![GitHub Last Commit](https://img.shields.io/github/last-commit/dagworks-inc/burr)](https://github.com/dagworks-inc/burr/pulse)
  [![X](https://img.shields.io/badge/follow-%40burr_framework-1DA1F2?logo=x&style=social)](https://twitter.com/burr_framework)
  <a href="https://app.commanddash.io/agent/github_DAGWorks-Inc_burr"><img src="https://img.shields.io/badge/AI-Code%20Agent-EB9FDA"></a>

  </div>

  Burr makes it easy to develop applications that make decisions (chatbots, agents, simulations, etc...) from simple python building blocks.

  Burr works well for any application that uses LLMs, and can integrate with any of your favorite frameworks. Burr includes a UI that can track/monitor/trace your system in real time, along with
  pluggable persisters (e.g. for memory) to save & load application state.

  Link to [documentation](https://burr.dagworks.io/). Quick (<3min) video intro [here](https://www.loom.com/share/a10f163428b942fea55db1a84b1140d8?sid=1512863b-f533-4a42-a2f3-95b13deb07c9).
  Longer [video intro & walkthrough](https://www.youtube.com/watch?v=rEZ4oDN0GdU). Blog post [here](https://blog.dagworks.io/p/burr-develop-stateful-ai-applications). Join discord for help/questions [here](https://discord.gg/6Zy2DwP4f3).



  Install from `pypi`:

  ```bash
  pip install "burr[start]"
  ```

  (see [the docs](https://burr.dagworks.io/getting_started/install/) if you're using poetry)

  Then run the UI server:

  ```bash
  burr
  ```

  This will open up Burr's telemetry UI. It comes loaded with some default data so you can click around.
  It also has a demo chat application to help demonstrate what the UI captures enabling you too see things changing in
  real-time. Hit the "Demos" side bar on the left and select `chatbot`. To chat it requires the `OPENAI_API_KEY`
  environment variable to be set, but you can still see how it works if you don't have an API key set.

  Next, start coding / running examples:

  ```bash
  git clone https://github.com/dagworks-inc/burr && cd burr/examples/hello-world-counter
  python application.py
  ```

  You'll see the counter example running in the terminal, along with the trace being tracked in the UI.
  See if you can find it.

  For more details see the [getting started guide](https://burr.dagworks.io/getting_started/simple-example/).



  With Burr you express your application as a state machine (i.e. a graph/flowchart).
  You can (and should!) use it for anything in which you have to manage state, track complex decisions, add human feedback, or dictate an idempotent, self-persisting workflow.

  The core API is simple -- the Burr hello-world looks like this (plug in your own LLM, or copy from [the docs](https://burr.dagworks.io/getting_started/simple-example/#build-a-simple-chatbot>) for _gpt-X_)

  ```python
  from burr.core import action, State, ApplicationBuilder

  @action(reads=[], writes=["prompt", "chat_history"])
  def human_input(state: State, prompt: str) -> State:
      
      return state.update(prompt=prompt).append(chat_history=chat_item)

  @action(reads=["chat_history"], writes=["response", "chat_history"])
  def ai_response(state: State) -> State:
      response = _query_llm(state["chat_history"]) # Burr doesn't care how you use LLMs!
      return state.update(response=content).append(chat_history=chat_item)

  app = (
      ApplicationBuilder()
      .with_actions(human_input, ai_response)
      .with_transitions(
          ("human_input", "ai_response"),
          ("ai_response", "human_input")
      ).with_state(chat_history=[])
      .with_entrypoint("human_input")
      .build()
  )
  *_, state = app.run(halt_after=["ai_response"], inputs={"prompt": "Who was Aaron Burr, sir?"})
  print("answer:", app.state["response"])
  ```

  Burr includes:

  1. A (dependency-free) low-abstraction python library that enables you to build and manage state machines with simple python functions
  2. A UI you can use view execution telemetry for introspection and debugging
  3. A set of integrations to make it easier to persist state, connect to telemetry, and integrate with other systems

  ![Burr at work](https://github.com/DAGWorks-Inc/burr/blob/main/chatbot.gif)



  Burr can be used to power a variety of applications, including:

  1. [A simple gpt-like chatbot](https://github.com/dagworks-inc/burr/tree/main/examples/multi-modal-chatbot)
  2. [A stateful RAG-based chatbot](https://github.com/dagworks-inc/burr/tree/main/examples/conversational-rag/simple_example)
  3. [An LLM-based adventure game](https://github.com/DAGWorks-Inc/burr/tree/main/examples/llm-adventure-game)
  4. [An interactive assistant for writing emails](https://github.com/DAGWorks-Inc/burr/tree/main/examples/email-assistant)

  As well as a variety of (non-LLM) use-cases, including a time-series forecasting [simulation](https://github.com/DAGWorks-Inc/burr/tree/main/examples/simulation),
  and [hyperparameter tuning](https://github.com/DAGWorks-Inc/burr/tree/main/examples/ml-training).

  And a lot more!

  Using hooks and other integrations you can (a) integrate with any of your favorite vendors (LLM observability, storage, etc...), and
  (b) build custom actions that delegate to your favorite libraries (like [Hamilton](https://github.com/DAGWorks-Inc/hamilton)).

  Burr will _not_ tell you how to build your models, how to query APIs, or how to manage your data. It will help you tie all these together
  in a way that scales with your needs and makes following the logic of your system easy. Burr comes out of the box with a host of integrations
  including tooling to build a UI in streamlit and watch your state machine execute.



  See the documentation for [getting started](https://burr.dagworks.io/getting_started/simple-example), and follow the example.
  Then read through some of the concepts and write your own application!



  While Burr is attempting something (somewhat) unique, there are a variety of tools that occupy similar spaces:

  | Criteria                                          | Burr | Langgraph | temporal | Langchain | Superagent | Hamilton |
  | ------------------------------------------------- | :--: | :-------: | :------: | :-------: | :--------: | :------: |
  | Explicitly models a state machine                 |  ✅  |    ✅     |    ❌    |    ❌     |     ❌     |    ❌    |
  | Framework-agnostic                                |  ✅  |    ✅     |    ✅    |    ✅     |     ❌     |    ✅    |
  | Asynchronous event-based orchestration            |  ❌  |    ❌     |    ✅    |    ❌     |     ❌     |    ❌    |
  | Built for core web-service logic                  |  ✅  |    ✅     |    ❌    |    ✅     |     ✅     |    ✅    |
  | Open-source user-interface for monitoring/tracing |  ✅  |    ❌     |    ❌    |    ❌     |     ❌     |    ✅    |
  | Works with non-LLM use-cases                      |  ✅  |    ❌     |    ❌    |    ❌     |     ❌     |    ✅    |



  Burr is named after [Aaron Burr](https://en.wikipedia.org/wiki/Aaron_Burr), founding father, third VP of the United States, and murderer/arch-nemesis of [Alexander Hamilton](https://en.wikipedia.org/wiki/Alexander_Hamilton).
  What's the connection with Hamilton? This is [DAGWorks](www.dagworks.io)' second open-source library release after the [Hamilton library](https://github.com/dagworks-inc/hamilton)
  We imagine a world in which Burr and Hamilton lived in harmony and saw through their differences to better the union. We originally
  built Burr as a _harness_ to handle state between executions of Hamilton DAGs (because DAGs don't have cycles),
  but realized that it has a wide array of applications and decided to release it more broadly.



  While Burr is stable and well-tested, we have quite a few tools/features on our roadmap!

  1. Parallelism -- support for recursive "sub-agents" through an ergonomic API (not: this is already feasible, see [recursive applications](https://burr.dagworks.io/recursion/)).
  2. Testing & eval curation. Curating data with annotations and being able to export these annotations to create unit & integration tests.
  3. Various efficiency/usability improvements for the core library (see [planned capabilities](https://burr.dagworks.io/concepts/planned-capabilities/) for more details). This includes:
     1. First-class support for retries + exception management
     2. More integration with popular frameworks (LCEL, LLamaIndex, Hamilton, etc...)
     3. Capturing & surfacing extra metadata, e.g. annotations for particular point in time, that you can then pull out for fine-tuning, etc.
  4. Tooling for hosted execution of state machines, integrating with your infrastructure (Ray, modal, FastAPI + EC2, etc...)
  5. Storage integrations. More integrations with technologies like Redis, MongoDB, MySQL, etc. so you can run Burr on top of what you have available.
  6. More out of the box plugins for fine-grained tracing, e.g. decorators for your functions, LLM clients, etc.

  If you want to avoid self-hosting the above solutions we're building Burr Cloud. To let us know you're interested
  sign up [here](https://forms.gle/w9u2QKcPrztApRedA) for the waitlist to get access.



  We welcome contributors! To get started on developing, see the [developer-facing docs](https://burr.dagworks.io/contributing).





  Users who have contributed core functionality, integrations, or examples.

  - [Elijah ben Izzy](https://github.com/elijahbenizzy)
  - [Stefan Krawczyk](https://github.com/skrawcz)
  - [Joseph Booth](https://github.com/jombooth)
  - [Nandani Thakur](https://github.com/NandaniThakur)
  - [Thierry Jean](https://github.com/zilto)
  - [Hamza Farhan](https://github.com/HamzaFarhan)
  - [Abdul Rafay](https://github.com/proftorch)



  Users who have contributed small docs fixes, design suggestions, and found bugs

  - [Luke Chadwick](https://github.com/vertis)
  - [Evans](https://github.com/sudoevans)
  - [Sasmitha Manathunga](https://github.com/mmz-001)


pkgId: 4b4c9d7a8d83669eb93b4bfa2825b2ff50352df44a5820bcb7f111d2e73a5533
name: python-bursty-dynamics
arch: src
version: 0.1.5
epoch: 0
release: 1
url: https://github.com/ai-multiply/bursty_dynamics
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bursty-dynamics-0.1.5-1.src.rpm
checksum_type: sha256
summary:
  bursty_dynamics is a Python package designed to facilitate the analysis of temporal patterns in longitudinal data. It provides functions to calculate the burstiness parameter (BP) and memory coefficient (MC), detect event trains, and visualise results.

description:
  - Burstiness Parameter (BP) and Memory Coefficient (MC) Calculation: Calculate BP and MC to quantify the irregularity and memory effects of event timing within longitudinal data.
  - Event Train Detection: Detect and label event trains based on user-defined criteria such as maximum inter-event time and minimum burst size.
  - Train-Level Analysis: Analyse BP and MC for detected event trains, providing insights into temporal patterns within trains of events.
  - Visualisation Tools: Visualise temporal patterns with scatter plots, histograms, kernel density estimates (KDE), and more, facilitating interpretation of analysis results.
  - User-Friendly Interface: Designed for ease of use, with clear function parameters and output formats, making it accessible to both novice and experienced users.


pkgId: 7a1af47a3a55f77f44f63a995ae2122dc88720f78dcb335fd91113667756f69b
name: python-busGal-api
arch: src
version: 0.2.2.1
epoch: 0
release: 1
summary: Python API wrapper for the galician public transport
url: https://github.com/peprolinbot/bus.gal-api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-busGal-api-0.2.2.1-1.src.rpm
checksum_type: sha256
description:
  [![GitHub license](https://img.shields.io/github/license/peprolinbot/bus.gal-api)](https://github.com/peprolinbot/bus.gal-api)
  [![PyPI version](https://img.shields.io/pypi/v/busGal-api?label=pypi%20package)](https://pypi.org/project/busGal-api)
  [![Upload Python Package](https://github.com/peprolinbot/bus.gal-api/actions/workflows/python-publish.yml/badge.svg)](https://github.com/peprolinbot/bus.gal-api/actions/workflows/python-publish.yml)

  Python API wrapper for [the galician public transport](https://www.bus.gal/) which uses the
  associated
  [app](https://play.google.com/store/apps/details?id=gal.xunta.transportepublico)'s
  http API to get the inforamtion about buses, your card and your user
  account. I got the endpoints using [mitmproxy](https://mitmproxy.org/).



  Documentation can be found [here](https://peprolinbot.github.io/bus.gal-api). There are two main submodules: `busGal_api.transport` and `busGal_api.accounts`, the first one has all the functions related to transportation and the second one allows you to manage cards and accounts, as the name implies.



  Just run:

  ``` bash
  pip install busGal_api
  ```



  There are quick examples for both the submodules mentioned above in their `__main__.py` and their docs.



  This project is not endorsed by, directly affiliated with, maintained
  by, sponsored by or in any way officially related with la Xunta de
  Galicia, the bus operators or any of the companies involved in the
  [bus.gal](https://www.bus.gal/) website and the
  [app](https://play.google.com/store/apps/details?id=gal.xunta.transportepublico).

  This software is provided 'as is' without any warranty of any kind. The user of this software assumes all responsibility and risk for its use. I shall not be liable for any damages or misuse of this software. Please use the code and information in this repo responsibly.


pkgId: a12ddbb7930443d6ca914d546f4f2be38aebc0a32719911dccb49a1aaba91093
name: python-business-duration
arch: src
version: 0.67
epoch: 0
release: 1
url: https://github.com/gnaneshwar441/Business_Duration
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-business-duration-0.67-1.src.rpm
checksum_type: sha256
summary:
  Calculates business duration in days, hours, minutes and seconds by excluding weekends, public holidays and non-business hours

description:
  Calculates business duration in days, hours, minutes and seconds by
  excluding weekends, public holidays and non-business hours


pkgId: 1c062af2bf377f3fbdd41c33168f5fbd174de43c19bec7fe05429fb7db7e4856
name: python-business-rule-engine
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Python DSL for setting up business intelligence rules
url: https://github.com/manfred-kaiser/business-rule-engine
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-business-rule-engine-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![CodeFactor](https://www.codefactor.io/repository/github/manfred-kaiser/business-rule-engine/badge)](https://www.codefactor.io/repository/github/manfred-kaiser/business-rule-engine)
  [![Github version](https://img.shields.io/github/v/release/manfred-kaiser/business-rule-engine?label=github&logo=github)](https://github.com/manfred-kaiser/business-rule-engine/releases)
  [![PyPI version](https://img.shields.io/pypi/v/business-rule-engine.svg?logo=pypi&logoColor=FFE873)](https://pypi.org/project/business-rule-engine/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/business-rule-engine.svg?logo=python&logoColor=FFE873)](https://pypi.org/project/business-rule-engine/)
  [![PyPI downloads](https://pepy.tech/badge/business-rule-engine/month)](https://pepy.tech/project/business-rule-engine/month)
  [![GitHub](https://img.shields.io/github/license/manfred-kaiser/business-rule-engine.svg)](LICENSE)
  As a software system grows in complexity and usage, it can become burdensome if every change to the logic/behavior of the system also requires you to write and deploy new code. The goal of this business rules engine is to provide a simple interface allowing anyone to capture new rules and logic defining the behavior of a system, and a way to then process those rules on the backend.
  You might, for example, find this is a useful way for analysts to define marketing logic around when certain customers or items are eligible for a discount or to automate emails after users enter a certain state or go through a particular sequence of events.


  Variables represent values in your system, usually the value of some particular object.  You create rules by setting threshold conditions such that when a variable is computed that triggers the condition some action is taken.
  ```python
  params = {
      'products_in_stock': 10
  }
  ```

  ```python
  def order_more(items_to_order):
      print("you ordered {} new items".format(items_to_order))
      return items_to_order
  ```

  ```python
  rules = """
  rule "order new items"
  when
      products_in_stock < 20
  then
      order_more(50)
  end
  """
  ```

  ```python
  from business_rule_engine import RuleParser
  parser = RuleParser()
  parser.register_function(order_more)
  parser.parsestr(rules)
  parser.execute(params)
  ```

  Business rule engine uses Excel like functions (thanks to [formulas](https://github.com/vinci1it2000/formulas). So it is possible to use most of them in rules.

  You can make multiple checks on the same params, and call multiple actions as needed:
  ```python
  rules = """
  rule "order new items"
  when
      AND(products_in_stock < 20,
      products_in_stock >= 5)
  then
      order_more(50)
  end
  rule "order new items urgent"
  when
      products_in_stock < 5,
  then
      AND(order_more(10, true),
      order_more(50))
  end
  """
  ```

  You can also write your own functions to validate conditions and use other libraries functions as actions:
  ```python
  from business_rule_engine import RuleParser
  def is_even(num):
     if (num % 2) == 0:
        return True
     return False
  params = {
      'number': 10
  }
  rules = """
  rule "check even number"
  when
      is_even(number) = True
  then
      print("is even")
  end
  """
  parser = RuleParser()
  parser.register_function(is_even)
  parser.register_function(print)
  parser.parsestr(rules)
  parser.execute(params)
  ```

  If some argruments are missing, the rule engine will raise a ValueError.
  There are some use cases, when you have to work with incomplete data. In such cases, you can define
  default arguments.
  You enable default rule arguments with the parameter `set_defaule_arg`. The default argument will have the Value `None`. To provide another value you can use `default_arg`.
  ```python
  params = {}
  rules = """
  rule "order new items"
  when
      products_in_stock < 20
  then
      order_more(50)
  end
  """
  parser = RuleParser()
  parser.register_function(order_more)
  parser.parsestr(rules)
  parser.execute(params, set_default_arg=True, default_arg=0)
  ```

  if you need more control, how the rule parser handles rules, you can iterate over the parser and execute each rule in your script.
  This gives you more control on how to handle missing arguments, rules with errors and you have access to the return values of the conditions and the actions.
  ```python
  from business_rule_engine import RuleParser
  from business_rule_engine.exceptions import MissingArgumentError
  def order_more(items_to_order):
      return "you ordered {} new items".format(items_to_order)
  rules = """
  rule "order new items"
  when
      products_in_stock < 20
  then
      order_more(50)
  end
  """
  params = {
      'products_in_stock': 10
  }
  parser = RuleParser()
  parser.register_function(order_more)
  parser.parsestr(rules)
  for rule in parser:
      try:
          rvalue_condition, rvalue_action = rule.execute(params)
          if rule.status:
              print(rvalue_action)
              break
      except MissingArgumentError:
          pass
  ```

  Most of the errors are caused by missing parameters, you can handle the errors and interpret the results handling ValueError:
  ```python
  from business_rule_engine import RuleParser

  params = {
      'produtcs_in_stock': 30
  }
  rules = """
  rule "order new items"
  when
      products_in_stock < 20
  then
      order_more(50)
  end
  """
  parser = RuleParser()
  parser.register_function(order_more)
  parser.parsestr(rules)
  try:
      ret = parser.execute(params)
      if ret is False:
          print("No conditions matched")
  except ValueError as e:
      print(e)
  ```

  To debug the rules processing, use the logging lib.
  You can insert in your Python script to log to stdout:
  ```
  import logging
  logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
  ```


pkgId: 11d8cb00f6ad638b391c9c8eb2c59fd31e6e09aae3886bed39197d3635963362
name: python-business-rules-extra
arch: src
version: 1.0.11
epoch: 0
release: 1
url: https://github.com/annawinkler/business-rules
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-business-rules-extra-1.0.11-1.src.rpm
checksum_type: sha256
summary:
  Python DSL for setting up business intelligence rules that can be configured without code; based on Venmo/business-rules.


pkgId: 42dea9eb17ab15a76398ee0cc5005efd6e2fbf4c67be1ba9df9c97a5aae2e3c7
name: python-business_calendar
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Simple business days, including custom work week and a holiday list.
url: https://github.com/antoniobotelho/py-business-calendar/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-business_calendar-0.2.1-1.src.rpm
checksum_type: sha256
description:
  **business_calendar** is a Python package that implements simple business days
  calculations. You can use a custom work week and a holiday list.
  Documentation
  ^^^^^^^^^^^^^
  You can find the latest documentation `here <http://py-business-calendar.readthedocs.org/en/latest/>`_.
  Example
  ^^^^^^^
  	from business_calendar import Calendar, MO, TU, WE, TH, FR
  	import datetime
  	date1 = datetime.datetime(2013,1,10)
  	
  	cal = Calendar()
  	date2 = cal.addbusdays(date1, 25)
  	print('%s days between %s and %s' % \
  	    (cal.busdaycount(date1, date2), date1, date2))
  	
  	cal = Calendar(workdays=[MO,TU,WE,TH])
  	date2 = cal.addbusdays(date1, 25)
  	print('%s days between %s and %s' % \
  	    (cal.busdaycount(date1, date2), date1, date2))
  	
  	cal = Calendar(workdays=[MO,TU,WE,TH], holidays=['2013-01-17'])
  	date2 = cal.addbusdays(date1, 25)
  	print('%s days between %s and %s' % \
  	    (cal.busdaycount(date1, date2), date1, date2)
  License
  ^^^^^^^
  MIT


pkgId: 578f5feb2d81f0c368b34d70d14284183bb9db1c49ad8ecc900003d76b86b394
name: python-businessdate
arch: src
version: 0.7
epoch: 0
release: 1
summary: Python library for generating business dates for fast date operations and rich functionality.
url: https://github.com/sonntagsgesicht/businessdate
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-businessdate-0.7-1.src.rpm
checksum_type: sha256
description:
  A fast, efficient Python library for generating `business dates` for simple and fast date operations.
     >>> from businessdate import BusinessDate
     >>> BusinessDate(2017,12,31) + '2 weeks'
     BusinessDate(20180114)
     >>> BusinessDate(20171231) + '2w'  # same but shorter
     BusinessDate(20180114)
     >>> BusinessDate(20180114).to_date()
     datetime.date(2018, 1, 14)
  Typical banking business features are provided like `holiday adjustments`
  to move dates away from weekend days or `holidays`. As well as functionality to get
  `year fractions` depending on `day count conventions` as the lengths of interest payment periods.
  Beside dates `business periods` can be created for time intervals like **10Y**, **3 Months** or **2b**.
  Those periods can easily be added to or subtracted from business dates.
  Moreover `range` style `schedule generator`
  are provided to systematic build a list of dates.
  Such are used to set up a payment schedule of loan and financial derivatives.


pkgId: 34604f72749181b3a09b64e77bb42b54f7c3dcd02f0bbddaab381ea25ed02a83
name: python-businessoptics
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Client for the BusinessOptics API
url: https://github.com/BusinessOptics/businessoptics_client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-businessoptics-0.8.0-1.src.rpm
checksum_type: sha256
description:
  Easy access to the BusinessOptics API, based on the python requests library.
  For example:
  ```python
  from businessoptics import Client
  print Client(auth=('user@example.com', 'apikey')).workspace(123).query('ideaname').tuples()
  ```


pkgId: dcadb0e600f3abcbb6a385ea0d63cbc5232c120602ecf6fdd0f521e82872c66c
name: python-businessready
arch: src
version: 0.9.152
epoch: 0
release: 1
summary: Transform Cisco CLIs and APIs into Business Ready Documents
url: https://github.com/automateyournetwork/business_ready
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-businessready-0.9.152-1.src.rpm
checksum_type: sha256
description:
  [![published](https://static.production.devnetcloud.com/codeexchange/assets/images/devnet-published.svg)](https://developer.cisco.com/codeexchange/github/repo/automateyournetwork/business_ready)





































  ```console

  $ python3 -V
  Python 3.9.10

  ```




  ```console

  $ sudo apt install python3-venv
  $ python3 -m venv demo
  $ source demo/bin/activate
  (demo)$

  ```




  ```console

  (demo)$ pip install pyats[full]

  ```




  ```console

  (demo)$ pip install businessready

  ```









  ```console

  C:\>python3 -m venv demo
  C:\>demo\Scripts\activate
  (demo) C:\>

  ```




  ``` console

  (demo) C:\>pip install buisnessready

  ```







  ```console

  (demo)$ python3
  >>> import businessready

  ```


  ```console

  (demo) C:\>python3
  >>> import businessready

  ```











  ``` console

  >>> import businessready
  >>> businessready.IOS_all("hostname","username","password","IP / DNS Address")

  ```


  ``` console

  >>> import businessready
  >>> businessready.IOS_learn_all("hostname","username","password","IP / DNS Address")

  ```



  ``` console

  >>> import businessready
  >>> businessready.IOS_show_all("hostname","username","password","IP / DNS Address")

  ```


  ``` console

  >>> import businessready
  >>> businessready.IOS_learn_{{ function }}("hostname","username","password","IP / DNS Address")
  >>> businessready.IOS_show_{{ show command }}("hostname","username","password","IP / DNS Address")

  ```




  ``` console

  >>> import businessready
  >>> businessready.NXOS_all("hostname","username","password","IP / DNS Address")

  ```


  ``` console

  >>> import businessready
  >>> businessready.NXOS_learn_all("hostname","username","password","IP / DNS Address")

  ```



  ``` console

  >>> import businessready
  >>> businessready.NXOS_show_all("hostname","username","password","IP / DNS Address")

  ```


  ``` console

  >>> import businessready
  >>> businessready.NXOS_learn_{{ function }}("hostname","username","password","IP / DNS Address")
  >>> businessready.NXOS_show_{{ show command }}("hostname","username","password","IP / DNS Address")

  ```









  ``` console

  >>> import businessready
  >>> businessready.DNAC_all("url","username","password")

  ```


  ``` console

  >>> import businessready
  >>> businessready.DNAC_{{ REST API }}("url","username","password")

  ```






  ``` console

  >>> import businessready
  >>> businessready.Meraki_all("url","Dashboard Token")

  ```


  ``` console

  >>> import businessready
  >>> businessready.Meraki_{{ REST API }}("url","Dashboard Token")

  ```

  * In Development

  * In Development










  ```python

  import businessready

  device01_info = ["dist-rtr01", "cisco", "cisco", "10.10.20.175"]
  device02_info = ["dist-rtr02", "cisco", "cisco", "10.10.20.176"]

  device_list = [device01_info, device02_info]

  for device in device_list:
      businessready.NXOS_learn_all(*device)

  ```







  ```python

  import businessready
  import yaml

  with open('testbed.yml') as info:
      info_dict = yaml.safe_load(info)

  for device in info_dict['devices']:
      if info_dict['devices'][device]['os'] == "iosxe":
          businessready.IOS_learn_all(device,info_dict['devices'][device]['credentials']['default']['username'],info_dict['devices'][device]['credentials']['default']['password'],info_dict['devices'][device]['connections']['cli']['ip'])
      elif info_dict['devices'][device]['os'] == "nxos":
          businessready.NXOS_learn_all(device,info_dict['devices'][device]['credentials']['default']['username'],info_dict['devices'][device]['credentials']['default']['password'],info_dict['devices'][device]['connections']['cli']['ip'])

  ```







  ```python

  import businessready
  import csv

  with open('spreadsheet.csv') as info:
      for line in csv.DictReader(info):
  	    info_dict = line
          print(info_dict)
  	    if info_dict['os'] == "iosxe":
              businessready.IOS_all(info_dict['hostname'],info_dict['username'],info_dict['password'],info_dict['ip'])
  	    elif info_dict['os'] == "nxos":
              businessready.NXOS_all(info_dict['hostname'],info_dict['username'],info_dict['password'],info_dict['ip'])

  ```


pkgId: 7a2728820498ef2e019e36e2fdc4e7c27e778471dcc0b6a55cd90edd1a3672bc
name: python-businesstime
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A simple utility for calculating business time aware timedeltas between two datetimes
url: http://github.com/seatgeek/businesstime
rpm_license: Copyright (c) 2014, SeatGeek, Inc.
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-businesstime-0.3.0-1.src.rpm
checksum_type: sha256
description:
          BusinessTime is a simple utility for calculating business time aware timedeltas between two datetimes. BusinessTime's understanding of weekends, holidays and business hours can be easily configured in code.
              >>> datetime(2013, 12, 26, 5) - datetime(2013, 12, 23, 12)
              datetime.timedelta(2, 61200)
              >>> bt = businesstime.BusinessTime(holidays=businesstime.holidays.usa.USFederalHolidays())
              >>> bt.businesstimedelta(datetime(2013, 12, 23, 12), datetime(2013, 12, 26, 5))
              datetime.timedelta(1, 18000)


pkgId: df93650c22817e1ba3e28f794371c8110f9c99337f5fd1d92941fa612fe27d30
name: python-businesstimedelta
arch: src
version: 1.0.1
epoch: 0
release: 1
url: http://github.com/seppemans/businesstimedelta
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-businesstimedelta-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  Timedelta for business time. Supports exact amounts of time (hours, seconds), custom schedules, holidays, and time zones.

description:
  Python's timedelta for business time. This module helps you calculate the exact working time between two datetimes. It supports common scenarios such as custom schedules, holidays, and time zones.

  [![Build Status](https://travis-ci.org/seppemans/businesstimedelta.svg?branch=master)](https://travis-ci.org/seppemans/businesstimedelta)


  Use pip to install BusinessTimeDelta.

  ```shell
  pip install businesstimedelta
  ```


  Define your business hours

  ```python
  import datetime
  import pytz
  import businesstimedelta


  workday = businesstimedelta.WorkDayRule(
      start_time=datetime.time(9),
      end_time=datetime.time(18),
      working_days=[0, 1, 2, 3, 4])


  lunchbreak = businesstimedelta.LunchTimeRule(
      start_time=datetime.time(12),
      end_time=datetime.time(13),
      working_days=[0, 1, 2, 3, 4])


  businesshrs = businesstimedelta.Rules([workday, lunchbreak])
  ```

  Calculate the business time between two datetimes

  ```python
  start = datetime.datetime(2016, 1, 18, 9, 0, 0)
  end = datetime.datetime(2016, 1, 22, 18, 0, 0)
  bdiff = businesshrs.difference(start, end)

  print bdiff


  print "%s hours and %s seconds" % (bdiff.hours, bdiff.seconds)

  ```

  Business time arithmetic

  ```python
  print start + businesstimedelta.BusinessTimeDelta(businesshrs, hours=40)


  print end - businesstimedelta.BusinessTimeDelta(businesshrs, hours=40)

  ```

  To define holidays, simply use the [Holidays](https://pypi.python.org/pypi/holidays) package

  ```python
  import holidays as pyholidays

  ca_holidays = pyholidays.US(state='CA')
  holidays = businesstimedelta.HolidayRule(ca_holidays)
  businesshrs = businesstimedelta.Rules([workday, lunchbreak, holidays])


  start = datetime.datetime(2015, 12, 21, 9, 0, 0)
  end = datetime.datetime(2015, 12, 28, 9, 0, 0)
  print businesshrs.difference(start, end)

  ```


  If your datetimes are not timezone aware, they will be localized to UTC (see example above).

  Let's say you want to calculate the business time overlap between a working day in San Francisco and in Santiago, Chile:
  ```python
  santiago_workday = businesstimedelta.WorkDayRule(
      start_time=datetime.time(9),
      end_time=datetime.time(18),
      working_days=[0, 1, 2, 3, 4],
      tz=pytz.timezone('America/Santiago'))

  santiago_lunchbreak = businesstimedelta.LunchTimeRule(
      start_time=datetime.time(12),
      end_time=datetime.time(13),
      working_days=[0, 1, 2, 3, 4],
      tz=pytz.timezone('America/Santiago'))

  santiago_businesshrs = businesstimedelta.Rules([santiago_workday, santiago_lunchbreak])

  sf_tz = pytz.timezone('America/Los_Angeles')
  sf_start = sf_tz.localize(datetime.datetime(2016, 1, 18, 9, 0, 0))
  sf_end = sf_tz.localize(datetime.datetime(2016, 1, 18, 18, 0, 0))

  print santiago_businesshrs.difference(sf_start, sf_end)

  ```


  ```python

  workday = WorkDayRule(
      start_time=datetime.time(9),
      end_time=datetime.time(17),
      working_days=[0, 1, 2, 3, 4],
      tz=pytz.utc)


  nightshift = businesstimedelta.WorkDayRule(
      start_time=datetime.time(23),
      end_time=datetime.time(7),
      working_days=[0, 1, 2, 3, 4])

  businesshrs = businesstimedelta.Rules([workday, nightshift])

  start = datetime.datetime(2016, 1, 18, 9, 0, 0)
  end = datetime.datetime(2016, 1, 22, 18, 0, 0)
  bdiff = businesshrs.difference(start, end)

  print bdiff

  ```


pkgId: 12b106fb1059e99f301c0c45f5bed877edca493c7af8221d304590a1fc220707
name: python-busker
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: A utility for testing Balladeer projects.
url: https://pypi.org/project/busker/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-busker-0.14.0-1.src.rpm
checksum_type: sha256
description:
  Busker is a utility for testing [Balladeer](https://tundish.github.io/balladeer) projects.
  It provides a graphical interface for interaction with a Balladeer host.
  Busker also allows you to self-host the Balladeer application, simplifying the steps required:
  + Creating a Python virtual environment.
  + Installing the Balladeer package along with its dependencies.
  + Running the Balladeer server.

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


pkgId: 34ae86deb7f22dc6db4bd999f3fa1000e19e84c9f077dbe131c756196cc3aa20
name: python-buslane
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/konradhalas/buslane
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buslane-0.0.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/konradhalas/buslane.svg?branch=master)](https://travis-ci.org/konradhalas/buslane)
  [![License](https://img.shields.io/pypi/l/buslane.svg)](https://pypi.python.org/pypi/buslane/)
  [![Version](https://img.shields.io/pypi/v/buslane.svg)](https://pypi.python.org/pypi/buslane/)
  [![Python versions](https://img.shields.io/pypi/pyversions/buslane.svg)](https://pypi.python.org/pypi/buslane/)

  Simple message (event/command) bus.



  To install `buslane`, simply use `pip` (or `pipenv`):

  ```
  $ pip install buslane
  ```



  Minimum Python version supported by `buslane` is 3.6.



  ```python
  from dataclasses import dataclass

  from buslane.commands import Command, CommandHandler, CommandBus


  @dataclass
  class RegisterUserCommand(Command):
      email: str
      password: str


  class RegisterUserCommandHandler(CommandHandler[RegisterUserCommand]):

      def handle(self, command: RegisterUserCommand) -> None:
          assert command == RegisterUserCommand(
              email='john@lennon.com',
              password='secret',
          )


  command_bus = CommandBus()
  command_bus.register(handler=RegisterUserCommandHandler())
  command_bus.execute(command=RegisterUserCommand(
      email='john@lennon.com',
      password='secret',
  ))
  ```



  This library makes it easier to create solutions based on messages. If you want to split event occurrence from its
  handling, `buslane` is the way to go. It supports commands (single handler) and events (0 or multiple handlers)
  approach.



  This package could be probably replaced with a simple Python dictionary with messages classes as keys and ordinary
  functions as values. Python is a dynamic language and we can implement such solution very easy, without any classes,
  inheritance, methods overriding and so one. So why you should use `buslane`? Is it the *pythonic* approach?

  First of all, `buslane` is very simple and tiny project. I was copying these few lines from project to project, so now I
  don't have to.

  Secondly, I'm a huge fan of type annotations. This a game changer in a project with a huge codebase. `buslane` has
  type hints everywhere and it is based on [Python generics][python-generics]. In combination with such tools like
  [`mypy`][mypy] you will be sure that you are doing (from types point of view) everything OK.

  Message handler is a class instead of function, because you can easily inject your dependencies via `__init__`
  parameters. Such class is very easy to test, you don't have to `mock.patch` everything. The interface is clear.

  Last but not least - the `buslane` API is simple and well defined. You can extend it easily, e.g. log all of your
  messages or store them in a database.

  It can be used as a foundation of your CQRS-based system.



  `buslane` uses Python type annotations to properly register handler. To create your message you have to inherit from
  `Event` or `Command` class. Handler should inherit from `EventHandler[T]` or `CommandHandler[T]`, where `T` is a class
  of your message.



  You can register multiple or none handlers for a single event.

  Classes:

  - `Event`
  - `EventHandler[Event]`
  - `EventBus`

  Exceptions:

  - `WrongHandlerException`



  ```python
  from buslane.events import Event, EventHandler, EventBus


  class SampleEvent(Event):
      pass


  class SampleEventHandler(EventHandler[SampleEvent]):

      def handle(self, event: SampleEvent) -> None:
          pass


  event_bus = EventBus()
  event_bus.register(handler=SampleEventHandler())
  event_bus.publish(event=SampleEvent())
  ```



  You have to register only single handler for the given command.

  Classes:

  - `Command`
  - `CommandHandler[Command]`
  - `CommandBus`

  Exceptions:

  - `MissingCommandHandlerException`
  - `CommandHandlerRegisteredException`
  - `WrongHandlerException`



  ```python
  from buslane.commands import Command, CommandHandler, CommandBus


  class SampleCommand(Command):
      pass


  class SampleCommandHandler(CommandHandler[SampleCommand]):

      def handle(self, command: SampleCommand) -> None:
          pass


  command_bus = CommandBus()
  command_bus.register(handler=SampleCommandHandler())
  command_bus.execute(command=SampleCommand())
  ```



  If you want to customize behaviour of your bus, you can override `handle` method from `EventBus` / `CommandBus` class.

  The following example shows a bus which logs every event and process it in a thread.

  ```python
  import logging
  from concurrent.futures import ThreadPoolExecutor


  class CustomEventBus(EventBus):

      def __init__(self, workers: int) -> None:
          super().__init__()
          self.logger = logging.getLogger()
          self.executor = ThreadPoolExecutor(max_workers=workers)

      def handle(self, event: Event, handler: EventHandler) -> None:
          self.logger.info(f'Handling event {event} by {handler}')
          self.executor.submit(handler.handle, event)
  ```



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

  [halas-homepage]: https://konradhalas.pl
  [python-generics]: https://docs.python.org/3/library/typing.html#generics
  [mypy]: https://github.com/python/mypy/


pkgId: 4063dad03017db1cefd7696d5c695ac3286da0e58b500d640d72912d8b764744
name: python-buslib
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: Client library for interfacing with the BUS Methodology data API
url: https://bitbucket.org/busmethodology/python-buslib/overview
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buslib-1.10.0-1.src.rpm
checksum_type: sha256
description:
  Typical contents for this file would include an overview of the project, basic
  usage examples, etc. Generally, including the project changelog in here is not
  a good idea, although a simple "What's New" section for the most recent version
  may be appropriate.


pkgId: 28c5d0b711f6ebd6a077045949c12f67df5ac053b3a52b08a570489525173643
name: python-busline
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Agnostic eventbus for Python
url: https://github.com/nricciardi/py-busline
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-busline-0.3.1-1.src.rpm
checksum_type: sha256
description:
  Agnostic eventbus for Python.

  Official eventbus library for [Orbitalis](https://github.com/nricciardi/orbitalis)





  ```python
  from busline.eventbus.async_local_eventbus import AsyncLocalEventBus
  from busline.eventbus_client.publisher.local_eventbus_publisher import LocalEventBusPublisher
  from busline.event.event import Event
  from busline.eventbus_client.subscriber.local_eventbus_closure_subscriber import LocalEventBusClosureSubscriber

  local_eventbus_instance = AsyncLocalEventBus()  # singleton


  def callback(topic_name: str, event: Event):
      print(event)


  subscriber = LocalEventBusClosureSubscriber(local_eventbus_instance, callback)
  publisher = LocalEventBusPublisher(local_eventbus_instance)

  await subscriber.subscribe("test-topic")

  await publisher.publish("test-topic", Event())  # publish empty event
  ```



  ```python
  from busline.event.event import Event
  from busline.eventbus_client.local_eventbus_client import LocalEventBusClient


  def callback(topic_name: str, event: Event):
      print(event)


  client = LocalEventBusClient(callback)

  await client.subscribe("test")

  await client.publish("test", Event())
  ```




  Implement business logic of your `Publisher` and `Subscriber` and... done. Nothing more.

  ```python
  from busline.event.event import Event
  from busline.eventbus_client.publisher.publisher import Publisher


  class YourEventBusPublisher(Publisher):

      async def _internal_publish(self, topic_name: str, event: Event, **kwargs):
          pass  # send events to your eventbus (maybe in cloud?)
  ```

  ```python
  from busline.eventbus_client.subscriber.subscriber import Subscriber
  from busline.event.event import Event


  class YourEventBusSubscriber(Subscriber):

      async def on_event(self, topic_name: str, event: Event, **kwargs):
          pass  # receive your events
  ```

  You could create a client to allow components to use it instead of become a publisher or subscriber.

  ```python
  from busline.eventbus_client.eventbus_client import EventBusClient
  from busline.event.event import Event


  def client_callback(topic_name: str, e: Event):
      print(e)


  subscriber = YourEventBusSubscriber(...)
  publisher = YourEventBusPublisher(...)

  client = EventBusClient(publisher, subscriber, ClosureEventListener(client_callback))
  ```


pkgId: 2c2ab1eeef00e40dbd7216b9bf81c394e191515ab0792b01136933deab1629e4
name: python-bussilab
arch: src
version: 0.0.45
epoch: 0
release: 1
summary: A package collecting a heterogeneous set of tools.
url: https://github.com/bussilab/py-bussilab
rpm_license: GNU Lesser General Public License v2 or later (LGPLv2+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bussilab-0.0.45-1.src.rpm
checksum_type: sha256
description:
  [![GitHub tag (latest SemVer)](https://img.shields.io/github/v/tag/bussilab/py-bussilab)](https://github.com/bussilab/py-bussilab/tags)
  [![PyPI](https://img.shields.io/pypi/v/bussilab)](https://pypi.org/project/bussilab/)
  [![Conda](https://img.shields.io/conda/v/bussilab/py-bussilab)](https://anaconda.org/bussilab/py-bussilab)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bussilab)](https://pypi.org/project/bussilab/)

  [![CI](https://github.com/bussilab/py-bussilab/workflows/CI/badge.svg)](https://github.com/bussilab/py-bussilab/actions?query=workflow%3ACI)
  [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/bussilab/py-bussilab.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/bussilab/py-bussilab/context:python)
  [![Total alerts](https://img.shields.io/lgtm/alerts/g/bussilab/py-bussilab.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/bussilab/py-bussilab/alerts/)
  [![codecov](https://codecov.io/gh/bussilab/py-bussilab/branch/master/graph/badge.svg)](https://codecov.io/gh/bussilab/py-bussilab)

  A package collecting a heterogeneous set of tools.

  This package collects a number of tools that are useful enough to be distributed but too small to deserve being published as separate packages.
  Source code is on [GitHub](https://github.com/bussilab/py-bussilab).
  Documentation can be browsed at [this page](https://bussilab.github.io/doc-py-bussilab).

  To install package and dependencies with pip:

  ```
  pip install bussilab
  ```

  To install package and dependencies with conda:

  ```
  conda install -c conda-forge -c bussilab py-bussilab
  ```

  To install dependencies with macports, see [documentation](https://bussilab.github.io/doc-py-bussilab).


pkgId: 417a629552c19af36fe2e703df83f89f600010ea275deaf7f5e0321a1cfaf5ea
name: python-bust
arch: src
version: 0.13.2
epoch: 0
release: 1
summary: Utility for simply creating and modifying VHDL bus slave modules
url: http://github.com/olagrottvik/bust
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bust-0.13.2-1.src.rpm
checksum_type: sha256
description:
  ![Workflow status](https://github.com/olagrottvik/bust/actions/workflows/python_tests.yml/badge.svg)



  Utility for simply creating and modifying VHDL bus slave modules.



  The main goal of the project is to able to automatically create and modify VHDL bus slave modules based on a simple definition format.
  By employing VHDL records the handling of the registers can be completely hidden in a module separate from the rest of the design.
  All referring to the registers are done via a record that specifies if the register is read-only or read-write, and also includes the name.
  All bus-specific signals are also wrapped in records. This increases the readability of the design as a whole.



  bust currently supports these bus standards:

  - [AXI4-lite](https://en.wikipedia.org/wiki/Advanced_eXtensible_Interface#AXI4-Lite)
  - [IPBus](https://ipbus.web.cern.ch/ipbus/)



  bust is developed in an environment with python 3.9.18 but should work with the following versions:

  - python 3.9
  - python 3.10
  - python 3.11

  bust does NOT support python 2.7 and neither should you!



  Install the latest relase by using pip:

  `pip install bust`



  `bust.py FILE [-o DIR]`

  `bust.py --version`

  `bust.py -h | --help`



  The examples folder contains JSON files for the bus types supported.
  The files are human-readable to the point that you can create your own from this template alone.
  The folder also contains the output files generated based on the JSON files.


  Simulation scripts are made solely for Modelsim/Questasim. For any other simulators, you need to compile everything yourselves.
  All testbenches require UVVM - which can be cloned from their [Github page](https://github.com/UVVM/UVVM).


  IPBus requires the bus package file from the [IPBus firmware repo](https://github.com/ipbus/ipbus-firmware) and the custom [IPBus BFM repo](https://github.com/olagrottvik/vip_ipbus).

  See the example files for how you point to the specific folders.



  The latest development version can be found in the [dev branch](https://github.com/olagrottvik/bust/tree/dev) on Github. Clone the repo and check out the branch.

  `git clone https://github.com/olagrottvik/bust.git`

  `cd bust`

  `git checkout dev`

  `pip install -r requirements.txt`

  `python -m bust`





  Release notes can be found on the [Releases page](https://github.com/olagrottvik/bust/releases).




  If you have ideas on how to improve the project, please review [CONTRIBUTING.md](CONTRIBUTING.md) for details. Note that we also have a [Code of Conduct](CODE_OF_CONDUCT.md).




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


pkgId: 3551ef7b14710bc1082d692530a5e254af688dee7e7870e39a4ee8fdde5c0e35
name: python-busylight-for-humans
arch: src
version: 0.32.0
epoch: 0
release: 1
summary: Control USB connected LED lights, like a human.
url: https://github.com/JnyJny/busylight.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-busylight-for-humans-0.32.0-1.src.rpm
checksum_type: sha256
description:
  <!-- USB HID API embrava blynclight agile innovative blinkstick kuando busylight omega alpha plantronics luxafor bluetooth bt flag mute orb thingM blink(1) muteme mutesync compulab fit-statusb -->
  ![BusyLight Project Logo][LOGO]
  <br>
  ![version][pypi-version]
  ![monthly-downloads][monthly-downloads]
  ![visits][visits]
  ![supported python versions][python-versions]
  ![license][license]
  ![Code style: black][code-style-black]
  <br>
  [![pytest-linux](https://github.com/JnyJny/busylight/actions/workflows/pytest-linux.yaml/badge.svg)](https://github.com/JnyJny/busylight/actions/workflows/pytest-linux.yaml)
  [![MacOS](https://github.com/JnyJny/busylight/actions/workflows/pytest-macos.yaml/badge.svg)](https://github.com/JnyJny/busylight/actions/workflows/pytest-macos.yaml)
  [![pytest-windows](https://github.com/JnyJny/busylight/actions/workflows/pytest-windows.yaml/badge.svg)](https://github.com/JnyJny/busylight/actions/workflows/pytest-windows.yaml)
  <br>

  [BusyLight for Humans™][0] gives you control of USB attached LED
  lights from a variety of vendors. Lights can be controlled via
  the command-line, using a HTTP API or imported directly into your own
  Python project.

  ![All Supported Lights][DEMO]
  Flag<sup>1</sup>,
  Busylight Alpha<sup>2</sup>,
  Status Indicator<sup>3</sup>,
  Blink(1)<sup>4</sup>,
  Mute<sup>5</sup>,
  Blynclight<sup>6</sup>.
  Orb<sup>7</sup>,
  BusyLight Omega<sup>8</sup>,
  BlinkStick Square<sup>9</sup>,
  Blynclight Mini<sup>10</sup>,
  MuteMe Original<sup>11</sup>,
  fit-statUSB<sup>12</sup>,
  MuteSync<sup>13</sup>,
  Blynclight Plus<sup>14</sup>


  - Control lights from the [command-line][HELP].
  - Control lights via a [Web API][WEBAPI].
  - Import `busylight` into your own Python project.
  - Supported on MacOS and Linux
  - Windows support is untested but there are reports that it is working.
  - Supports _nine_ vendors & sixteen devices:

  | **Vendor** | | | | |
  |------------:|---|---|---|---|
  | [**Agile Innovative**][2] | BlinkStick Square |
  | [**Compulab**][8] | fit-statUSB |
  | [**Embrava**][3] | Blynclight | Blynclight Mini | Blynclight Plus |
  | [**Kuando**][4] | Busylight Alpha | BusyLight Omega |
  | [**Luxafor**][5] | Bluetooth | Flag | Mute | Orb |
  | [**Plantronics**][3] | Status Indicator |
  | [**MuteMe**][7] | MuteMe Original | Mute Mini |
  | [**MuteSync**][9] | MuteSync |
  | [**ThingM**][6] | Blink(1) |

  If you have a USB light that's not on this list open an issue with:
   - the make and model device you want supported
   - where I can get one
   - any public hardware documentation you are aware of

  Or even better, open a pull request!



  Thank you to [@todbot][todbot] and the very nice people at [ThingM][thingm] who
  graciously and unexpectedly gifted me with two `blink(1) mk3` lights!



  Installs only the command-line `busylight` tool and associated
  modules.

  ```console
  $ python3 -m pip install busylight-for-humans
  ```



  Installs `uvicorn` and `FastAPI` in addition to `busylight`:

  ```console
  $ python3 -m pip install busylight-for-humans[webapi]
  ```



  I use the tool [poetry][poetry-docs] to manage various aspects of this project, including:
  - dependencies
  - pytest configuration
  - versioning
  - optional dependencies
  - virtual environment creation
  - building packages
  - publishing packages to PyPi

  ```console
  $ python3 -m pip install poetry
  $ cd path/to/busylight
  $ poetry shell
  <venv> $ poetry install -E webapi
  <venv> $ which busylight
  <venv> $ which busyserve
  ```

  After installing into the virtual environment, the project is now available in editable mode.  Changes made in the source will be reflected in the runtime behavior when running in the poetry initiated shell.



  Linux controls access to USB devices via the [udev subsystem][UDEV]. By
  default it denies non-root users access to devices it doesn't
  recognize. I've got you covered!

  You'll need root access to configure the udev rules:

  ```console
  $ busylight udev-rules -o 99-busylights.rules
  $ sudo cp 99-busylights.rules /etc/udev/rules.d
  $ sudo udevadm control -R
  $ # unplug/plug your light
  $ busylight on
  ```



  ```console
  $ busylight on               # light turns on green
  $ busylight on red           # now it's shining a friendly red
  $ busylight on 0xff0000      # still red
  $ busylight on #00ff00       # now it's blue!
  $ busylight blink            # it's slowly blinking on and off with a red color
  $ busylight blink green fast # blinking faster green and off
  $ busylight --all on         # turn all lights on green
  $ busylight --all off        # turn all lights off
  ```



  First start the `busylight` API server using the `busyserv` command line interface:
  ```console
  $ busyserve -D
  INFO:     Started server process [40064]
  INFO:     Waiting for application startup.
  INFO:     Application startup complete.
  INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
  ...
  ```

  The API is fully documented and available via these URLs:

  - `https://localhost:8000/redoc`
  - `https://localhost:8000/docs`


  Now you can use the web API endpoints which return JSON payloads:

  ```console
    $ curl -s http://localhost:8000/lights/status | jq
    ...

    $ curl -s http://localhost:8000/light/0/status | jq
    ...

    $ curl -s http://localhost:8000/light/0/on | jq
    {
      "light_id": 0,
      "action": "on",
      "color": "green",
      "rgb": [0, 128, 0]
    }

    $ curl -s http://localhost:8000/light/0/off | jq
    {
      "light_id": 0,
      "action": "off"
    }

    $ curl -s http://localhost:8000/light/0/on?color=purple | jq
    {
      "light_id": 0,
      "action": "on",
      "color": "purple",
      "rgb": [128, 0, 128]
    }

    $ curl -s http://localhost:8000/lights/on | jq
    {
      "light_id": "all",
      "action": "on",
      "color": "green",
      "rgb", [0, 128, 0]
    }

    $ curl -s http://localhost:8000/lights/off | jq
    {
      "light_id": "all",
      "action": "off"
    }

    $ curl -s http://localhost:8000/lights/rainbow | jq
    {
      "light_id": "all",
      "action": "effect",
      "name": "rainbow"
    }
  ```


  The API can be secured with a simple username and password through
  [HTTP Basic Authentication][BASICAUTH]. To require authentication
  for all API requests, set the `BUSYLIGHT_API_USER` and
  `BUSYLIGHT_API_PASS` environmental variables before running
  `busyserve`.

  > :warning: **SECURITY WARNING**: HTTP Basic Auth sends usernames and passwords in *cleartext* (i.e., unencrypted). Use of SSL is highly recommended!



  Adding light support to your own python applications is easy!



  In this example, we pick an Embrava Blynclight to activate with
  the color white. Colors are specified as a three-tuple of integers
  that range from 0 to 255 and represent red, green, and blue
  in that order.

  ```python
  from busylight.lights.embrava import Blynclight

  light = Blynclight.first_light()

  light.on((255, 255, 255))

  light.off()
  ```

  Not sure what light you've got? No problem!

  ```python
  from busylight.lights import Light

  light = Light.first_light()

  light.on((0xff, 0, 0xff))

  light.off()
  ```



  The `busylight` package includes a manager class that's great for
  working with multiple lights or lights that require a little
  more direct intervention like the Kuando Busylight family.

  ```python
  from busylight.manager import LightManager
  from busylight.effects import Effects

  manager = LightManager()
  for light in manager.lights:
     print(light.name)

  rainbow = Effects.for_name("spectrum")(duty_cycle=0.05)

  manager.apply_effect(rainbow)
  ...
  manager.off()
  ```

  [0]: https://github.com/JnyJny/busylight


  <!-- doc links -->
  [2]: https://github.com/JnyJny/busylight/blob/master/docs/devices/agile_innovative.md
  [3]: https://github.com/JnyJny/busylight/blob/master/docs/devices/embrava.md
  [4]: https://github.com/JnyJny/busylight/blob/master/docs/devices/kuando.md
  [5]: https://github.com/JnyJny/busylight/blob/master/docs/devices/luxafor.md
  [6]: https://github.com/JnyJny/busylight/blob/master/docs/devices/thingm.md
  [7]: https://github.com/JnyJny/busylight/blob/master/docs/devices/muteme.md
  [8]: https://github.com/JnyJny/busylight/blob/master/docs/devices/compulab.md
  [9]: https://github.com/JnyJny/busylight/blob/master/docs/devices/mutesync.md

  [LOGO]: https://github.com/JnyJny/busylight/blob/master/docs/assets/BusyLightForHumans.png
  [HELP]: https://github.com/JnyJny/busylight/blob/master/docs/busylight.1.md
  [WEBAPI]: https://github.com/JnyJny/busylight/blob/master/docs/busylight_api.pdf

  <!-- [DEMO]: demo/demo-updated.gif -->
  [DEMO]: https://github.com/JnyJny/busylight/blob/master/docs/assets/HerdOfLights.png

  [BASICAUTH]: https://en.wikipedia.org/wiki/Basic_access_authentication
  [UDEV]: https://en.wikipedia.org/wiki/Udev

  [todbot]: https://github.com/todbot
  [thingm]: https://thingm.com

  <!-- badges -->

  [code-style-black]: https://img.shields.io/badge/code%20style-black-000000.svg
  [pypi-version]: https://img.shields.io/pypi/v/busylight-for-humans
  [python-versions]: https://img.shields.io/pypi/pyversions/busylight-for-humans
  [license]: https://img.shields.io/pypi/l/busylight-for-humans
  [dependencies]: https://img.shields.io/librariesio/github/JnyJny/busylight
  [monthly-downloads]: https://img.shields.io/pypi/dm/busylight-for-humans
  [poetry-docs]: https://python-poetry.org/docs/
  [visits]: https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2FJnyJny%2Fbusylight&count_bg=%2379C83D&title_bg=%23555555&icon=&icon_color=%23E7E7E7&title=Visits&edge_flat=false


pkgId: 4a175a84f78ae4ca45985d894424e43d80b6168d82719549953397f01839d884
name: python-busypie
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Easy and expressive busy-waiting for Python
url: https://github.com/rockem/busypie
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-busypie-0.5.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://raw.githubusercontent.com/rockem/busypie/master/docs/source/_static/busypie_logo.png" width="120"/>
  </p>
  <p align="center">
    <strong>Easy and expressive busy-waiting for Python</strong>
  </p>
  <p align="center">
    <a href="https://github.com/rockem/busypie/actions"><img src="https://github.com/rockem/busypie/workflows/Build/badge.svg"/></a>
    <a href="https://github.com/rockem/busypie/releases"><img src="https://img.shields.io/github/v/release/rockem/busypie"/></a>
    <a href="https://github.com/rockem/busypie/blob/master/LICENSE"><img src="http://img.shields.io/:license-apache2.0-blue.svg"/></a>
  </p>


  Although you wouldn't want to do much busy waiting in your production code,
  testing is a different matter. When testing asynchronous systems,
  it's very helpful to wait for some scenario to finish its course.
  busypie helps you perform busy waiting easily and expressively.


  Most typical usage will be in test, when we have a scenario
  that require us to wait for something to happen.
  ```python
  from busypie import wait, SECOND

  def test_create_user():
      create_user_from(USER_DETAILS)
      wait().at_most(2, SECOND).until(lambda: is_user_exists(USER_DETAILS))
  ```


  * [Installation](https://busypie.readthedocs.io/en/latest/install.html)
  * [Usage Guide](https://busypie.readthedocs.io/en/latest/index.html)



  This project drew a lot of inspiration from [Awaitility](https://github.com/awaitility/awaitility).


pkgId: c4512213ced2c867c24d6ab400ab1f1798b99000b717aab428a4d69b43b0d5d2
name: python-buteo
arch: src
version: 0.9.62
epoch: 0
release: 1
summary: Tools for merging Geospatial Analysis and AI.
url: https://github.com/casperfibaek/buteo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buteo-0.9.62-1.src.rpm
checksum_type: sha256
description:
  Buteo is a toolbox designed to simplify the process of working with geospatial data in machine learning. It includes tools for reading, writing, and processing geospatial data, as well as tools for creating labels from vector data and generating patches from geospatial data. Buteo makes it easy to ingest data, create training data, and perform inference on geospatial data.

  Please note that Buteo is under active development, and its API may not be entirely stable. Feel free to report any bugs or suggest improvements.

  When using, please pin the version of Buteo you are using to avoid breaking changes.

  For documentation, visit: https://casperfibaek.github.io/buteo/

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

  Fibaek, Casper. (2023). Buteo: Geospatial Data Analysis Framework for AI/EO. (v0.9.8). Zenodo. https://doi.org/10.5281/zenodo.7936577

  **Dependencies** </br>
  `numba` (https://numba.pydata.org/) </br>
  `gdal` (https://gdal.org/) </br>

  **Installation** </br>
  Using pip:
  ```
  pip install gdal
  pip install buteo
  ```
  Using conda:
  ```
  conda install gdal
  pip install buteo
  ```

  **Quickstart**


  ```python
  import buteo as beo

  OUTDIR = "path/to/output/dir"

  vector_file_correct_projection = "path/to/vector/file.gpkg"
  raster_files_wrong_projection = "path/to/raster/files/*.tif:glob"

  paths_to_reprojected_rasters = beo.reproject_raster(
      raster_files_with_wrong_projection,
      vector_file_with_correct_projection,
      out_path=outdir
  )

  paths_to_reprojected_rasters
  >>> [path/to/output/dir/file1.tif, path/to/output/dir/file2.tif, ...]
  ```


  ```python
  import buteo as beo

  SRCDIR = "path/to/src/dir/"

  paths_to_aligned_rasters_in_memory = beo.align_rasters(
      SRCDIR + "*.tif:glob",
  )

  stacked_numpy_arrays = beo.raster_to_array(
      paths_to_aligned_rasters_in_memory,
  )

  patches = beo.array_to_patches(
      stacked_numpy_arrays,
      256,
      offsets_y=1, # 1 overlap at 1/2 patch size (128)
      offsets_x=1, # 1 overlap at 1/2 patch size (128)
  )


  patches
  >>> np.ndarray([10000, 256, 256, 9])
  ```


  ```python
  import buteo as beo

  RASTER_PATH = "path/to/raster/raster.tif"
  RASTER_OUT_PATH = "path/to/raster/raster_pred.tif"

  array = beo.raster_to_array(RASTER_PATH)

  callback = model.predict # from pytorch, keras, etc..



  predicted = predict_array(
      array,
      callback,
      tile_size=256,
  )


  beo.array_to_raster(
      predicted,
      reference=RASTER_PATH,
      out_path=RASTER_OUT_PATH,
  )

  >>> "path/to/raster/raster_pred.tif"
  ```

  </br>

  | Example Colabs                        |                                                                                                                                                                                                               |
  |---------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | Create labels from OpenStreetMap data | [![Open All Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/casperfibaek/buteo/blob/master/examples/create_labels_from_osm_data.ipynb)            |
  | Scheduled cleaning of geospatial data | [![Open All Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/casperfibaek/buteo/blob/master/examples/rocket_example.ipynb)                         |
  | Clip and remove noise from rasters    | [![Open All Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/casperfibaek/buteo/blob/master/examples/clip_and_remove_noise_raster.ipynb)           |
  | Sharpen nightlights data              | [![Open All Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/casperfibaek/buteo/blob/master/examples/process_nightlights.ipynb)                    |
  | Filters and morphological operations  | [![Open All Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/casperfibaek/buteo/blob/master/examples/filters_and_morphology.ipynb)                 |


  </br>

  The toolbox is being developed by ESA-Philab, NIRAS, and Aalborg University.


  gdal
  numba

  optional:
  orfeo-toolbox
  esa-snap


pkgId: d56d2ff8c4c3c9472f93bb0b019712372acd8113881becb447111d0f619232c7
name: python-buteo
arch: src
version: 0.9.64
epoch: 0
release: 1
summary: Tools for merging Geospatial Analysis and AI.
url: https://github.com/casperfibaek/buteo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buteo-0.9.64-1.src.rpm
checksum_type: sha256
description:
  Buteo is a toolbox designed to simplify the process of working with geospatial data in machine learning. It includes tools for reading, writing, and processing geospatial data, as well as tools for creating labels from vector data and generating patches from geospatial data. Buteo makes it easy to ingest data, create training data, and perform inference on geospatial data.

  Please note that Buteo is under active development, and its API may not be entirely stable. Feel free to report any bugs or suggest improvements.

  When using, please pin the version of Buteo you are using to avoid breaking changes.

  For documentation, visit: https://casperfibaek.github.io/buteo/

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

  Fibaek, Casper. (2024). Buteo: Geospatial Data Analysis Framework for AI/EO. (v0.9.63). Zenodo. https://doi.org/10.5281/zenodo.7936577

  **Dependencies** </br>
  `numba` (https://numba.pydata.org/) </br>
  `gdal` (https://gdal.org/) </br>

  **Installation** </br>
  Using pip:
  ```
  pip install gdal
  pip install buteo
  ```
  Using conda:
  ```
  conda install gdal
  pip install buteo
  ```

  **Quickstart**


  ```python
  import buteo as beo

  OUTDIR = "path/to/output/dir"

  vector_file_correct_projection = "path/to/vector/file.gpkg"
  raster_files_wrong_projection = "path/to/raster/files/*.tif:glob"

  paths_to_reprojected_rasters = beo.reproject_raster(
      raster_files_with_wrong_projection,
      vector_file_with_correct_projection,
      out_path=outdir
  )

  paths_to_reprojected_rasters
  >>> [path/to/output/dir/file1.tif, path/to/output/dir/file2.tif, ...]
  ```


  ```python
  import buteo as beo

  SRCDIR = "path/to/src/dir/"

  paths_to_aligned_rasters_in_memory = beo.align_rasters(
      SRCDIR + "*.tif:glob",
  )

  stacked_numpy_arrays = beo.raster_to_array(
      paths_to_aligned_rasters_in_memory,
  )

  patches = beo.array_to_patches(
      stacked_numpy_arrays,
      256,
      offsets_y=1, # 1 overlap at 1/2 patch size (128)
      offsets_x=1, # 1 overlap at 1/2 patch size (128)
  )


  patches
  >>> np.ndarray([10000, 256, 256, 9])
  ```


  ```python
  import buteo as beo

  RASTER_PATH = "path/to/raster/raster.tif"
  RASTER_OUT_PATH = "path/to/raster/raster_pred.tif"

  array = beo.raster_to_array(RASTER_PATH)

  callback = model.predict # from pytorch, keras, etc..



  predicted = predict_array(
      array,
      callback,
      tile_size=256,
  )


  beo.array_to_raster(
      predicted,
      reference=RASTER_PATH,
      out_path=RASTER_OUT_PATH,
  )

  >>> "path/to/raster/raster_pred.tif"
  ```

  </br>

  | Example Colabs                        |                                                                                                                                                                                                               |
  |---------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | Create labels from OpenStreetMap data | [![Open All Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/casperfibaek/buteo/blob/master/examples/create_labels_from_osm_data.ipynb)            |
  | Scheduled cleaning of geospatial data | [![Open All Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/casperfibaek/buteo/blob/master/examples/rocket_example.ipynb)                         |
  | Clip and remove noise from rasters    | [![Open All Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/casperfibaek/buteo/blob/master/examples/clip_and_remove_noise_raster.ipynb)           |
  | Sharpen nightlights data              | [![Open All Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/casperfibaek/buteo/blob/master/examples/process_nightlights.ipynb)                    |
  | Filters and morphological operations  | [![Open All Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/casperfibaek/buteo/blob/master/examples/filters_and_morphology.ipynb)                 |


  </br>

  The toolbox is being developed by ESA-Philab, NIRAS, and Aalborg University.


  gdal
  numba

  optional:
  orfeo-toolbox
  esa-snap


pkgId: 3ed6f3a29e48e02ebf654504c45e29ab0d91077db148d63fde3e4239972135d8
name: python-butler-connect
arch: src
version: 0.10.3
epoch: 0
release: 1
summary: Access libraries (with pika) and data definitions for the Buttler project.
url: https://pypi.org/project/butler-connect/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-butler-connect-0.10.3-1.src.rpm
checksum_type: sha256
description:
  Access libraries and data definitions for the Buttler project.
  For more information ask Oliver Birkholz.



  - Adding vhost Support

  - Adding sending automatic heartbeats in publisher-function

  - update sending automatic heartbeats
  - handling error

  - adding group-types

  - adding signalOptionType and groupOptionType with forwardingMQTT

  - Solving problems on publishing data without connecting dest

  - Solving Problems with createConsumer with same topic an different routing_keys


  - add new signal  types f.ex. system_state or set_temperature.heater


  - change signal Description and add ext. !!! No backwards compatibility! if Using Schmema for parsing


  - Bugifx in Signal().__init__(.. ext was missing)

  - create SignalDirection()
  - add convertFrom to SignalOptionType
  - add different consumptionSignals to SignalType

  - add buildingHardware to signalOptionType and groupOptionType
  - add agent_building to groupOptionType

  - add SignalType co2
  - add SignalType consumption*Current

  - add SignalOptionType SignalOptionType.buildingHardware.energy

  - add analytics to GroupOptionType
  - create GroupOptionType_labels

  - bugfix in GroupOptionType_labels

  - add GroupOptionType_labels to __init__

  - bugfix in GroupOptionType.agent.building

  - bugfix automatic destory of connection on BasicBrokerThreadingConnection on class destroy

  - add heating_sub_system to signal and group

  - add some internal functions to pikaButler for mor stability
  - better loghandling in pikaBulter with the gobale Vars':
  -- logInfoMessages = False
  -- logInfoConnection = True

  - add flow and return values to signal

  - add storage temperature

  - add freeze protection temperature

  - add durable Option to create Consumer

  - disable BasicPikaConnection -> Veraltet
  - add checkConnectionConsumer to BasicBrokerThreadingConnection
  - Überarbeitung stop() der Consumer


  - fixing some bugs

  - fixing some bugs

rpm_license:
  MIT License  Copyright (c) 2023 Oliver Birkholz  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: e4810e596b879ccba927150b4213bd4886258ee8dbb71e899b439c2eb9a6582e
name: python-butler-connect
arch: src
version: 0.10.5
epoch: 0
release: 1
summary: Access libraries (with pika) and data definitions for the Buttler project.
url: https://pypi.org/project/butler-connect/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-butler-connect-0.10.5-1.src.rpm
checksum_type: sha256
description:
  Access libraries and data definitions for the Buttler project.
  For more information ask Oliver Birkholz.



  - Adding vhost Support

  - Adding sending automatic heartbeats in publisher-function

  - update sending automatic heartbeats
  - handling error

  - adding group-types

  - adding signalOptionType and groupOptionType with forwardingMQTT

  - Solving problems on publishing data without connecting dest

  - Solving Problems with createConsumer with same topic an different routing_keys


  - add new signal  types f.ex. system_state or set_temperature.heater


  - change signal Description and add ext. !!! No backwards compatibility! if Using Schmema for parsing


  - Bugifx in Signal().__init__(.. ext was missing)

  - create SignalDirection()
  - add convertFrom to SignalOptionType
  - add different consumptionSignals to SignalType

  - add buildingHardware to signalOptionType and groupOptionType
  - add agent_building to groupOptionType

  - add SignalType co2
  - add SignalType consumption*Current

  - add SignalOptionType SignalOptionType.buildingHardware.energy

  - add analytics to GroupOptionType
  - create GroupOptionType_labels

  - bugfix in GroupOptionType_labels

  - add GroupOptionType_labels to __init__

  - bugfix in GroupOptionType.agent.building

  - bugfix automatic destory of connection on BasicBrokerThreadingConnection on class destroy

  - add heating_sub_system to signal and group

  - add some internal functions to pikaButler for mor stability
  - better loghandling in pikaBulter with the gobale Vars':
  -- logInfoMessages = False
  -- logInfoConnection = True

  - add flow and return values to signal

  - add storage temperature

  - add freeze protection temperature

  - add durable Option to create Consumer

  - disable BasicPikaConnection -> Veraltet
  - add checkConnectionConsumer to BasicBrokerThreadingConnection
  - Überarbeitung stop() der Consumer


  - fixing some bugs

  - fixing some bugs

  - add heatcurve eco

rpm_license:
  MIT License  Copyright (c) 2023 Oliver Birkholz  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: b910d2ac1cce9a44166f6674e6f72da2659a9a7d70a4064615c7f42101811441
name: python-buttercms-django
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: Company blogs as a service. Built for developers.
url: https://buttercms.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buttercms-django-0.3.7-1.src.rpm
checksum_type: sha256
description:
  https://www.buttercms.com
  **Why Butter?**
  Butter makes setting up a company blog on Django insanely easy. It's built for Django developers to save us from hosting, DB setup, themeing, maintaining yet another Wordpress install. It's designed to be quickly integrated to an existing Django project.
  Butter provides a marketing friendly blogging UI, hosted on buttercms.com, and exposes blog content created via an API.
  This package provides thin wrapper that interacts with the Butter API and a quick start blog application.


pkgId: 45a90952c260c632cd753946d386197024a333f5c3765a1d749e26ab83221fcd
name: python-buttercms-python
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: API First Blogging and CMS platform built for developers
url: https://github.com/buttercms/buttercms-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buttercms-python-2.1.1-1.src.rpm
checksum_type: sha256
description:
  Python Library for ButterCMS API.



  For a comprehensive list of examples, check out the [API documentation](https://buttercms.com/docs/api/).



  * [Pages](#pages)
  * [Collections](#collections)
  * [Posts](#posts)
  * [Authors](#authors)
  * [Categories](#categories)
  * [Feeds](#feeds)



  Install from PyPi using [pip](http://www.pip-installer.org/en/latest/), a
  package manager for Python.

      pip install buttercms-python




  Getting started with the ButterCMS API couldn't be easier. Use your authorization token to create a ButterCMS client.

  ```python
  from butter_cms import ButterCMS

  auth_token = "XXXXXXXXXXXXXXXXXXX"
  client = ButterCMS(auth_token)
  ```

  All methods return dictionaries. The data can be navigated using keys and indexes like the example below.

  ```python
  response = client.posts.all()

  posts = response['data']


  my_post = posts[0]


  print(my_post)






  ```



  The Page's `.all()`, `.get()` and `.search()` methods accept an optional `params` to add additional data to the response.

  ```python
  client.pages.all('news')


  client.pages.all('news', {'foo': 'bar'})
  ```


  ```python
  client.pages.get('news', 'hello-world')


  client.pages.get('news', 'hello-world', {'foo': 'bar'})
  ```

  ```python
  client.pages.search('enter search query', {'page': 1, 'page_size': 10})
  ```

  [To Top](#buttercms-python)




  For a list of params see the [API documentation](https://buttercms.com/docs/api/?python#collections)

  .get() method accepts an optional `params` dict to add additional data to the response.

  ```python
  client.content_fields.get(['collection_key'], {'locale': 'en'})
  ```

  [To Top](#buttercms-python)






  ```python
  client.posts.all({'page_size': 3, 'page': 1, 'exclude_body': 'true'})
  ```


  ```python
  client.posts.get('hello-world')
  ```


  ```python
  client.posts.search('query', {'page': 1, 'page_size': 10})
  ```



  The Author's `.all()` and `.get()` methods accept an optional `params` to add additional data to the response.

  * `{'include':'recent_posts'}`: Adds each author's posts under the `recent_posts` key in that author's returned dictionary

  ```python
  client.authors.all()
  client.authors.all({'include':'recent_posts'})
  ```


  ```python
  client.authors.get('jennifer-smith')
  client.authors.get('jennifer-smith', {'include':'recent_posts'})
  ```


  [To Top](#buttercms-python)



  The Category's `.all()` and `.get()` methods accept an optional `params` to add additional data to the response.

  * `{'include':'recent_posts'}`: Adds posts tagged with that category under the `recent_posts` key in that category's returned dictionary

  ```python
  client.categories.all()
  client.categories.all({'include':'recent_posts'})
  ```


  ```python
  client.categories.get('product-updates')
  client.categories.get('product-updates', {'include':'recent_posts'})
  ```


  [To Top](#buttercms-python)




  The Tag's `.all()` and `.get()` methods accept an optional `params` to add additional data to the response.

  * `{'include':'recent_posts'}`: Adds posts tagged with that tag under the `recent_posts` key in that tag's returned dictionary

  ```python
  client.tags.all()
  client.tags.all({'include':'recent_posts'})
  ```


  ```python
  client.tags.get('product-updates')
  client.tags.get('product-updates', {'include':'recent_posts'})
  ```


  [To Top](#buttercms-python)



  ```python
  client.feeds.get('rss')
  ```


  ```python
  client.feeds.get('atom')
  ```


  ```python
  client.feeds.get('sitemap')
  ```


  [To Top](#buttercms-python)





  View Python [Blog engine](https://buttercms.com/python-blog-engine/) and [Full CMS](https://buttercms.com/python-cms/) for other examples of using ButterCMS with Python.



  To run tests:

  ```python
  python -m unittest butter_cms/unit_tests.py
  ```


pkgId: 10fbf66c152de9d9f424f7116f067d86a312fa33a951b589a248ae6f9678450f
name: python-buttersink
arch: src
version: 0.6.9
epoch: 0
release: 1
summary: Buttersink is like rsync for btrfs snapshots
url: https://github.com/AmesCornish/buttersink/wiki
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buttersink-0.6.9-1.src.rpm
checksum_type: sha256
description:
  ButterSink synchronizes two sets of btrfs read-only subvolumes
  (snapshots).
  ButterSink is like rsync, but for btrfs subvolumes instead of files,
  which makes it much more efficient for things like archiving backup
  snapshots. It is built on top of btrfs send and receive capabilities.
  Sources and destinations can be local btrfs file systems, remote btrfs
  file systems over SSH, or S3 buckets.
  To use the ssh back-end, ButterSink must be installed on the remote
  system.
  ButterSink *only* handles read-only subvolumes. It ignores read-write
  subvolumes and any files not in a subvolume.


pkgId: a44eaa640878b766464342fba93d90c5a306d80a625a5b04ac3e9c5c11fac335
name: python-buvar-aiohttp
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: aiohttp plugin for buvar
url: https://gitlab.com/diefans/buvar
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buvar-aiohttp-0.4.5-1.src.rpm
checksum_type: sha256
description:
  Solves some boilerplate around starting an `aiohttp`_ server.
      import aiohttp.web
      from buvar import context, di, fork, plugin
      from buvar_aiohttp import AioHttpConfig
      async def hello(request):
          return aiohttp.web.Response(body=b"Hello, world")
      async def prepare_aiohttp(load: plugin.Loader):
          
          context.add(AioHttpConfig(host="0.0.0.0", port=5678))
          
          await load("buvar_aiohttp")
          
          app = await di.nject(aiohttp.web.Application)
          app.router.add_route("GET", "/", hello)
      
      
      fork.stage(prepare_aiohttp, forks=0, sockets=["tcp://:5678"])


pkgId: ccee437b900c03d2546be0ddd8b67dd93c511ea559d6f1403e06019db95517f2
name: python-buzzword
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Web-app for corpus linguistics
url: https://pypi.org/project/buzzword/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-buzzword-1.4.0-1.src.rpm
checksum_type: sha256
description:
  > Version 1.4.0

  [![Build Status](https://travis-ci.org/interrogator/buzzword.svg?branch=master)](https://travis-ci.org/interrogator/buzzword)
  [![readthedocs](https://readthedocs.org/projects/buzzword/badge/?version=latest)](https://buzzword.readthedocs.io/en/latest/)
  [![codecov.io](https://codecov.io/gh/interrogator/buzzword/branch/master/graph/badge.svg)](https://codecov.io/gh/interrogator/buzzword)
  [![PyPI version](https://badge.fury.io/py/buzzword.svg)](https://badge.fury.io/py/buzzword)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)

  > Web-app for corpus linguistics; documentation available [via ReadTheDocs](https://buzzword.readthedocs.io/en/latest/)

  > Note, this app is currently being overhauled and turned into a Django project. The last stable (Dash) app was version `1.2.5`. Versions after this will be in Django, and for now, a bit unstable, as features like user management are added in. Documentation for now targets 1.2.5, not the new Django app.



  ```bash
  pip install buzzword
  ```



  The `buzzword.create` command will create a directory and populate it with the necessary config files and a sample corpus. Here, we name it `workspace` and run buzzword from within it.

  ```bash
  buzzword-create workspace

  cd workspace
  python -m buzzword
  ```



  To set things up more more permanently, either modify the directory created with `buzzword-create`, or do the following:

  0. [Create and parse corpus](https://buzzword.readthedocs.io/en/latest/building/)
  1. [Configure a `.env` file](https://buzzword.readthedocs.io/en/latest/run/) from `.env.example`
  2. [Configure a `corpora.json`](https://buzzword.readthedocs.io/en/latest/run/) file from `corpora.json.example`
  3. Run the tool with or without [command line arguments](https://buzzword.readthedocs.io/en/latest/run/):

  ```bash
  buzzword --debug

  ```



  ```bash
  docker build . -t name/tag
  docker run -it -p 8001:8000 name/tag
  ```
  buzzword is now available at http://localhost:8001


pkgId: 0f2c8f66c0d4c05f42c1bbfe78c144a9d17abeb416e7f1b8d2566f33ce5fd3d2
name: python-bvlain
arch: src
version: 0.24.5
epoch: 0
release: 1
summary: The Bond valence site energy calculator
url: https://github.com/dembart/BVlain
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bvlain-0.24.5-1.src.rpm
checksum_type: sha256
description:
  ![BVlain_logo](https://raw.githubusercontent.com/dembart/BVlain/master/BVlain_logo.png)

  BVlain is the module for bond valence site energy calculations and is about to solve tasks related to ionic conductivity of a tracer ion in a crystal structure.

  For more details, see [documentation.](https://bvlain.readthedocs.io/en/latest/index.html)





  ```python
  !pip install bvlain
  ```






  ```python
  from bvlain import Lain

  file = '/Users/artemdembitskiy/Downloads/LiFePO4.cif'
  calc = Lain(verbose = False)
  st = calc.read_file(file)

  params = {'mobile_ion': 'Li1+',    # mobile specie
  		  'r_cut': 10.0,           # cutoff for interaction between the mobile species and framework
  		  'resolution': 0.2,	   # distance between the grid points
  		  'k': 100                 # maximum number of neighbors to be collected for each point
  }
  _ = calc.bvse_distribution(**params)
  energies = calc.percolation_barriers(encut = 5.0)
  for key in energies.keys():
      print(f'{key[-2:]} percolation barrier is {round(energies[key], 4)} eV')
  ```

      1D percolation barrier is 0.4395 eV
      2D percolation barrier is 3.3301 eV
      3D percolation barrier is 3.3594 eV





  ```python
  from bvlain import Lain

  file = '/Users/artemdembitskiy/Downloads/LiFePO4.cif'
  calc = Lain(verbose = False)
  st = calc.read_file(file)

  params = {'mobile_ion': 'Li1+',    # mobile specie
  		  'r_cut': 10.0,           # cutoff for interaction between the mobile species and framework
  		  'resolution': 0.2,	   # distance between the grid points
  }
  _ = calc.void_distribution(**params)
  radii = calc.percolation_radii()
  for key in radii.keys():
      print(f'{key[-2:]} percolation barrier is {round(radii[key], 4)} angstrom')
  ```

      1D percolation barrier is 0.3943 angstrom
      2D percolation barrier is 0.2957 angstrom
      3D percolation barrier is 0.1972 angstrom





  ```python
  from bvlain import Lain

  file = '/Users/artemdembitskiy/Downloads/LiFePO4.cif'
  calc = Lain(verbose = False)
  st = calc.read_file(file)

  params = {'mobile_ion': 'Li1+',    # mobile specie
  		  'r_cut': 10.0,           # cutoff for interaction between the mobile species and framework
  		  'resolution': 0.2,	   # distance between the grid points
  		  'k': 100                 # maximum number of neighbors to be collected for each point
  }
  _ = calc.bvse_distribution(**params)
  _ = calc.void_distribution(**params)

  calc.write_grd(file + '_bvse', task = 'bvse')  # saves .grd file
  calc.write_cube(file + '_void', task = 'void') # save .cube file
  ```




  ```python
  from bvlain import Lain

  file = '/Users/artemdembitskiy/Downloads/LiFePO4.cif'
  calc = Lain(verbose = False)
  st = calc.read_file(file)
  dataframe = calc.mismatch(r_cut = 3.5)
  ```


  For more examples, see [documentation.](https://bvlain.readthedocs.io/en/latest/index.html)

  The library is under active development and it is not guaranteed that there are no bugs. If you observe not expected results, errors, please report an issue at github.


pkgId: 5886493c25e1bb5d6b48eeadae77d80642597006088a1bf1a94fe11e5bb20036
name: python-bvlogger
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: A brief description of your project
url: https://github.com/obaidshk/bvlogger
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bvlogger-1.0.10-1.src.rpm
checksum_type: sha256
description:
  **BVLogger** is a Python library for logging and tracking API interactions. It provides functionality to log various aspects of your API interactions, including connector details and endpoint data.



  - **Authentication**: Obtain JWT tokens for secure API access.
  - **Connector Logging**: Track details related to API connectors.
  - **Endpoint Logging**: Log interactions with specific API endpoints.



  To install BVLogger, use pip:

  ```bash
  pip install bvlogger


pkgId: f673021677cdb9ecbf80c234b15677c1d8767a1290c0c330d338156c4dfbbd94
name: python-bw-graph-tools
arch: src
version: 0.5
epoch: 0
release: 1
summary: Graph traversal class and utilities
url: https://pypi.org/project/bw-graph-tools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw-graph-tools-0.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/bw_graph_tools.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/bw_graph_tools.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/bw_graph_tools)][pypi status]
  [![License](https://img.shields.io/pypi/l/bw_graph_tools)][license]

  [![Read the documentation at https://bw_graph_tools.readthedocs.io/](https://img.shields.io/readthedocs/bw_graph_tools/latest.svg?label=Read%20the%20Docs)][read the docs]
  [![Tests](https://github.com/brightway-lca/bw_graph_tools/workflows/Tests/badge.svg)][tests]
  [![Codecov](https://codecov.io/gh/brightway-lca/bw_graph_tools/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 status]: https://pypi.org/project/bw_graph_tools/
  [read the docs]: https://bw_graph_tools.readthedocs.io/
  [tests]: https://github.com/brightway-lca/bw_graph_tools/actions?workflow=Tests
  [codecov]: https://app.codecov.io/gh/brightway-lca/bw_graph_tools
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black



  You can install _bw_graph_tools_ via [pip] from [PyPI]:

  ```console
  $ pip install bw_graph_tools
  ```

  Packages are also on conda at the [channel cmutel](https://anaconda.org/cmutel/bw_graph_tools).



  `bw_graph_tools` has three main components: A graph traversal class `NewNodeEachVisitGraphTraversal`; a function to guess production exchanges using only `bw_processing` datapackages `guess_production_exchanges`; and a function to find the path from node `A` to node `B` with the largest amount of the reference product of `A`, `get_path_from_matrix` and it's sister `path_as_brightway_objects`.



  Normally we construct matrices and solve the resulting set of linear equations to get a life cycle inventory or impact assessment result. The matrix approach is elegant, in that it simultaneously solves all equations and handles cycles in the graph, and much faster than graph traversal. However, in some cases we want to actually traverse the supply chain graph and calculate the individual impact of visiting nodes at that point in the graph. Graph traversal's use cases include:

  * Distinguishing between different paths to the same object

  * Convolving temporal distributions

  If we add temporal information using `bw_temporalis`, then the same node can occur at different times depending on how the temporal dynamics its preceding path. For example:




  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [BSD 3 Clause license][license],
  _bw_graph_tools_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  1. Install the conda environment from the file `.docs/environment.yml`
  2. Build the documentation locally by running:

  ```bash
  sphinx-autobuild docs _build/html -a -j auto --open-browser
  ```


pkgId: 1f8b03a243514be7fec8b6178f178914fafd043656304bb3d57e5dfc5db9091b
name: python-bw-interface-schemas
arch: src
version: 0.2
epoch: 0
release: 1
summary: Interface schemas for data transfer in Brightway
url: https://pypi.org/project/bw-interface-schemas/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw-interface-schemas-0.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/bw_interface_schemas.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/bw_interface_schemas.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/bw_interface_schemas)][pypi status]
  [![License](https://img.shields.io/pypi/l/bw_interface_schemas)][license]



  `bw_interface_schemas` defines a set of [pydantic](https://docs.pydantic.dev/2.0/) classes which will be the fundamental data schema for Brightway Cloud, the next iteration of the Brightway LCA software ecosystem. These schemas provide clear and consistent graph-based interfaces between Brightway software libraries, and simplify and harmonize the way data was modeled and stored in Brightway.

  We have chosen to model all data in a graph, as a list of nodes and edges. This includes inventory data, which models how processes consume and produce products to form supply chains. It also includes impact assessment, where elementary flows are linked to impact categories via characterization edges, and data organization. Now both projects and databases are also in the graph, and process and product nodes are linked to databases via `belongs_to` relationship edges.



  Here is our standard bicycle production example in the new paradigm:

  <img src="example.png">

  You can see two ways of building this graph in code in `tests/conftest.py`.



  These new interfaces break backwards compatibility. We do not take such steps lightly; these changes were necessary to include database, projects, and methods in the same data store as other nodes and edges, and to add sanity checks and simpler code paths to building correct supply chain models.

  Our approach has the following advantages:

  * Edge `source` and `target` attributes now correctly indicate direction. Previously production edges had the product being produced as an input. Similarly, elementary flows being emitted were still modeled as inputs.
  * Removal of implicit production edges. These seemed like a convenience but ultimately led to many hacks and difficult to diagnose incorrect behaviour for users.
  * Removal of edge `type` labels which were at best confusing and sometimes incorrect. Edges now have a small set of possible types which only indicates the matrix they can be used in, and explicit instead of implicit direction.
  * Clear separation of processes and products. Processes can only consume and produce products, and vice-versa. The previous allowance of chimaera processes which acted as products made modelling of multifunctional processes difficult and error-prone.
  * The single graph format with LCI and LCIA nodes can sensibly model impact assessment data. Previously impact assessment data had to pretend to be inventory databases in `bw2io`.
  * A unified data format which is identical in Python and JSON. This makes serialization, database storage, and exchange across systems and languages much easier.
  * Pydantic validation provides usable feedback and prevents data errors entering the database.



  You can install _bw_interface_schemas_ via [pip] from [PyPI]:

  ```console
  $ pip install bw_interface_schemas
  ```



  Contributions are very welcome.
  To learn more, see the [Contributor Guide][Contributor Guide].



  Distributed under the terms of the [MIT license][License],
  _bw_interface_schemas_ is free and open source software.



  If you encounter any problems,
  please [file an issue][Issue Tracker] along with a detailed description.


  <!-- github-only -->

  [command-line reference]: https://bw_interface_schemas.readthedocs.io/en/latest/usage.html
  [License]: https://github.com/brightway-lca/bw_interface_schemas/blob/main/LICENSE
  [Contributor Guide]: https://github.com/brightway-lca/bw_interface_schemas/blob/main/CONTRIBUTING.md
  [Issue Tracker]: https://github.com/brightway-lca/bw_interface_schemas/issues


pkgId: 77014806a99d569ea443c78e6884c6372c0f2c5049528df9d63176b3d9d33f40
name: python-bw-matchbox
arch: src
version: 2.6
epoch: 0
release: 1
summary: Browser to match Brightway databases
url: https://github.com/cauldron/bw_matchbox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw-matchbox-2.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/bw_matchbox.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/bw_matchbox.svg)][pypi status]
  <!-- [![Python Version](https://img.shields.io/pypi/pyversions/bw_matchbox)][pypi status] -->
  [![License](https://img.shields.io/pypi/l/bw_matchbox)][license]

  <!-- [![Read the documentation at https://bw_matchbox.readthedocs.io/](https://img.shields.io/readthedocs/bw_matchbox/latest.svg?label=Read%20the%20Docs)][read the docs] -->
  <!-- [![Tests](https://github.com/cauldron/bw_matchbox/workflows/Tests/badge.svg)][tests] -->
  <!-- [![Codecov](https://codecov.io/gh/cauldron/bw_matchbox/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 status]: https://pypi.org/project/bw_matchbox/
  [read the docs]: https://bw_matchbox.readthedocs.io/
  [tests]: https://github.com/cauldron/bw_matchbox/actions?workflow=Tests
  [codecov]: https://app.codecov.io/gh/cauldron/bw_matchbox
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black

  `bw_matchbox` is a web app for matching two [Brightway](https://docs.brightway.dev/en/latest/). It allows you to do complicated matches, such as:

  * Link process a to processes b and c, with allocation factors
  * Link process a to a proxy for process b, changing the exchange values in b proxy to match those in process a where desired
  * Link process a to a proxy for process b, removing some exchanges from b and adding some from a
  * Link process a to a proxy for process b, expanding and inlining some exchanges from b to "flatten" its supply chain



  You can install _bw_matchbox_ via [pip] from [PyPI]:

  ```console
  pip install bw_matchbox
  ```

  It's possible to install the library itself for development purposes (in the cloned project):

  ```console
  pip install -e .
  ```

  This library depends on:

  * Brightway 2.5 (`brightway25`)
  * `docopt-ng`
  * `flask` and `flask_httpauth`
  * `tomli`
  * `werkzeug`



  This is a `flask` application. Flask has a debug server suitable for development, but it [should not be used for production](https://flask.palletsprojects.com/en/2.3.x/deploying/)!

  To use `bw_matchbox`, you need to do the following:



  Configuration is done via a `toml` file. See [`config_example.toml`](https://github.com/cauldron/bw_matchbox/blob/main/config_example.toml) for the structure of this file. Here is an example:

  ```toml
  [users]
  jane = "deer"
  john = "doe"

  [roles]
  editors = ["jane"]
  reviewers = ["john"]

  [configs]
  my_config = { project = "something", source = "database A", target = "database B", proxy = "database C"}

  [files]
  output_dir = "/Path/to/some/directory"
  ```

  The `config.toml` file needs to provide the following:

  * `[users]` section: Authentication, via a set of usernames and passwords
  * `[roles]` section: The exact role labels must be used. Editors can make changes, reviewers can only comment.
  * `[configs]` section: A combination of Brightway project and the source, target and proxy databases.
  * `[files]` section: Currently only uses the `output_dir` key.

  The easiest way to set this up is with:

  ```console
  matchbox setup
  ```

  This will create stub configuration and changes files in your current working directory - note that you should change the configuration and username/password in `config.toml`.



  Just run:

  ```console
  matchbox webapp config.toml
  ```



  You will need to configure the Flask app using `configure_app`, or re-implement its functionality. Here is an example using [waitress](https://docs.pylonsproject.org/projects/waitress/en/stable/index.html):

  ```python
  from bw_matchbox import matchbox_app, configure_app
  config_filepath = "/path/to/config.toml"
  app = configure_app(config_filepath, matchbox_app)

  from waitress import serve
  serve(app, port=8080)
  ```



  Once the app is running and configured locally or remotely, connect to the correct address and port. If you are running locally, this is probably either `http://localhost:5000` or `http://127.0.0.1:5000`.

  In the first screen, choose the Brightway project you want to work on. This is `matchbox-example` if you ran `matchbox example_project`.

  On the next screen, choose one database as the *source*, and **a different database** as the *target*. Currently you need to specify a new proxy database by typing a new database name into the *Create a new database* input box.



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _bw_matchbox_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.


  <!-- github-only -->

  [command-line reference]: https://bw_matchbox.readthedocs.io/en/latest/usage.html
  [license]: https://github.com/cauldron/bw_matchbox/blob/main/LICENSE
  [contributor guide]: https://github.com/cauldron/bw_matchbox/blob/main/CONTRIBUTING.md


pkgId: 3bc6db98dcea9d62ea5cfca52e8e5ed5ba558545dd9e966186c86c95ca3b0960
name: python-bw-save-game
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Editor for Dragon Age: The Veilguard saves.
url: https://github.com/timniederhausen/bw_save_game
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw-save-game-0.0.1-1.src.rpm
checksum_type: sha256
description:
      Edit save games for Dragon Age: The Veilguard

  This pure-Python library and its console applications (`csav2json`, `json2csav`) can read and write Dragon Age: The Veilguard save files (`*.csav`).
  Support for previous Dragon Age games might follow.



  Make sure you have these programs installed:

  * Python 3.8 or newer

  This package is available for download from [PyPI][1]. You can install this
  package using `pip`:
  ```bash
  pip install --upgrade bw_save_game
  ```



  For non-programmers this project ships two applications that can convert a save game into a readable JSON document and vice-versa.
  Editing this document allows you to change every part of a save, however, ensuring correctness and consistency is up to you.





  This project uses [pre-commit][4], please make sure to install it before making any
  changes::

      pip install pre-commit
      cd bw_save_game
      pre-commit install

  It is a good idea to update the hooks to the latest version::

      pre-commit autoupdate

  Don't forget to tell your contributors to also install and use pre-commit.



  [![GNU GPLv3 Image](https://www.gnu.org/graphics/gplv3-127x51.png)][2]

  `bw_save_game` is Free Software: You can use, study, share and improve it at your
  will. Specifically you can redistribute and/or modify it under the terms of the
  [GNU General Public License][3] as published by the Free Software Foundation,
  either version 3 of the License, or (at your option) any later version.

  [1]: https://pypi.org/project/bw_save_game/
  [2]: http://www.gnu.org/licenses/gpl-3.0.en.html
  [3]: https://www.gnu.org/licenses/gpl.html
  [4]: https://pre-commit.com/


pkgId: be7c8ef46973e286f9578bd3e5b337decdf675ce4be7a322b9039c12f7ef5e06
name: python-bw-simapro-csv
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Utility library to read and parse SimaPro CSV LCI and LCIA files
url: https://pypi.org/project/bw-simapro-csv/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw-simapro-csv-0.2.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/bw_simapro_csv.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/bw_simapro_csv.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/bw_simapro_csv)][pypi status]
  [![License](https://img.shields.io/pypi/l/bw_simapro_csv)][license]

  [![Read the documentation at https://bw_simapro_csv.readthedocs.io/](https://img.shields.io/readthedocs/bw_simapro_csv/latest.svg?label=Read%20the%20Docs)][read the docs]
  [![Tests](https://github.com/brightway-lca/bw_simapro_csv/actions/workflows/python-test.yml/badge.svg)][tests]
  [![Codecov](https://codecov.io/gh/brightway-lca/bw_simapro_csv/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 status]: https://pypi.org/project/bw_simapro_csv/
  [read the docs]: https://bw_simapro_csv.readthedocs.io/
  [tests]: https://github.com/brightway-lca/bw_simapro_csv/actions?workflow=Tests
  [codecov]: https://app.codecov.io/gh/brightway-lca/bw_simapro_csv
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black



  You can install _bw_simapro_csv_ via from [PyPI](https://pypi.org/project/bw-simapro-csv/):

  ```console
  $ pip install bw_simapro_csv
  ```

  Or using conda/mamba from the channel `cmutel`:

  ```console
  $ mamba install -c conda-forge -c cmutel bw_simapro_csv
  ```

  To install with the compatible Brightway libraries via `pip`:

  ```console
  $ pip install "bw_simapro_csv[brightway]""
  ```

  Or via conda/mamba:

  ```console
  $ mamba install -c conda-forge -c cmutel bw_simapro_csv brightway25
  ```

  On MacOS with ARM chips, run instead:

  ```console
  $ mamba install -c conda-forge -c cmutel bw_simapro_csv brightway25_nosolver
  ```

  See the Brightway docs for more on [ARM CPUs and sparse solvers](https://docs.brightway.dev/en/latest/content/installation/index.html#installing-brightway-using-pip).



  `bw_simapro_csv` extracts a single SimaPro separated value export file to a series of blocks. Files can be CSV, TSV, or some other separator.  Basic usage:

  ```python
  from pathlib import Path
  from bw_simapro_csv import SimaProCSV
  sp = SimaProCSV(Path("my SimaPro file.csv"))
  ```

  The file object must be an instance of `pathlib.Path` or `io.StringIO`. The `SimaProCSV` will do the following:

  * Determine the file type. There are three kinds of SimaPro export files: "processes", "methods", and "product stages". This library **does not** yet work with product stages.
  * Read the header, and build `SimaProCSV.header`. The header is a dictionary of metadata. We do our best to convert the values to their python equivalents, such as datetimes or booleans.
  * Using the metadata, read the rest of the file, and convert it into a series of blocks. Each block has its own data schema, though they are mostly similar.
  * While reading the file, some common data mistakes are cleaned up. For example, impossible uncertainty distributions are switch to `UnkownUncertainty`. We also do our best to create valid and reasonable unicode text.
  * Many numeric values can be defined by formulae. In order to parse these formulae in python, we need to substitute some operators for their python equivalents (e.g. `**` instead of `^`). As python is case-sensitive, we switch all variable names to upper case, and add the prefix `SP_`, so `my_variable` would become `SP_MY_VARIABLE`. We then evaluate all formulas (including for allocation), and store their numeric results in the `amount` field.

  The end result is `SimaProCSV.blocks`, a list of `SimaProCSVBlock` instances with parsed and cleaned data.



  Despite the presence of a `Products` block in processes, SimaPro doesn't really differentiate between between the two. Therefore, all process datasets should be considered as [`ProcessWithReferenceProduct`](https://github.com/brightway-lca/bw_interface_schemas/blob/5fb1d40587aec2a4bb2248505550fc883a91c355/bw_interface_schemas/lci.py#L83). Consider this quote from the tutorial:

      Process name in SimaPro
      Under the Documentation tab, you can enter the process name. Please note that this is only for
      your own reference and this name is not used anywhere. Processes are identified by the name
      defined under the Input/Output tab in the product section. Therefore, if you want to search for a
      certain process, you should use the product name defined in the Input/Output as the keyword.



  The intersection of ecoinvent waste models (negative values means things labelled as inputs are outputs, and vice-versa) and SimaPro `Waste treatment` versus `Waste to treatment` make life interesting. The SimaPro model is:

  * `Waste treatment` are *inputs*, and indicate that the given process is a waste treatment process, i.e. it does not have a `Products` block, and has the `category_type` `waste treatment`.
  * `Waste to treatment` are *outputs*, and indicate that waste is being produced which needs to be treated. Negative amounts in `Waste to treatment` indicate that these wastes are *inputs*, and that this process is a waste treatment process.

  We label edges in both `Products` and `Waste treatment` as functional when exporting to Brightway.



  `bw_simapro_csv` uses the [loguru](https://github.com/Delgan/loguru) library for controlling logs. By default, logs are printed to `stderr`, and two log files are created: `warning.log` for important errors or information messages, and `debug.log`, for a detailed log of operations and resolved data issues.

  Log are created in a directory path drawn from the [platformdirs](https://platformdirs.readthedocs.io/en/latest/) library; you can copy them to a more convenient place with `SimaProCSV.copy_log_dir(some_dir)`, where `some_dir` is a `pathlib.Path` directory instance.



  Process datasets can be exported to a format usable by `bw2io` with `SimaProCSV.to_brightway()`. This returns a Python dictionary, but you can also write this data to a file on disk by passing a `pathlib.Path` instance, i.e.:

  ```python
  from pathlib import Path
  from bw_simapro_csv import SimaProCSV
  sp = SimaProCSV(Path("my SimaPro file.csv"))
  sp.to_brightway(Path("my-export.json"))
  ```





  Contributions are very welcome.
  To learn more, see the [Contributor Guide][Contributor Guide].



  Distributed under the terms of the [MIT license][License],
  _bw_simapro_csv_ is free and open source software.



  If you encounter any problems,
  please [file an issue][Issue Tracker] along with a detailed description.


  <!-- github-only -->

  [command-line reference]: https://bw_simapro_csv.readthedocs.io/en/latest/usage.html
  [License]: https://github.com/brightway-lca/bw_simapro_csv/blob/main/LICENSE
  [Contributor Guide]: https://github.com/brightway-lca/bw_simapro_csv/blob/main/CONTRIBUTING.md
  [Issue Tracker]: https://github.com/brightway-lca/bw_simapro_csv/issues


pkgId: b409df23127715ad01405ade3eaa17e1b79fb63f24951e763b3d8a1e8dfd4245
name: python-bw-temporalis
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Revision of bw2temporalis for modern Brightway
url: https://github.com/brightway-lca/bw_temporalis
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw-temporalis-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/bw_temporalis.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/bw_temporalis.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/bw_temporalis)][pypi status]
  [![License](https://img.shields.io/pypi/l/bw_temporalis)][license]

  [![Read the documentation at https://bw_temporalis.readthedocs.io/](https://img.shields.io/readthedocs/bw_temporalis/latest.svg?label=Read%20the%20Docs)][read the docs]
  [![Tests](https://github.com/brightway-lca/bw_temporalis/actions/workflows/python-test.yml/badge.svg)][tests]
  [![Codecov](https://codecov.io/gh/brightway-lca/bw_temporalis/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 status]: https://pypi.org/project/bw_temporalis/
  [read the docs]: https://bw_temporalis.readthedocs.io/
  [tests]: https://github.com/brightway-lca/bw_temporalis/actions/workflows/python-test.yml
  [codecov]: https://app.codecov.io/gh/brightway-lca/bw_temporalis
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black



  You can install _bw_temporalis_ via [pip] from [PyPI]:

  ```console
  $ pip install bw_temporalis
  ```

  Currently Python 3.11 installations are broken as [scikit-network](https://scikit-network.readthedocs.io/en/latest/?badge=latest) only has pre-built wheels for version 0.31 - but this changed the [API for shortest path](https://github.com/sknetwork-team/scikit-network/blob/master/HISTORY.rst#0310-2023-05-22), and `bw_graph_tools` has not yet been adapted](https://github.com/brightway-lca/bw_graph_tools/issues/13).

  You can also install using conda in the [cmutel channel](https://anaconda.org/cmutel/bw_temporalis).



  See [the teaching repo `from-the-ground-up`](https://github.com/brightway-lca/from-the-ground-up/tree/main/temporal) for examples on how to use this library.

  This library uses the *net amount* in the technosphere and biosphere matrix, so caution should be taken in cases where multiple edges with temporal dynamics, especially with different numerical signs, link the same nodes. In general, these edges should be split across multiple processes.

  The temporal resolution should not be less than seconds, it will be rounded up to seconds in the `TemporalDistribution`.



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [BSD 3 Clause license][license],
  _bw_temporalis_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.


  <!-- github-only -->

  [command-line reference]: https://bw_temporalis.readthedocs.io/en/latest/usage.html
  [license]: https://github.com/brightway-lca/bw_temporalis/blob/main/LICENSE
  [contributor guide]: https://github.com/brightway-lca/bw_temporalis/blob/main/CONTRIBUTING.md


pkgId: fa90255dcf6ce79f554d52aecf68a5962738b9f541183e8d16649c4073a96c6a
name: python-bw-timex
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Time-explicit Life Cycle Assessment
url: https://pypi.org/project/bw-timex/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw-timex-0.2.6-1.src.rpm
checksum_type: sha256
description:
  <h1>
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="docs/_static/bw_timex_dark_nomargins.svg" height="50">
      <img alt="bw_timex logo" src="docs/_static/bw_timex_light_nomargins.svg" height="50">
    </picture>
  </h1>

  [![Read the Docs](https://img.shields.io/readthedocs/timex?label=documentation)](https://docs.brightway.dev/projects/bw-timex/en/latest/)
  [![PyPI - Version](https://img.shields.io/pypi/v/bw-timex?color=%2300549f)](https://pypi.org/project/bw-timex/)
  [![Conda Version](https://img.shields.io/conda/v/diepers/bw_timex?label=conda)](https://anaconda.org/diepers/bw_timex)
  ![Conda - License](https://img.shields.io/conda/l/diepers/bw_timex)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/brightway-lca/bw_timex/HEAD?labpath=notebooks%2Fgetting_started.ipynb)

  This is a python package for [time-explicit Life Cycle Assessment](https://docs.brightway.dev/projects/bw-timex/en/latest/content/theory.html#terminology) that helps you assess the environmental impacts of products and processes over time. `bw_timex` builds on top of the [Brightway LCA framework](https://docs.brightway.dev/en/latest).


  This package enables you to account for:
  - **Timing of processes** throughout the supply chain (e.g., end-of-life treatment occurs 20 years after construction)
  - **Variable** and/or **evolving** supply chains & technologies (e.g., increasing shares of renewable electricity in the future)
  - **Timing of emissions** (by applying dynamic characterization functions)

  You can define temporal distributions for process and emission exchanges, which are then *automatically* propagated through the supply chain and mapped to corresponding time-explicit databases. The resulting time-explicit LCI reflects the current technology status within the production system at the actual time of each process. Also, `bw_timex` keeps track of the timing of emissions which means that you can apply [dynamic characterization functions](https://github.com/TimoDiepers/dynamic_characterization).


  `bw_timex` is ideal for cases with:
  - **Variable** or strongly **evolving production systems**
  - **Long-lived** products
  - **Biogenic** carbon


  - [Installation Guide](https://docs.brightway.dev/projects/bw-timex/en/latest/content/installation.html)
  - [Getting Started Tutorial](https://docs.brightway.dev/projects/bw-timex/en/latest/content/getting_started/index.html)
  - [Example Collection](https://docs.brightway.dev/projects/bw-timex/en/latest/content/examples/index.html)


  We welcome contributions! If you have suggestions or want to fix a bug, please:
  - [Open an Issue](https://github.com/brightway-lca/bw_timex/issues)
  - [Send a Pull Request](https://github.com/brightway-lca/bw_timex/pulls)


  If you have any questions or need help, do not hesitate to contact us:
  - Timo Diepers ([timo.diepers@ltt.rwth-aachen.de](mailto:timo.diepers@ltt.rwth-aachen.de))
  - Amelie Müller ([a.muller@cml.leidenuniv.nl](mailto:a.muller@cml.leidenuniv.nl))
  - Arthur Jakobs ([artos.jakobs@psi.ch](mailto:artos.jakobs@psi.ch))


pkgId: 5a3ab4a107cb1bc84e0c4805063f368e8f0c338b51f95cb5291daa9c2f0ffadb
name: python-bw25ui
arch: src
version: 0.43.0
epoch: 0
release: 1
summary: A web and command line user interface, part of the Brightway2 LCA framework https://brightway.dev.
url: https://pypi.org/project/bw25ui/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw25ui-0.43.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/bw25ui.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/bw25ui.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/bw25ui)][pypi status]
  [![License](https://img.shields.io/pypi/l/bw25ui)][license]

  [![Read the documentation at https://brightway2-ui.readthedocs.io/](https://img.shields.io/readthedocs/brightway2-ui/latest.svg?label=Read%20the%20Docs)][read the docs]
  [![Codecov](https://codecov.io/gh/brightway-lca/brightway2-ui/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 status]: https://pypi.org/project/bw25ui/
  [read the docs]: https://brightway2-ui.readthedocs.io/
  [codecov]: https://app.codecov.io/gh/brightway-lca/brightway2-ui
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black

  This is now the official repo for  Brightway2-UI:

  > a web and command line user interface, part of the **Brightway2 LCA framework** <https://brightway.dev>.

  The _original_ source code was hosted on Bitbucket: <https://bitbucket.org/tomas_navarrete/brightway2-ui>.



  This repository is used to produce 2 packages: one compatible with brightway25 (`bw25ui`), and one compatible with brightway2 (`bw2ui`).



  Both, `conda` / `mamba` and wheels from [pypi.org](https://pypi.org) are available.
  The package names are different for Brightway25 and Brightway2, but the main executable script is still the same.

  > [!NOTE]
  > The requirements here are abstract, but they are different for `brightway25` and `brightway2`.
  > For brightway25, bw2calc must be `>= 2.0.dev10` and bw2analyzer `>= 0.11`
  > for brightway2 bw2calc must be `< 2` and bw2analyzer `>=0.10`



  To install a `conda` / `mamba` package compatible with brightway25:

  ```commandline
  mamba install -c tomas_navarrete bw25ui
  ```

  There is also a pip wheel that you can install with:

  ```commandline
  pip install bw25ui
  ```



  To install a package compatible with brightway2:

  ```commandline
  mamba install -c tomas_navarrete bw2ui
  ```

  There is also a pip wheel that you can install with:

  ```commandline
  pip install bw2ui
  ```



  + As long as retro-compatibility is possible between Brightway25 and Brightway2, the code base will remain identical.
  + Packages will be published with the same version tags, but different names.
  + New features will be primarily implemented to work with Brightway25, and if they are compatible with Brightway2 they will be part of the same code base.
  + When the implementation of new features in a single code base for Brightway2 and Brightway25 becomes imposible, a new branch called `legacy` will be created to track the code compatible with Brightway2. The same will be done in the long term once Brightway3 is released.



  The current code base is identical for both packages (`bw25ui` and `bw2ui`).
  The current main branch will be kept as the branch for development, with identical code bases for both packages _until_ brightway25 public API breaks the compatibility.



  Once Brightway3 starts to exist, the main branch will be dedicated to it, with a `bw3ui` package.




  Contributions are very welcome.
  To learn more, see the [Contributor Guide][Contributor Guide].



  Distributed under the terms of the [BSD-3 license][License],
  _bw2ui_ is free and open source software.



  If you encounter any problems,
  please [file an issue][Issue Tracker] along with a detailed description.


  <!-- github-only -->

  [command-line reference]: https://brightway2-ui.readthedocs.io/en/latest/usage.html
  [License]: https://github.com/brightway-lca/brightway2-ui/blob/main/LICENSE
  [Contributor Guide]: https://github.com/brightway-lca/brightway2-ui/blob/main/CONTRIBUTING.md
  [Issue Tracker]: https://github.com/brightway-lca/brightway2-ui/issues




  You can build the documentation locally by installing the documentation Conda environment:

  ```bash
  conda env create -f docs/environment.yml
  ```

  activating the environment

  ```bash
  conda activate sphinx_brightway2-ui
  ```

  and [running the build command](https://www.sphinx-doc.org/en/master/man/sphinx-build.html#sphinx-build):

  ```bash
  sphinx-build docs _build/html --builder=html --jobs=auto --write-all; open _build/html/index.html
  ```

  and [running the build command](https://www.sphinx-doc.org/en/master/man/sphinx-build.html#sphinx-build):

  ```bash
  sphinx-build docs _build/html --builder=html --jobs=auto --write-all; open _build/html/index.html
  ```


pkgId: 806be85a74e120f42c5da429c95a8f8c5feaafc75810057db11739039c8e7ee5
name: python-bw2calc
arch: src
version: 1.8.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://bitbucket.org/cmutel/brightway2-calc
rpm_license: NewBSD 3-clause; LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw2calc-1.8.2-1.src.rpm
checksum_type: sha256
description:
  This package provides the calculation engine for the `Brightway2 life cycle assessment framework <https://brightwaylca.org>`_. `Online documentation <https://docs.brightwaylca.org/>`_ is available, and the source code is hosted on `Bitucket <https://bitbucket.org/cmutel/brightway2-calc>`_.
  The emphasis here has been on speed of solving the linear systems, for normal LCA calculations, graph traversal, or Monte Carlo uncertainty analysis.
  The Monte Carlo LCA class can do about 30 iterations a second (on a 2011 MacBook Pro). Instead of doing LU factorization, it uses an initial guess and the conjugant gradient squared algorithm.
  The multiprocessing Monte Carlo class (ParallelMonteCarlo) can do about 100 iterations a second, using 7 virtual cores. The MultiMonteCarlo class, which does Monte Carlo for many processes (and hence can re-use the factorized technosphere matrix), can do about 500 iterations a second, using 7 virtual cores. Both these algorithms perform best when the initial setup for each worker job is minimized, e.g. by dispatching big chunks.


pkgId: f106e9b53cd57ac8125b80b840d617b405b0955d79783d33e4c472960f90af1b
name: python-bw2data
arch: src
version: 3.6.6
epoch: 0
release: 1
url: https://bitbucket.org/cmutel/brightway2-data
rpm_license: 3-clause BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw2data-3.6.6-1.src.rpm
checksum_type: sha256
summary:
  Tools for the management of inventory databases and impact assessment methods. Part of the Brightway2 LCA Framework

description:
  This package provides tools for the management of inventory databases and impact assessment methods. It is part of the `Brightway2 LCA framework <https://brightwaylca.org>`_. `Online documentation <https://docs.brightwaylca.org/>`_ is available, and the source code is hosted on `Bitbucket <https://bitbucket.org/cmutel/brightway2-data>`_.


pkgId: 0528476e30752cd6cca53d11c27918c5f36c1000004c50a1888a35325c44a0e3
name: python-bw2data
arch: src
version: 4.1
epoch: 0
release: 1
url: https://pypi.org/project/bw2data/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw2data-4.1-1.src.rpm
checksum_type: sha256
summary:
  Tools for the management of inventory databases and impact assessment methods. Part of the Brightway LCA framework.

description:
  [![PyPI](https://img.shields.io/pypi/v/bw2data.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/bw2data.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/bw2data)][pypi status]
  [![License](https://img.shields.io/pypi/l/bw2data)][license]

  [![Tests](https://github.com/brightway-lca/brightway2-data/actions/workflows/python-test.yml/badge.svg)][tests]
  [![Codecov](https://codecov.io/gh/brightway-lca/bw2data/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 status]: https://pypi.org/project/bw2data/
  [read the docs]: https://bw2data.readthedocs.io/
  [tests]: https://github.com/brightway-lca/brightway2-data/actions?workflow=Tests
  [codecov]: https://app.codecov.io/gh/brightway-lca/bw2data
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black

  This package provides tools for the management of inventory databases and impact assessment methods.
  It is part of the [Brightway LCA framework](https://brightway.dev).
  [Online documentation](https://docs.brightway.dev/) is available, and the source code is hosted on [GitHub brightway-lca organization](https://github.com/brightway-lca/brightway2-data).

  Note that version 4.0 and higher are only compatible with Brightway 2.5, as described in the [changelog](https://github.com/brightway-lca/brightway2-data/blob/main/CHANGES.md).



  You can install _bw2data_ via [pip] from [PyPI]:

  ```console
  $ pip install bw2data
  ```



  Contributions are very welcome.
  To learn more, see the [Contributor Guide][Contributor Guide].



  Distributed under the terms of the [BSD 3 Clause license][License],
  _bw2data_ is free and open source software.



  If you encounter any problems,
  please [file an issue][Issue Tracker] along with a detailed description.


  <!-- github-only -->

  [command-line reference]: https://bw2data.readthedocs.io/en/latest/usage.html
  [License]: https://github.com/brightway-lca/bw2data/blob/main/LICENSE
  [Contributor Guide]: https://github.com/brightway-lca/bw2data/blob/main/CONTRIBUTING.md
  [Issue Tracker]: https://github.com/brightway-lca/bw2data/issues




  You can build the documentation locally by installing the documentation Conda environment:

  ```bash
  conda env create -f docs/environment.yml
  ```

  activating the environment

  ```bash
  conda activate sphinx_bw2data
  ```

  and [running the build command](https://www.sphinx-doc.org/en/master/man/sphinx-build.html#sphinx-build):

  ```bash
  sphinx-build docs _build/html --builder=html --jobs=auto --write-all; open _build/html/index.html
  ```


pkgId: 26c035eca6467feb4ba375c2ff189fa774599d4af894720462a395f69bed4f7f
name: python-bw2io
arch: src
version: 0.8.12
epoch: 0
release: 1
summary: Tools for importing and export life cycle inventory databases
url: https://github.com/brightway-lca/brightway2-io
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw2io-0.8.12-1.src.rpm
checksum_type: sha256
description:
  This package provides tools for the import, export, and management of inventory databases and impact assessment methods. It is part of the `Brightway2 LCA framework <https://brightwaylca.org>`_. `Online documentation <https://docs.brightwaylca.org/>`_ is available, and the source code is hosted on `Bitbucket <https://bitbucket.org/cmutel/brightway2-io>`_.
  In contrast with previous IO functionality in Brightway2, brightway2-io uses an iterative approach to importing and linking data. First, data is *extracted* into a common format. Next, a series of *strategies* is employed to uniquely identify each dataset and link datasets internally and to the biosphere. Following internal linking, linking to other background datasets can be performed. Finally, database data is written to disk.
  This approach offers a number of benefits that help mitigate some of the serious problems in existing inventory data formats: the number of unlinked exchanges can be easily seen, linking strategies can be iteratively applied, and intermediate results can be saved.
  Here is a typical usage:
      In [1]: from bw2io import *
      In [2]: so = SingleOutputEcospold2Importer("/path/to/ecoinvent/3.1/cutoff/datasets", "ecoinvent 3.1 cutoff")
      11301/11301 (100%) |||||||||||||||||||||||||||||||||||||||||||||||||||||||||| Time: 0:01:56
      Converting to unicode
      Extracted 11301 datasets in 262.63 seconds
      In [3]: so.apply_strategies()
      Applying strategy: remove_zero_amount_coproducts
      Applying strategy: remove_zero_amount_inputs_with_no_activity
      Applying strategy: es2_assign_only_product_with_amount_as_reference_product
      Applying strategy: assign_single_product_as_activity
      Applying strategy: create_composite_code
      Applying strategy: link_biosphere_by_flow_uuid
      Applying strategy: link_internal_technosphere_by_composite_code
      Applying strategy: delete_exchanges_missing_activity
      Applying strategy: delete_ghost_exchanges
      Applying strategy: mark_unlinked_exchanges
      In [4]: so.statistics()
      11301 datasets
      521712 exchanges
      0 unlinked exchanges
      Out[4]: (11301, 521712, 0)
      In [5]: so.write_database()
  Note that brightway2-io can't magically make problems in databases go away.


pkgId: e01255404f60986930c6510ebab9ba9bb0ee197d78bd09403a7b1c92432343e6
name: python-bw2io
arch: src
version: 0.9
epoch: 0
release: 1
summary: Tools for importing and export life cycle inventory databases
url: https://pypi.org/project/bw2io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw2io-0.9-1.src.rpm
checksum_type: sha256
description:
  This package provides tools for the import, export, and management of inventory databases and impact assessment methods. It is part of the `Brightway LCA framework <https://brightway.dev/>`_. `Online documentation <https://2.docs.brightway.dev/>`_ is available, and the source code is hosted on `Github <https://github.com/brightway-lca/brightway2-io>`_.


pkgId: 6e33cd3478ac1792514b0a22fb6aca0f89e89a67cab0148dec214383ce843280
name: python-bw2parameters
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Contains all the python boilerplate you need to create a Brightway ecosystem package.
url: https://github.com/brightway-lca/brightway2-parameters
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bw2parameters-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Library for storing, validating, and calculating with parameters. Designed to work with the [Brightway2 life cycle assessment framework](https://brightwaylca.org), but is generic enough to work in other use cases.

      In [1]: from bw2parameters import ParameterSet

      In [2]: parameters = {
         ...:        'Deep_Thought': {'amount': 42},
         ...:        'East_River_Creature': {'formula': '2 * Deep_Thought + 16'},
         ...:        'Elders_of_Krikkit': {'formula': 'sqrt(East_River_Creature)'},
         ...: }

      In [3]: ParameterSet(parameters).evaluate()
      Out[3]: {'Deep_Thought': 42, 'East_River_Creature': 100, 'Elders_of_Krikkit': 10.0}

  Compatible with Python 2.7 and 3.3+. 100% test coverage. [Source code on Github](https://github.com/brightway-lca/brightway2-parameters), documentation on [Read the Docs](https://brightway2-parameters.readthedocs.io/).


pkgId: 2491445f64cd52e5dffccbee04b319fb22f96356ddf4879ba8e2a65818c02899
name: python-bwapi
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: A software development kit for the Brandwatch API
url: https://github.com/BrandwatchLtd/api_sdk
rpm_license: License :: OSI Approved :: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bwapi-4.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/BrandwatchLtd/api_sdk.svg?branch=master)](https://travis-ci.com/BrandwatchLtd/api_sdk)





  The Brandwatch API SDK was designed to address many of the challenges involved in building complex applications which interact with RESTful API's in general and Brandwatch's API from Python 3, in particular:

  - The SDK's object hierarchy roughly mirrors the API's resource hierarchy, making the code intuitive for those familiar with the Brandwatch platform
  - All required parameters are enforced, and most optional parameters are supported and documented
  - Typical Brandwatch workflows are supported behind the scenes; for instance, one can validate, upload, and backfill a query with a single function call
  - The SDK is designed to support simple and readable code: sensible defaults are chosen for rarely used parameters and all resource IDs are handled behind the scenes

  From the user's perspective, the basic structure of the SDK is as follows.  One first creates an instance of the class `BWProject`; this class handles authentication (via a user name and password or API key) and keeps track of project-level data such as the project's ID.  (Behind the scenes, the user-level operations are handled by the class `BWUser` from which `BWProject` is inherited.)  One passes `BWProject` instance as an argument in the constructor for a series of classes which manage the various Brandwatch resources: queries, groups, tags, categories, etc.  These resource classes manage all resource-level operations: for example a single `BWQueries` instance handles all HTTP requests associated with queries in its attached project.



  Be sure to install the latest version of Python 3.x. You can install bwapi on your machine by running the following command:

  `pip install bwapi`

  This allows you to run scripts that import bwproject or bwresources from anywhere on your computer.



  Please see the Jupyter notebook DEMO.ipynb for examples.  This notebook was built as a beginner's guide to using the Brandwatch API SDK, so it has example code, as well as detailed instructions for use.



  This is not an official or supported Brandwatch library, and should be implemented at the users' own risk.


pkgId: fe3d189bd05759ceba946857eab7bdb7721a77af103c4429305ec1398907da81
name: python-bwi
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Package to add bwi methods into your project
url: https://gitlab.com/bwi-gpe/bwi-lib
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bwi-0.1.2-1.src.rpm
checksum_type: sha256
description:
  _python client for BWI interactions_





  ```python
  import bwi


  client = bwi.Client(api_key='xxxxxxxxxxxxxxxx', workflow='shop')
  ```



  ```python

  with client.Step('fetch client information') as bwi:
      bwi.logger.info('found client with user id %d', 18)

  ```



  ```python

  client.Step('validate order')


  total_paid = 220


  bwi.metrics.inc('income', total_paid)
  ```



  ```python

  try:
      
  except Exception as err:
      bwi.handler.catch(err)
      
  ```



  ```python
  step = bwi.Step('process order')


  step.success()


  step.failed()
  ```


pkgId: 2b9fb5838fb18829cd9d36da5faab61b9c247ca67567a239c16a3b4ae89bd908
name: python-bwninja
arch: src
version: 1.2.8
epoch: 0
release: 1
summary: A modern replacement for iftop
url: https://bwninja.zkpq.ca
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bwninja-1.2.8-1.src.rpm
checksum_type: sha256
description:
  A modern replacement for `iftop`

  Why?
  - Colors!
  - More easily readable UI
  - Can track all interfaces
  - Less overhead (uses eBPF to collect metrics, and does not need to copy and process packets in userspace)




  ```sh
  pip install bwninja
  ```



  `bwninja` requires `python3-bpfcc` which does not seem to have a correct package in pip/pypi.

  See the official install documentation here: https://github.com/iovisor/bcc/blob/master/INSTALL.md






  `bwninja` requires root access to the network interfaces.

  ```sh
  bwninja # bwninja will try to escalate itself.

  python -m bwninja.tui # same. if bin script was not installed

  sudo bwninja # will work only if bwninja was installed as a system package
  ```


pkgId: 4b8c36a6cbbc257febb804506112b84e2914bc332143035eabcaaf3465f3ab32
name: python-bx-django-utils
arch: src
version: 79
epoch: 0
release: 1
summary: Various Django utility functions
url: https://pypi.org/project/bx-django-utils/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bx-django-utils-79-1.src.rpm
checksum_type: sha256
description:
  Various Django utility functions

  [![unittests](https://github.com/boxine/bx_django_utils/actions/workflows/pythonapp.yml/badge.svg?branch=master)](https://github.com/boxine/bx_django_utils/actions/workflows/pythonapp.yml) [![Coverage Status on codecov.io](https://codecov.io/gh/boxine/bx_django_utils/branch/master/graph/badge.svg)](https://codecov.io/gh/boxine/bx_django_utils)

  [![bx_django_utils @ PyPi](https://img.shields.io/pypi/v/bx_django_utils?label=bx_django_utils%20%40%20PyPi)](https://pypi.org/project/bx_django_utils/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/bx_django_utils)](https://gitlab.com/boxine/bx_django_utils/-/blob/main/pyproject.toml)
  [![License MIT](https://img.shields.io/pypi/l/bx_django_utils)](https://gitlab.com/boxine/bx_django_utils/-/blob/main/LICENSE)




  ```bash
  pip install bx_django_utils
  ```


  `bx_django_utils` generally follows the support schedule of Django. The project is tested against [officially supported Django versions](https://endoflife.date/django) and [their respective supported CPython versions](https://docs.djangoproject.com/en/stable/faq/install/#what-python-version-can-i-use-with-django).

  However, under special circumstances we may decide to pull support for a specific version early, e.g. if development of the library would be severely limited.
  Check our tox test matrix for a definitive answer.



  Here only a simple list about existing utilities.
  Please take a look into the sources and tests for deeper informations.

  [comment]: <> (✂✂✂ auto generated start ✂✂✂)



  Django Admin extra views: https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/README.md




  Activate "ExtraViewAdminSite" by set this as default admin site

  * [`CustomAdminConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/admin_config.py#L7-L12) - Change Django Admin Site to ExtraViewAdminSite for the extra views.



  * [`AdminExtraViewsAppConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/apps.py#L6-L18) - App config to auto discover all extra views.



  * [`only_staff_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/conditions.py#L4-L15) - Pass only active staff users. The default condition for all admin extra views.



  * [`AdminExtraMeta()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/datatypes.py#L15-L58) - Stores information for pseudo app and pseudo models.
  * [`PseudoApp()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/datatypes.py#L61-L91) - Represents information about a Django App. Instance must be pass to @register_admin_view()



  * [`Command()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/management/commands/admin_extra_views.py#L7-L26) - Manage command "admin_extra_views": Info about registered admin extra views



  * [`AdminExtraViewRegistry()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/registry.py#L12-L101) - Hold all information about all admin extra views to expand urls and admin app list.
  * [`register_admin_view()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/registry.py#L107-L120) - Decorator to add a normal view as pseudo App/Model to the admin.



  * [`ExtraViewAdminSite()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/site.py#L6-L13) - An AdminSite object encapsulates an instance of the Django admin application, ready



  * [`AdminExtraViewsTestCase()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/tests/test_admin_extra_views.py#L10-L43) - Integrations tests for Admin Extra Views.



  * [`iter_admin_extra_views_urls()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/utils.py#L20-L26) - Iterate over all registered admin extra view urls.
  * [`reverse_admin_extra_view()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/utils.py#L10-L17) - Get the URL of a Admin Extra View, e.g.: url=reverse_admin_extra_view(YouAdminExtraView)



  * [`Redirect2AdminExtraView()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/views.py#L7-L23) - Redirect to a Admin Extra Views.



  Helpers to build Admin URLs

  * [`admin_change_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L62-L78) - Shortcut to generate Django admin "change" url for a model instance.
  * [`admin_changelist_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L119-L134) - Shortcut to generate Django admin "changelist" url for a model or instance.
  * [`admin_delete_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L100-L116) - Shortcut to generate Django admin "delete" url for a model instance.
  * [`admin_history_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L81-L97) - Shortcut to generate Django admin "history" url for a model instance.
  * [`admin_model_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L15-L59) - Build Admin change, add, changelist, etc. links with optional filter parameters.



  * [`ExistingCountedListFilter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/filters.py#L26-L62) - Advanced SimpleListFilter that list only existing filter values with counts.
  * [`NotAllSimpleListFilter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/filters.py#L8-L23) - Similar to SimpleListFilter, but don't add "All" choice.



  Base model/admin/form classes to implement a model with draft/approve versions workflow




  * [`BaseApproveModelAdmin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/admin.py#L15-L107) - Base admin class for a draft/approve Model



  * [`PublishAdminForm()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/forms.py#L7-L46) - Activate models REQUIRED_FIELDS_PUBLIC on approve



  * [`BaseApproveModel()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/models.py#L14-L202) - Base model class for approve models *and* this relation models.
  * [`BaseApproveWorkflowModel()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/models.py#L205-L255) - Base model for approve workflow models.



  * [`CachedDataclassBase()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/cached_dataclasses.py#L7-L59) - A Base dataclass that can be easy store/restore to Django cache.



  ModelField, FormField and validators for GTIN/UPC/EAN numbers




  * [`GtinFormField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/form_fields.py#L8-L28) - Form field with GTIN validator.



  * [`GtinModelField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/model_fields.py#L10-L33) - GTIN model field



  * [`GtinValidator()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/validators.py#L33-L52) - Validate GTIN number
  * [`validate_gtin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/validators.py#L12-L30) - It's the same as stdnum.ean.validate() but also accept ISBN-10



  * [`RecordingCursorWrapper()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/dbperf/cursor.py#L17-L136) - An implementation of django.db.backends.utils.CursorWrapper.



  * [`SQLQueryRecorder()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/dbperf/query_recorder.py#L95-L176) - A context manager that allows recording SQL queries executed during its lifetime.



  Feature flags: https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/README.md




  * [`ManageFeatureFlagsBaseView()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/admin_views.py#L31-L101) - Base admin extra view to manage all existing feature flags in admin.



  * [`FeatureFlag()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/data_classes.py#L18-L164) - A feature flag that persistent the state into django cache/database.



  * [`FeatureFlagTestCaseMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/test_utils.py#L35-L79) - Mixin for `TestCase` that will change `FeatureFlag` entries. To make the tests atomic.
  * [`get_feature_flag_states()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/test_utils.py#L12-L17) - Collects information about all registered feature flags and their current state.



  * [`if_feature()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/utils.py#L20-L38) - A decorator that only executed the decorated function if the given feature flag is enabled.



  * [`clean_filename()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/filename.py#L34-L64) - Convert filename to ASCII only via slugify.
  * [`filename2human_name()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/filename.py#L7-L31) - Convert filename to a capitalized name.



  Generic "AdminExtraView" view to filter accessible model by any field value.

  * [`GenericModelFilterBaseView()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/generic_model_filter/admin_views.py#L171-L321) - Base "AdminExtraView" to add this view to the admin interface via @register_admin_view().



  * [`build_url_parameters()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/http.py#L4-L30) - Return an encoded string of all given parameters.



  * [`pformat()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/humanize/pformat.py#L6-L20) - Better `pretty-print-format` using `DjangoJSONEncoder` with fallback to `pprint.pformat()`



  * [`human_timedelta()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/humanize/time.py#L18-L63) - Converts a time duration into a friendly text representation. (`X ms`, `sec`, `minutes` etc.)



  * [`make_json_serializable()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/json_utils.py#L20-L37) - Convert value to a JSON serializable value, with convert callback for special objects.
  * [`to_json()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/json_utils.py#L40-L56) - Convert value to JSON via make_json_serializable() and DjangoJSONEncoder()



  * [`ColorModelField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/color_field.py#L14-L29) - Hex color model field, e.g.: "#0055ff" (It's not a html color picker widget)
  * [`HexColorValidator()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/color_field.py#L6-L11) - Hex color validator (seven-character hexadecimal notation, e.g.: "#0055ff")



  * [`SelectModelForm()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/get_models4user.py#L43-L57) - Form to select a model that the user can "view"
  * [`get_user_model_choices()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/get_models4user.py#L29-L40) - Build a form choices list with all models the given user can "view" | "add" | "change" | "delete" etc.
  * [`iter_user_models()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/get_models4user.py#L11-L26) - Filter models for the given user.



  Utilities to manipulate objects in database via models:

  * [`CreateOrUpdateResult()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L50-L77) - Result object returned by create_or_update2() with all information about create/save a model.
  * [`FieldUpdate()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L39-L47) - Information about updated model field values. Used for CreateOrUpdateResult.update_info
  * [`InvalidStoreBehavior()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L20-L23) - Exception used in create_or_update() if "store_behavior" contains not existing field names.
  * [`create()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L26-L36) - Create a new model instance with optional validate before create.
  * [`create_or_update()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L244-L262) - Create a new model instance or update a existing one. Deprecated! Use: create_or_update2()
  * [`create_or_update2()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L98-L241) - Create a new model instance or update a existing one and returns CreateOrUpdateResult instance
  * [`update_model_field()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L80-L95) - Default callback for create_or_update2() to set a changed model field value and expand CreateOrUpdateResult



  * [`remove_filter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/queryset_utils.py#L8-L38) - Remove an applied .filter() from a QuerySet
  * [`remove_model_filter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/queryset_utils.py#L41-L68) - Remove an applied .filter() from a QuerySet if it contains references to the specified model



  * [`TimetrackingBaseModel()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/timetracking.py#L8-L62) - Abstract base model that will automaticly set create/update Datetimes.



  * [`StackTrace()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/stacktrace.py#L21-L22) - Built-in mutable sequence.
  * [`StacktraceAfter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/stacktrace.py#L87-L115) - Generate a stack trace after a package was visited.
  * [`get_stacktrace()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/stacktrace.py#L64-L84) - Returns a StackTrace object, which is a list of FrameInfo objects.



  * [`dict_get()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/templatetags/accessors.py#L7-L26) - Returns the wanted member of a dict-like container, or an empty string



  * [`human_duration()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/templatetags/humanize_time.py#L16-L58) - Verbose time since template tag, e.g.: `<span title="Jan. 1, 2000, noon">2.0 seconds</span>`



  Utilities / helper for writing tests.




  * [`AssertQueries()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/assert_queries.py#L35-L288) - Assert executed database queries: Check table names, duplicate/similar Queries.



  * [`ClearCacheMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/cache.py#L100-L111) - TestCase mixin to clear the Django cache in setUp/tearDown
  * [`MockCache()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/cache.py#L55-L97) - Mock Django cache backend, so it's easy to check/manipulate the cache content



  * [`ContentTypeCacheFixMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/content_types.py#L7-L35) - TestCase mixin to fill the ContentType cache to avoid flaky database queries.



  * [`MockDatetimeGenerator()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/datetime.py#L4-L50) - Mock django `timezone.now()` with generic time stamps in tests.



  Utilities to manage text fixtures in JSON files.

  * [`BaseFixtures()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L28-L65) - Base class for JSON dump fixtures.
  * [`FixturesRegistry()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L102-L140) - Registry to collect a list of all existing fixture classes.
  * [`RenewAllFixturesBaseCommand()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L172-L248) - A base Django manage command to renew all existing fixture JSON dump files
  * [`SerializerFixtures()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L68-L99) - Helper to store/restore model instances serialized into a JSON file.
  * [`autodiscover()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L146-L169) - Register all fixtures by import all **/fixtures/**/*.py files



  * [`AssertFormFields()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/forms.py#L13-L86) - Helper to check the existing form fields.



  * [`HtmlAssertionMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/html_assertion.py#L48-L184) - Unittest mixin class with useful assertments around Django test client tests
  * [`assert_html_response_snapshot()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/html_assertion.py#L19-L45) - Assert a HttpResponse via snapshot file using assert_html_snapshot() from bx_py_utils.
  * [`get_django_name_suffix()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/html_assertion.py#L12-L16) - Returns a short Django version string, useable for snapshot "name_suffix" e.g.: "django42"



  * [`AssertModelCleanCalled()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/model_clean_assert.py#L35-L86) - Context manager for assert that full_clean() was called for every model instance.
  * [`CleanMock()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/model_clean_assert.py#L6-L32) - Track if full_clean() was called.



  Use Playwright in Unittest + Fast Django user login

  * [`PlaywrightConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/playwright.py#L13-L31) - PlaywrightTestCase config from environment (PWBROWSER, PWHEADLESS, PWSKIP, PWSLOWMO)
  * [`PlaywrightTestCase()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/playwright.py#L34-L91) - StaticLiveServerTestCase with helpers for writing frontend tests using Playwright.



  * [`assert_permissions()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L33-L48) - Check user permissions.
  * [`assert_user_properties()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L151-L173) - Check a user instance with all properties and password (optional)
  * [`filter_permission_names()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L12-L30) - Generate a Permission model query filtered by names, e.g.: ['<app_label>.<codename>', ...]
  * [`make_max_test_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L114-L148) - Create a test user with all permissions *except* the {exclude_permissions} ones.
  * [`make_minimal_test_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L87-L111) - Create a test user and set given permissions.
  * [`make_test_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L51-L84) - Create a test user and set given permissions.



  * [`FieldTranslation()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L110-L128) - Dict-like container that maps language codes to a translated string.
  * [`TranslationField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L131-L261) - A field designed to hold translations for a given set of language codes.
  * [`TranslationFieldAdmin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L410-L471) - Provides drop-in support for ModelAdmin classes that want to display TranslationFields
  * [`TranslationFormField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L63-L107) - Default form field for TranslationField.
  * [`TranslationSlugField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L318-L407) - A unique translation slug field, useful in combination with TranslationField()
  * [`create_or_update_translation_callback()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L474-L507) - Callback for create_or_update2() for TranslationField, that will never remove existing translation.
  * [`expand_languages_codes()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L580-L600) - Build a complete list if language code with and without dialects.
  * [`get_user_priorities()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L603-L616) - Collect usable language codes the current user
  * [`make_unique()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L568-L577) - Flat args and remove duplicate entries while keeping the order intact.
  * [`merge_translations()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L521-L532) - Merge two FieldTranslation and ignore all empty/None values, e.g.:
  * [`remove_empty_translations()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L510-L518) - Remove all empty/None from a FieldTranslation, e.g.:
  * [`user_language_priorities()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L619-L627) - Returns the order in which to attempt resolving translations of a FieldTranslation model field.
  * [`validate_unique_translations()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L535-L565) - Deny creating non-unique translation: Creates ValidationError with change list search for doubled entries.



  Automatic local user timezone: https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/README.md




  * [`UserTimezoneAppConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/apps.py#L4-L14) - Django app to set the user local time zone.



  * [`human_timezone_datetime()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/humanize.py#L7-L21) - Render a datetime with timezone information.



  * [`InvalidUserTimeZone()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/middleware.py#L11-L12) - Inappropriate argument value (of correct type).
  * [`UserTimezoneMiddleware()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/middleware.py#L34-L68) - Activate Timezone by "UserTimeZone" cookie
  * [`validate()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/middleware.py#L15-L31) - Validate the UserTimeZone cookie value.



  * [`humane_timezone_dt()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/templatetags/user_timezone.py#L9-L14) - Template filter to render a datetime with timezone information.



  * [`DetermineVersionCommand()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/version.py#L50-L78) - Write application version determined from git as a command



  * [`DynamicViewMenu()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/view_utils/dynamic_menu_urls.py#L4-L45) - Simple storage for store information about views/urls to build a menu.

  [comment]: <> (✂✂✂ auto generated end ✂✂✂)



  To start developing e.g.:

  ```bash
  ~$ git clone https://github.com/boxine/bx_django_utils.git
  ~$ cd bx_django_utils
  ~/bx_django_utils$ make
  help                 List all commands
  install-poetry       install poetry
  install              install via poetry
  update               Update the dependencies as according to the pyproject.toml file
  lint                 Run code formatters and linter
  fix-code-style       Fix code formatting
  tox-listenvs         List all tox test environments
  tox                  Run unittests via tox with all environments
  test                 Run unittests
  publish              Release new version to PyPi
  docker-test          Run tests in docker
  makemessages         Make and compile locales message files
  start-dev-server     Start Django dev. server with the test project
  clean                Remove created files from the test project (e.g.: SQlite, static files)
  playwright-install   Install test browser for Playwright tests
  playwright-inspector Run Playwright inspector
  playwright-tests     Run only the Playwright tests
  ```

  You can start the test project with the Django developing server, e.g.:
  ```bash
  ~/bx_django_utils$ make start-dev-server
  ```
  This is a own manage command, that will create migrations files from our test app, migrate, collectstatic and create a super user if no user exists ;)

  If you like to start from stretch, just delete related test project files with:
  ```bash
  ~/bx_django_utils$ make clean
  ```
  ...and start the test server again ;)





  * Increase verion number in `bx_django_utils/__init__.py`
  * Create pull request
  * After merge, call: `make publish`




  [MIT](https://github.com/boxine/bx_django_utils/blob/master/LICENSE). Patches welcome!




  We’ve been rethinking the listening experience for kids and have created an ecosystem where haptic and listening experience are combined via smart technology - the Toniebox.

  We are constantly looking for engineers to join our team in different areas. If you’d be interested in contributing to our platform, have a look at: https://tonies.com/jobs/




  * https://pypi.org/project/bx-django-utils/


pkgId: 8b478cd79611eab7f5e71f8f31d8f33a30fac9f46e60cf973fe6386306bc5003
name: python-bx-django-utils
arch: src
version: 82
epoch: 0
release: 1
summary: Various Django utility functions
url: https://pypi.org/project/bx-django-utils/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bx-django-utils-82-1.src.rpm
checksum_type: sha256
description:
  Various Django utility functions

  [![unittests](https://github.com/boxine/bx_django_utils/actions/workflows/pythonapp.yml/badge.svg?branch=master)](https://github.com/boxine/bx_django_utils/actions/workflows/pythonapp.yml) [![Coverage Status on codecov.io](https://codecov.io/gh/boxine/bx_django_utils/branch/master/graph/badge.svg)](https://codecov.io/gh/boxine/bx_django_utils)

  [![bx_django_utils @ PyPi](https://img.shields.io/pypi/v/bx_django_utils?label=bx_django_utils%20%40%20PyPi)](https://pypi.org/project/bx_django_utils/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/bx_django_utils)](https://gitlab.com/boxine/bx_django_utils/-/blob/main/pyproject.toml)
  [![License MIT](https://img.shields.io/pypi/l/bx_django_utils)](https://gitlab.com/boxine/bx_django_utils/-/blob/main/LICENSE)




  ```bash
  pip install bx_django_utils
  ```


  `bx_django_utils` generally follows the support schedule of Django. The project is tested against [officially supported Django versions](https://endoflife.date/django) and [their respective supported CPython versions](https://docs.djangoproject.com/en/stable/faq/install/#what-python-version-can-i-use-with-django).

  However, under special circumstances we may decide to pull support for a specific version early, e.g. if development of the library would be severely limited.
  Check our tox test matrix for a definitive answer.



  Here only a simple list about existing utilities.
  Please take a look into the sources and tests for deeper informations.

  [comment]: <> (✂✂✂ auto generated start ✂✂✂)



  Django Admin extra views: https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/README.md




  Activate "ExtraViewAdminSite" by set this as default admin site

  * [`CustomAdminConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/admin_config.py#L7-L12) - Change Django Admin Site to ExtraViewAdminSite for the extra views.



  * [`AdminExtraViewsAppConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/apps.py#L6-L18) - App config to auto discover all extra views.



  * [`only_staff_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/conditions.py#L4-L15) - Pass only active staff users. The default condition for all admin extra views.



  * [`AdminExtraMeta()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/datatypes.py#L14-L57) - Stores information for pseudo app and pseudo models.
  * [`PseudoApp()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/datatypes.py#L60-L90) - Represents information about a Django App. Instance must be pass to @register_admin_view()



  * [`Command()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/management/commands/admin_extra_views.py#L7-L26) - Manage command "admin_extra_views": Info about registered admin extra views



  * [`AdminExtraViewRegistry()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/registry.py#L11-L100) - Hold all information about all admin extra views to expand urls and admin app list.
  * [`register_admin_view()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/registry.py#L106-L119) - Decorator to add a normal view as pseudo App/Model to the admin.



  * [`ExtraViewAdminSite()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/site.py#L6-L13) - An AdminSite object encapsulates an instance of the Django admin application, ready



  * [`AdminExtraViewsTestCase()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/tests/test_admin_extra_views.py#L10-L43) - Integrations tests for Admin Extra Views.



  * [`iter_admin_extra_views_urls()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/utils.py#L20-L26) - Iterate over all registered admin extra view urls.
  * [`reverse_admin_extra_view()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/utils.py#L10-L17) - Get the URL of a Admin Extra View, e.g.: url=reverse_admin_extra_view(YouAdminExtraView)



  * [`Redirect2AdminExtraView()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/views.py#L7-L23) - Redirect to a Admin Extra Views.



  Helpers to build Admin URLs

  * [`admin_change_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L61-L77) - Shortcut to generate Django admin "change" url for a model instance.
  * [`admin_changelist_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L118-L133) - Shortcut to generate Django admin "changelist" url for a model or instance.
  * [`admin_delete_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L99-L115) - Shortcut to generate Django admin "delete" url for a model instance.
  * [`admin_history_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L80-L96) - Shortcut to generate Django admin "history" url for a model instance.
  * [`admin_model_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L14-L58) - Build Admin change, add, changelist, etc. links with optional filter parameters.



  * [`ExistingCountedListFilter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/filters.py#L26-L62) - Advanced SimpleListFilter that list only existing filter values with counts.
  * [`NotAllSimpleListFilter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/filters.py#L8-L23) - Similar to SimpleListFilter, but don't add "All" choice.



  Base model/admin/form classes to implement a model with draft/approve versions workflow




  * [`BaseApproveModelAdmin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/admin.py#L15-L107) - Base admin class for a draft/approve Model



  * [`PublishAdminForm()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/forms.py#L7-L46) - Activate models REQUIRED_FIELDS_PUBLIC on approve



  * [`BaseApproveModel()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/models.py#L14-L202) - Base model class for approve models *and* this relation models.
  * [`BaseApproveWorkflowModel()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/models.py#L205-L255) - Base model for approve workflow models.



  * [`CachedDataclassBase()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/cached_dataclasses.py#L7-L59) - A Base dataclass that can be easy store/restore to Django cache.



  ModelField, FormField and validators for GTIN/UPC/EAN numbers




  * [`GtinFormField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/form_fields.py#L8-L28) - Form field with GTIN validator.



  * [`GtinModelField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/model_fields.py#L10-L33) - GTIN model field



  * [`GtinValidator()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/validators.py#L33-L52) - Validate GTIN number
  * [`validate_gtin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/validators.py#L12-L30) - It's the same as stdnum.ean.validate() but also accept ISBN-10



  * [`RecordingCursorWrapper()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/dbperf/cursor.py#L17-L136) - An implementation of django.db.backends.utils.CursorWrapper.



  * [`SQLQueryRecorder()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/dbperf/query_recorder.py#L95-L176) - A context manager that allows recording SQL queries executed during its lifetime.



  Feature flags: https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/README.md




  * [`ManageFeatureFlagsBaseView()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/admin_views.py#L31-L105) - Base admin extra view to manage all existing feature flags in admin.



  * [`FeatureFlag()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/data_classes.py#L20-L204) - A feature flag that persistent the state into django cache/database.



  * [`FeatureFlagTestCaseMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/test_utils.py#L35-L79) - Mixin for `TestCase` that will change `FeatureFlag` entries. To make the tests atomic.
  * [`get_feature_flag_states()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/test_utils.py#L12-L17) - Collects information about all registered feature flags and their current state.



  * [`if_feature()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/utils.py#L20-L38) - A decorator that only executed the decorated function if the given feature flag is enabled.



  * [`clean_filename()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/filename.py#L34-L64) - Convert filename to ASCII only via slugify.
  * [`filename2human_name()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/filename.py#L7-L31) - Convert filename to a capitalized name.



  Generic "AdminExtraView" view to filter accessible model by any field value.

  * [`GenericModelFilterBaseView()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/generic_model_filter/admin_views.py#L171-L321) - Base "AdminExtraView" to add this view to the admin interface via @register_admin_view().



  * [`build_url_parameters()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/http.py#L4-L30) - Return an encoded string of all given parameters.



  * [`pformat()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/humanize/pformat.py#L6-L20) - Better `pretty-print-format` using `DjangoJSONEncoder` with fallback to `pprint.pformat()`



  * [`human_timedelta()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/humanize/time.py#L18-L63) - Converts a time duration into a friendly text representation. (`X ms`, `sec`, `minutes` etc.)



  * [`make_json_serializable()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/json_utils.py#L20-L37) - Convert value to a JSON serializable value, with convert callback for special objects.
  * [`to_json()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/json_utils.py#L40-L56) - Convert value to JSON via make_json_serializable() and DjangoJSONEncoder()



  * [`ColorModelField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/color_field.py#L14-L29) - Hex color model field, e.g.: "#0055ff" (It's not a html color picker widget)
  * [`HexColorValidator()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/color_field.py#L6-L11) - Hex color validator (seven-character hexadecimal notation, e.g.: "#0055ff")



  * [`SelectModelForm()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/get_models4user.py#L43-L57) - Form to select a model that the user can "view"
  * [`get_user_model_choices()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/get_models4user.py#L29-L40) - Build a form choices list with all models the given user can "view" | "add" | "change" | "delete" etc.
  * [`iter_user_models()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/get_models4user.py#L11-L26) - Filter models for the given user.



  Utilities to manipulate objects in database via models:

  * [`CreateOrUpdateResult()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L50-L77) - Result object returned by create_or_update2() with all information about create/save a model.
  * [`FieldUpdate()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L39-L47) - Information about updated model field values. Used for CreateOrUpdateResult.update_info
  * [`InvalidStoreBehavior()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L20-L23) - Exception used in create_or_update() if "store_behavior" contains not existing field names.
  * [`create()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L26-L36) - Create a new model instance with optional validate before create.
  * [`create_or_update()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L244-L262) - Create a new model instance or update a existing one. Deprecated! Use: create_or_update2()
  * [`create_or_update2()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L98-L241) - Create a new model instance or update a existing one and returns CreateOrUpdateResult instance
  * [`update_model_field()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L80-L95) - Default callback for create_or_update2() to set a changed model field value and expand CreateOrUpdateResult



  * [`remove_filter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/queryset_utils.py#L7-L37) - Remove an applied .filter() from a QuerySet
  * [`remove_model_filter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/queryset_utils.py#L40-L67) - Remove an applied .filter() from a QuerySet if it contains references to the specified model



  * [`TimetrackingBaseModel()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/timetracking.py#L8-L62) - Abstract base model that will automaticly set create/update Datetimes.



  * [`StackTrace()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/stacktrace.py#L21-L22) - Built-in mutable sequence.
  * [`StacktraceAfter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/stacktrace.py#L87-L115) - Generate a stack trace after a package was visited.
  * [`get_stacktrace()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/stacktrace.py#L64-L84) - Returns a StackTrace object, which is a list of FrameInfo objects.



  * [`dict_get()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/templatetags/accessors.py#L7-L26) - Returns the wanted member of a dict-like container, or an empty string



  * [`human_duration()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/templatetags/humanize_time.py#L16-L58) - Verbose time since template tag, e.g.: `<span title="Jan. 1, 2000, noon">2.0 seconds</span>`



  Utilities / helper for writing tests.




  * [`AssertQueries()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/assert_queries.py#L34-L287) - Assert executed database queries: Check table names, duplicate/similar Queries.



  * [`ClearCacheMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/cache.py#L100-L111) - TestCase mixin to clear the Django cache in setUp/tearDown
  * [`MockCache()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/cache.py#L55-L97) - Mock Django cache backend, so it's easy to check/manipulate the cache content



  * [`ContentTypeCacheFixMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/content_types.py#L7-L35) - TestCase mixin to fill the ContentType cache to avoid flaky database queries.



  * [`MockDatetimeGenerator()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/datetime.py#L4-L50) - Mock django `timezone.now()` with generic time stamps in tests.



  Utilities to manage text fixtures in JSON files.

  * [`BaseFixtures()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L28-L65) - Base class for JSON dump fixtures.
  * [`FixturesRegistry()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L102-L140) - Registry to collect a list of all existing fixture classes.
  * [`RenewAllFixturesBaseCommand()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L172-L248) - A base Django manage command to renew all existing fixture JSON dump files
  * [`SerializerFixtures()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L68-L99) - Helper to store/restore model instances serialized into a JSON file.
  * [`autodiscover()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L146-L169) - Register all fixtures by import all **/fixtures/**/*.py files



  * [`AssertFormFields()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/forms.py#L13-L86) - Helper to check the existing form fields.



  * [`HtmlAssertionMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/html_assertion.py#L48-L184) - Unittest mixin class with useful assertments around Django test client tests
  * [`assert_html_response_snapshot()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/html_assertion.py#L19-L45) - Assert a HttpResponse via snapshot file using assert_html_snapshot() from bx_py_utils.
  * [`get_django_name_suffix()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/html_assertion.py#L12-L16) - Returns a short Django version string, useable for snapshot "name_suffix" e.g.: "django42"



  * [`AssertModelCleanCalled()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/model_clean_assert.py#L35-L86) - Context manager for assert that full_clean() was called for every model instance.
  * [`CleanMock()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/model_clean_assert.py#L6-L32) - Track if full_clean() was called.



  Use Playwright in Unittest + Fast Django user login

  * [`PlaywrightConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/playwright.py#L13-L31) - PlaywrightTestCase config from environment (PWBROWSER, PWHEADLESS, PWSKIP, PWSLOWMO)
  * [`PlaywrightTestCase()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/playwright.py#L34-L91) - StaticLiveServerTestCase with helpers for writing frontend tests using Playwright.



  * [`assert_permissions()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L33-L48) - Check user permissions.
  * [`assert_user_properties()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L151-L173) - Check a user instance with all properties and password (optional)
  * [`filter_permission_names()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L12-L30) - Generate a Permission model query filtered by names, e.g.: ['<app_label>.<codename>', ...]
  * [`make_max_test_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L114-L148) - Create a test user with all permissions *except* the {exclude_permissions} ones.
  * [`make_minimal_test_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L87-L111) - Create a test user and set given permissions.
  * [`make_test_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L51-L84) - Create a test user and set given permissions.



  * [`FieldTranslation()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L110-L128) - Dict-like container that maps language codes to a translated string.
  * [`TranslationField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L131-L261) - A field designed to hold translations for a given set of language codes.
  * [`TranslationFieldAdmin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L410-L471) - Provides drop-in support for ModelAdmin classes that want to display TranslationFields
  * [`TranslationFormField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L63-L107) - Default form field for TranslationField.
  * [`TranslationSlugField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L318-L407) - A unique translation slug field, useful in combination with TranslationField()
  * [`create_or_update_translation_callback()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L474-L507) - Callback for create_or_update2() for TranslationField, that will never remove existing translation.
  * [`expand_languages_codes()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L580-L600) - Build a complete list if language code with and without dialects.
  * [`get_user_priorities()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L603-L616) - Collect usable language codes the current user
  * [`make_unique()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L568-L577) - Flat args and remove duplicate entries while keeping the order intact.
  * [`merge_translations()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L521-L532) - Merge two FieldTranslation and ignore all empty/None values, e.g.:
  * [`remove_empty_translations()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L510-L518) - Remove all empty/None from a FieldTranslation, e.g.:
  * [`user_language_priorities()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L619-L627) - Returns the order in which to attempt resolving translations of a FieldTranslation model field.
  * [`validate_unique_translations()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L535-L565) - Deny creating non-unique translation: Creates ValidationError with change list search for doubled entries.



  Automatic local user timezone: https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/README.md




  * [`UserTimezoneAppConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/apps.py#L4-L14) - Django app to set the user local time zone.



  * [`human_timezone_datetime()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/humanize.py#L7-L21) - Render a datetime with timezone information.



  * [`InvalidUserTimeZone()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/middleware.py#L11-L12) - Inappropriate argument value (of correct type).
  * [`UserTimezoneMiddleware()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/middleware.py#L34-L68) - Activate Timezone by "UserTimeZone" cookie
  * [`validate()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/middleware.py#L15-L31) - Validate the UserTimeZone cookie value.



  * [`humane_timezone_dt()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/templatetags/user_timezone.py#L9-L14) - Template filter to render a datetime with timezone information.



  * [`DetermineVersionCommand()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/version.py#L50-L78) - Write application version determined from git as a command



  * [`DynamicViewMenu()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/view_utils/dynamic_menu_urls.py#L4-L45) - Simple storage for store information about views/urls to build a menu.

  [comment]: <> (✂✂✂ auto generated end ✂✂✂)



  To start developing e.g.:

  ```bash
  ~$ git clone https://github.com/boxine/bx_django_utils.git
  ~$ cd bx_django_utils
  ~/bx_django_utils$ make
  help                 List all commands
  install-poetry       install poetry
  install              install via poetry
  update               Update the dependencies as according to the pyproject.toml file
  lint                 Run code formatters and linter
  fix-code-style       Fix code formatting
  tox-listenvs         List all tox test environments
  tox                  Run unittests via tox with all environments
  test                 Run unittests
  publish              Release new version to PyPi
  docker-test          Run tests in docker
  makemessages         Make and compile locales message files
  start-dev-server     Start Django dev. server with the test project
  clean                Remove created files from the test project (e.g.: SQlite, static files)
  playwright-install   Install test browser for Playwright tests
  playwright-inspector Run Playwright inspector
  playwright-tests     Run only the Playwright tests
  ```

  You can start the test project with the Django developing server, e.g.:
  ```bash
  ~/bx_django_utils$ make start-dev-server
  ```
  This is a own manage command, that will create migrations files from our test app, migrate, collectstatic and create a super user if no user exists ;)

  If you like to start from stretch, just delete related test project files with:
  ```bash
  ~/bx_django_utils$ make clean
  ```
  ...and start the test server again ;)





  * Increase verion number in `bx_django_utils/__init__.py`
  * Create pull request
  * After merge, call: `make publish`




  [MIT](https://github.com/boxine/bx_django_utils/blob/master/LICENSE). Patches welcome!




  We’ve been rethinking the listening experience for kids and have created an ecosystem where haptic and listening experience are combined via smart technology - the Toniebox.

  We are constantly looking for engineers to join our team in different areas. If you’d be interested in contributing to our platform, have a look at: https://tonies.com/jobs/




  * https://pypi.org/project/bx-django-utils/


pkgId: ae7191d60cfdad2402a8b0891c8f6ff4844824363bad1794b2cfba302873fe27
name: python-bx-django-utils
arch: src
version: 84
epoch: 0
release: 1
summary: Various Django utility functions
url: https://pypi.org/project/bx-django-utils/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bx-django-utils-84-1.src.rpm
checksum_type: sha256
description:
  Various Django utility functions

  [![unittests](https://github.com/boxine/bx_django_utils/actions/workflows/pythonapp.yml/badge.svg?branch=master)](https://github.com/boxine/bx_django_utils/actions/workflows/pythonapp.yml) [![Coverage Status on codecov.io](https://codecov.io/gh/boxine/bx_django_utils/branch/master/graph/badge.svg)](https://codecov.io/gh/boxine/bx_django_utils)

  [![bx_django_utils @ PyPi](https://img.shields.io/pypi/v/bx_django_utils?label=bx_django_utils%20%40%20PyPi)](https://pypi.org/project/bx_django_utils/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/bx_django_utils)](https://gitlab.com/boxine/bx_django_utils/-/blob/main/pyproject.toml)
  [![License MIT](https://img.shields.io/pypi/l/bx_django_utils)](https://gitlab.com/boxine/bx_django_utils/-/blob/main/LICENSE)




  ```bash
  pip install bx_django_utils
  ```


  `bx_django_utils` generally follows the support schedule of Django. The project is tested against [officially supported Django versions](https://endoflife.date/django) and [their respective supported CPython versions](https://docs.djangoproject.com/en/stable/faq/install/#what-python-version-can-i-use-with-django).

  However, under special circumstances we may decide to pull support for a specific version early, e.g. if development of the library would be severely limited.
  Check our tox test matrix for a definitive answer.



  Here only a simple list about existing utilities.
  Please take a look into the sources and tests for deeper informations.

  [comment]: <> (✂✂✂ auto generated start ✂✂✂)



  Django Admin extra views: https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/README.md




  Activate "ExtraViewAdminSite" by set this as default admin site

  * [`CustomAdminConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/admin_config.py#L7-L12) - Change Django Admin Site to ExtraViewAdminSite for the extra views.



  * [`AdminExtraViewsAppConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/apps.py#L6-L18) - App config to auto discover all extra views.



  * [`only_staff_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/conditions.py#L4-L15) - Pass only active staff users. The default condition for all admin extra views.



  * [`AdminExtraMeta()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/datatypes.py#L14-L57) - Stores information for pseudo app and pseudo models.
  * [`PseudoApp()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/datatypes.py#L60-L90) - Represents information about a Django App. Instance must be pass to @register_admin_view()



  * [`Command()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/management/commands/admin_extra_views.py#L7-L26) - Manage command "admin_extra_views": Info about registered admin extra views



  * [`AdminExtraViewRegistry()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/registry.py#L11-L100) - Hold all information about all admin extra views to expand urls and admin app list.
  * [`register_admin_view()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/registry.py#L106-L119) - Decorator to add a normal view as pseudo App/Model to the admin.



  * [`ExtraViewAdminSite()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/site.py#L6-L13) - An AdminSite object encapsulates an instance of the Django admin application, ready



  * [`AdminExtraViewsTestCase()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/tests/test_admin_extra_views.py#L10-L43) - Integrations tests for Admin Extra Views.



  * [`iter_admin_extra_views_urls()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/utils.py#L20-L26) - Iterate over all registered admin extra view urls.
  * [`reverse_admin_extra_view()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/utils.py#L10-L17) - Get the URL of a Admin Extra View, e.g.: url=reverse_admin_extra_view(YouAdminExtraView)



  * [`Redirect2AdminExtraView()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_extra_views/views.py#L7-L23) - Redirect to a Admin Extra Views.



  Helpers to build Admin URLs

  * [`admin_change_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L61-L77) - Shortcut to generate Django admin "change" url for a model instance.
  * [`admin_changelist_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L118-L133) - Shortcut to generate Django admin "changelist" url for a model or instance.
  * [`admin_delete_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L99-L115) - Shortcut to generate Django admin "delete" url for a model instance.
  * [`admin_history_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L80-L96) - Shortcut to generate Django admin "history" url for a model instance.
  * [`admin_model_url()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/admin_urls.py#L14-L58) - Build Admin change, add, changelist, etc. links with optional filter parameters.



  * [`ExistingCountedListFilter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/filters.py#L26-L62) - Advanced SimpleListFilter that list only existing filter values with counts.
  * [`NotAllSimpleListFilter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/admin_utils/filters.py#L8-L23) - Similar to SimpleListFilter, but don't add "All" choice.



  Base model/admin/form classes to implement a model with draft/approve versions workflow




  * [`BaseApproveModelAdmin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/admin.py#L15-L107) - Base admin class for a draft/approve Model



  * [`PublishAdminForm()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/forms.py#L7-L46) - Activate models REQUIRED_FIELDS_PUBLIC on approve



  * [`BaseApproveModel()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/models.py#L14-L202) - Base model class for approve models *and* this relation models.
  * [`BaseApproveWorkflowModel()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/approve_workflow/models.py#L205-L255) - Base model for approve workflow models.



  * [`CachedDataclassBase()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/cached_dataclasses.py#L7-L59) - A Base dataclass that can be easy store/restore to Django cache.



  ModelField, FormField and validators for GTIN/UPC/EAN numbers




  * [`GtinFormField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/form_fields.py#L8-L28) - Form field with GTIN validator.



  * [`GtinModelField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/model_fields.py#L10-L33) - GTIN model field



  * [`GtinValidator()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/validators.py#L33-L52) - Validate GTIN number
  * [`validate_gtin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/data_types/gtin/validators.py#L12-L30) - It's the same as stdnum.ean.validate() but also accept ISBN-10



  * [`RecordingCursorWrapper()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/dbperf/cursor.py#L17-L136) - An implementation of django.db.backends.utils.CursorWrapper.



  * [`SQLQueryRecorder()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/dbperf/query_recorder.py#L95-L176) - A context manager that allows recording SQL queries executed during its lifetime.



  Feature flags: https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/README.md




  * [`ManageFeatureFlagsBaseView()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/admin_views.py#L31-L105) - Base admin extra view to manage all existing feature flags in admin.



  * [`FeatureFlag()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/data_classes.py#L17-L171) - A feature flag that persistent the state into django cache/database.



  * [`FeatureFlagTestCaseMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/test_utils.py#L24-L68) - Mixin for `TestCase` that will change `FeatureFlag` entries. To make the tests atomic.
  * [`get_feature_flag_states()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/test_utils.py#L11-L16) - Collects information about all registered feature flags and their current state.



  * [`if_feature()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/feature_flags/utils.py#L11-L39) - A decorator that only executes the decorated function if the given feature flag is enabled.



  * [`clean_filename()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/filename.py#L34-L64) - Convert filename to ASCII only via slugify.
  * [`filename2human_name()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/filename.py#L7-L31) - Convert filename to a capitalized name.



  Generic "AdminExtraView" view to filter accessible model by any field value.

  * [`GenericModelFilterBaseView()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/generic_model_filter/admin_views.py#L171-L321) - Base "AdminExtraView" to add this view to the admin interface via @register_admin_view().



  * [`build_url_parameters()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/http.py#L4-L30) - Return an encoded string of all given parameters.



  * [`pformat()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/humanize/pformat.py#L6-L20) - Better `pretty-print-format` using `DjangoJSONEncoder` with fallback to `pprint.pformat()`



  * [`human_timedelta()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/humanize/time.py#L18-L63) - Converts a time duration into a friendly text representation. (`X ms`, `sec`, `minutes` etc.)



  * [`make_json_serializable()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/json_utils.py#L20-L37) - Convert value to a JSON serializable value, with convert callback for special objects.
  * [`to_json()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/json_utils.py#L40-L56) - Convert value to JSON via make_json_serializable() and DjangoJSONEncoder()



  * [`ColorModelField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/color_field.py#L14-L29) - Hex color model field, e.g.: "#0055ff" (It's not a html color picker widget)
  * [`HexColorValidator()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/color_field.py#L6-L11) - Hex color validator (seven-character hexadecimal notation, e.g.: "#0055ff")



  * [`SelectModelForm()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/get_models4user.py#L43-L57) - Form to select a model that the user can "view"
  * [`get_user_model_choices()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/get_models4user.py#L29-L40) - Build a form choices list with all models the given user can "view" | "add" | "change" | "delete" etc.
  * [`iter_user_models()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/get_models4user.py#L11-L26) - Filter models for the given user.



  Utilities to manipulate objects in database via models:

  * [`CreateOrUpdateResult()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L50-L77) - Result object returned by create_or_update2() with all information about create/save a model.
  * [`FieldUpdate()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L39-L47) - Information about updated model field values. Used for CreateOrUpdateResult.update_info
  * [`InvalidStoreBehavior()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L20-L23) - Exception used in create_or_update() if "store_behavior" contains not existing field names.
  * [`create()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L26-L36) - Create a new model instance with optional validate before create.
  * [`create_or_update()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L244-L262) - Create a new model instance or update a existing one. Deprecated! Use: create_or_update2()
  * [`create_or_update2()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L98-L241) - Create a new model instance or update a existing one and returns CreateOrUpdateResult instance
  * [`update_model_field()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/manipulate.py#L80-L95) - Default callback for create_or_update2() to set a changed model field value and expand CreateOrUpdateResult



  * [`remove_filter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/queryset_utils.py#L7-L37) - Remove an applied .filter() from a QuerySet
  * [`remove_model_filter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/queryset_utils.py#L40-L67) - Remove an applied .filter() from a QuerySet if it contains references to the specified model



  * [`TimetrackingBaseModel()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/models/timetracking.py#L8-L62) - Abstract base model that will automaticly set create/update Datetimes.



  * [`StackTrace()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/stacktrace.py#L21-L22) - Built-in mutable sequence.
  * [`StacktraceAfter()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/stacktrace.py#L87-L115) - Generate a stack trace after a package was visited.
  * [`get_stacktrace()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/stacktrace.py#L64-L84) - Returns a StackTrace object, which is a list of FrameInfo objects.



  * [`dict_get()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/templatetags/accessors.py#L7-L26) - Returns the wanted member of a dict-like container, or an empty string



  * [`human_duration()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/templatetags/humanize_time.py#L16-L58) - Verbose time since template tag, e.g.: `<span title="Jan. 1, 2000, noon">2.0 seconds</span>`



  Utilities / helper for writing tests.




  * [`AssertQueries()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/assert_queries.py#L34-L287) - Assert executed database queries: Check table names, duplicate/similar Queries.



  * [`ClearCacheMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/cache.py#L100-L111) - TestCase mixin to clear the Django cache in setUp/tearDown
  * [`MockCache()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/cache.py#L55-L97) - Mock Django cache backend, so it's easy to check/manipulate the cache content



  * [`ContentTypeCacheFixMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/content_types.py#L7-L35) - TestCase mixin to fill the ContentType cache to avoid flaky database queries.



  * [`MockDatetimeGenerator()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/datetime.py#L4-L50) - Mock django `timezone.now()` with generic time stamps in tests.



  Utilities to manage text fixtures in JSON files.

  * [`BaseFixtures()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L28-L65) - Base class for JSON dump fixtures.
  * [`FixturesRegistry()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L102-L140) - Registry to collect a list of all existing fixture classes.
  * [`RenewAllFixturesBaseCommand()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L172-L248) - A base Django manage command to renew all existing fixture JSON dump files
  * [`SerializerFixtures()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L68-L99) - Helper to store/restore model instances serialized into a JSON file.
  * [`autodiscover()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/fixtures.py#L146-L169) - Register all fixtures by import all **/fixtures/**/*.py files



  * [`AssertFormFields()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/forms.py#L13-L86) - Helper to check the existing form fields.



  * [`HtmlAssertionMixin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/html_assertion.py#L48-L184) - Unittest mixin class with useful assertments around Django test client tests
  * [`assert_html_response_snapshot()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/html_assertion.py#L19-L45) - Assert a HttpResponse via snapshot file using assert_html_snapshot() from bx_py_utils.
  * [`get_django_name_suffix()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/html_assertion.py#L12-L16) - Returns a short Django version string, useable for snapshot "name_suffix" e.g.: "django42"



  * [`AssertModelCleanCalled()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/model_clean_assert.py#L35-L86) - Context manager for assert that full_clean() was called for every model instance.
  * [`CleanMock()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/model_clean_assert.py#L6-L32) - Track if full_clean() was called.



  Use Playwright in Unittest + Fast Django user login

  * [`PlaywrightConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/playwright.py#L13-L31) - PlaywrightTestCase config from environment (PWBROWSER, PWHEADLESS, PWSKIP, PWSLOWMO)
  * [`PlaywrightTestCase()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/playwright.py#L34-L91) - StaticLiveServerTestCase with helpers for writing frontend tests using Playwright.



  * [`assert_permissions()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L33-L48) - Check user permissions.
  * [`assert_user_properties()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L151-L173) - Check a user instance with all properties and password (optional)
  * [`filter_permission_names()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L12-L30) - Generate a Permission model query filtered by names, e.g.: ['<app_label>.<codename>', ...]
  * [`make_max_test_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L114-L148) - Create a test user with all permissions *except* the {exclude_permissions} ones.
  * [`make_minimal_test_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L87-L111) - Create a test user and set given permissions.
  * [`make_test_user()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/test_utils/users.py#L51-L84) - Create a test user and set given permissions.



  * [`FieldTranslation()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L110-L128) - Dict-like container that maps language codes to a translated string.
  * [`TranslationField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L131-L261) - A field designed to hold translations for a given set of language codes.
  * [`TranslationFieldAdmin()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L410-L471) - Provides drop-in support for ModelAdmin classes that want to display TranslationFields
  * [`TranslationFormField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L63-L107) - Default form field for TranslationField.
  * [`TranslationSlugField()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L318-L407) - A unique translation slug field, useful in combination with TranslationField()
  * [`create_or_update_translation_callback()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L474-L507) - Callback for create_or_update2() for TranslationField, that will never remove existing translation.
  * [`expand_languages_codes()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L580-L600) - Build a complete list if language code with and without dialects.
  * [`get_user_priorities()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L603-L616) - Collect usable language codes the current user
  * [`make_unique()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L568-L577) - Flat args and remove duplicate entries while keeping the order intact.
  * [`merge_translations()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L521-L532) - Merge two FieldTranslation and ignore all empty/None values, e.g.:
  * [`remove_empty_translations()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L510-L518) - Remove all empty/None from a FieldTranslation, e.g.:
  * [`user_language_priorities()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L619-L627) - Returns the order in which to attempt resolving translations of a FieldTranslation model field.
  * [`validate_unique_translations()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/translation.py#L535-L565) - Deny creating non-unique translation: Creates ValidationError with change list search for doubled entries.



  Automatic local user timezone: https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/README.md




  * [`UserTimezoneAppConfig()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/apps.py#L4-L14) - Django app to set the user local time zone.



  * [`human_timezone_datetime()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/humanize.py#L7-L21) - Render a datetime with timezone information.



  * [`InvalidUserTimeZone()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/middleware.py#L11-L12) - Inappropriate argument value (of correct type).
  * [`UserTimezoneMiddleware()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/middleware.py#L34-L68) - Activate Timezone by "UserTimeZone" cookie
  * [`validate()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/middleware.py#L15-L31) - Validate the UserTimeZone cookie value.



  * [`humane_timezone_dt()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/user_timezone/templatetags/user_timezone.py#L9-L14) - Template filter to render a datetime with timezone information.



  * [`DetermineVersionCommand()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/version.py#L50-L78) - Write application version determined from git as a command



  * [`DynamicViewMenu()`](https://github.com/boxine/bx_django_utils/blob/master/bx_django_utils/view_utils/dynamic_menu_urls.py#L4-L45) - Simple storage for store information about views/urls to build a menu.

  [comment]: <> (✂✂✂ auto generated end ✂✂✂)



  To start developing e.g.:

  ```bash
  ~$ git clone https://github.com/boxine/bx_django_utils.git
  ~$ cd bx_django_utils
  ~/bx_django_utils$ make
  help                 List all commands
  install-poetry       install poetry
  install              install via poetry
  update               Update the dependencies as according to the pyproject.toml file
  lint                 Run code formatters and linter
  fix-code-style       Fix code formatting
  tox-listenvs         List all tox test environments
  tox                  Run unittests via tox with all environments
  test                 Run unittests
  publish              Release new version to PyPi
  docker-test          Run tests in docker
  makemessages         Make and compile locales message files
  start-dev-server     Start Django dev. server with the test project
  clean                Remove created files from the test project (e.g.: SQlite, static files)
  playwright-install   Install test browser for Playwright tests
  playwright-inspector Run Playwright inspector
  playwright-tests     Run only the Playwright tests
  ```

  You can start the test project with the Django developing server, e.g.:
  ```bash
  ~/bx_django_utils$ make start-dev-server
  ```
  This is a own manage command, that will create migrations files from our test app, migrate, collectstatic and create a super user if no user exists ;)

  If you like to start from stretch, just delete related test project files with:
  ```bash
  ~/bx_django_utils$ make clean
  ```
  ...and start the test server again ;)





  * Increase verion number in `bx_django_utils/__init__.py`
  * Create pull request
  * After merge, call: `make publish`




  [MIT](https://github.com/boxine/bx_django_utils/blob/master/LICENSE). Patches welcome!




  We’ve been rethinking the listening experience for kids and have created an ecosystem where haptic and listening experience are combined via smart technology - the Toniebox.

  We are constantly looking for engineers to join our team in different areas. If you’d be interested in contributing to our platform, have a look at: https://tonies.com/jobs/




  * https://pypi.org/project/bx-django-utils/


pkgId: ae0ec155311cd93db77d51624362c640c31a64df73a0d55ee89f2a8563104bb5
name: python-bx-py-utils
arch: src
version: 104
epoch: 0
release: 1
summary: Various Python utility functions
url: https://pypi.org/project/bx-py-utils/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bx-py-utils-104-1.src.rpm
checksum_type: sha256
description:
  Various Python utility functions

  [![tests](https://github.com/boxine/bx_py_utils/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/boxine/bx_py_utils/actions/workflows/tests.yml)
  [![codecov](https://codecov.io/github/boxine/bx_py_utils/branch/master/graph/badge.svg)](https://app.codecov.io/github/boxine/bx_py_utils)
  [![bx_py_utils @ PyPi](https://img.shields.io/pypi/v/bx_py_utils?label=bx_py_utils%20%40%20PyPi)](https://pypi.org/project/bx_py_utils/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/bx_py_utils)](https://github.com/boxine/bx_py_utils/blob/master/pyproject.toml)
  [![License MIT](https://img.shields.io/pypi/l/bx_py_utils)](https://github.com/boxine/bx_py_utils/blob/master/LICENSE)




  ```bash
  pip install bx_py_utils
  ```




  Here only a simple list about existing utilities.
  Please take a look into the sources and tests for deeper informations.


  [comment]: <> (✂✂✂ auto generated start ✂✂✂)



  * [`anonymize()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/anonymize.py#L17-L47) - Anonymize the given string with special handling for eMail addresses and the possibility to truncate the output.
  * [`anonymize_dict()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/anonymize.py#L50-L75) - Returns a new dict with anonymized values for keys containing one of the given keywords.



  * [`FnmatchExclude()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/auto_doc.py#L203-L212) - Helper for auto doc `exclude_func` that exclude files via fnmatch pattern.
  * [`assert_readme()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/auto_doc.py#L174-L200) - Check and update README file with generate_modules_doc()
  * [`assert_readme_block()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/auto_doc.py#L141-L171) - Check and update README file: Asset that "text_block" is present between the markers.
  * [`generate_modules_doc()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/auto_doc.py#L46-L138) - Generate a list of function/class information via pdoc.
  * [`get_code_location()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/auto_doc.py#L38-L43) - Return start and end line number for an object via inspect.



  * [`ClientSideCertManager()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/aws/client_side_cert_manager.py#L6-L72) - Helper to manage client-side TLS certificate via AWS Secrets Manager by



  * [`SecretsManager()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/aws/secret_manager.py#L4-L34) - Access AWS Secrets Manager values



  * [`removeprefix()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/compat.py#L1-L7) - Backport of `removeprefix` from PEP-616 (Python 3.9+)
  * [`removesuffix()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/compat.py#L10-L16) - Backport of `removesuffix` from PEP-616 (Python 3.9+)



  * [`dict_get()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/dict_utils.py#L8-L29) - nested dict `get()`
  * [`dict_list2markdown()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/dict_utils.py#L47-L77) - Convert a list of dictionaries into a markdown table.
  * [`pluck()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/dict_utils.py#L32-L44) - Extract values from a dict, if they are present



  Doc-Write, see: https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/doc_write/README.md




  * [`OverrideEnviron()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/environ.py#L31-L54) - Context manager to change 'os.environ' temporarily.
  * [`cgroup_memory_usage()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/environ.py#L12-L28) - Returns the memory usage of the cgroup the Python interpreter is running in.



  * [`print_exc_plus()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/error_handling.py#L14-L72) - Print traceback information with a listing of all the local variables in each frame.



  * [`EmptyFileError()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/file_utils.py#L18-L21) - Will be raised from get_and_assert_file_size() if a 0-bytes file was found.
  * [`FileError()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/file_utils.py#L12-L15) - Base error class for all 'file_utils' exceptions.
  * [`FileHasher()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/file_utils.py#L79-L104) - Context Manager for generate different hashes from file content while processing a file.
  * [`FileSizeError()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/file_utils.py#L24-L38) - File size is not the same as the expected size.
  * [`NamedTemporaryFile2()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/file_utils.py#L53-L76) - Generates a temp file with the given filename **without** any random name sequence.
  * [`OverlongFilenameError()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/file_utils.py#L188-L191) - cut_filename() error: The file name can not be shortened, because sterm is to short.
  * [`TempFileHasher()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/file_utils.py#L107-L178) - File like context manager that combines NamedTemporaryFile2 and FileHasher.
  * [`cut_filename()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/file_utils.py#L194-L234) - Short the file name (and keep the last suffix). Raise OverlongFilenameError if it can't fit.
  * [`get_and_assert_file_size()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/file_utils.py#L41-L50) - Check file size of given file object. Raise EmptyFileError for empty files or return size
  * [`safe_filename()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/file_utils.py#L181-L185) - Makes an arbitrary input suitable to be used as a filename.



  * [`filename_matcher()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/filename_matcher.py#L6-L25) - Enhance fnmatch that accept a list of patterns.



  * [`introspection_query()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/graphql_introspection.py#L5-L25) - Generate GraphQL introspection query with variable nested depth.



  * [`url_safe_encode()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/hash_utils.py#L13-L22) - Encode bytes into a URL safe string.
  * [`url_safe_hash()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/hash_utils.py#L25-L46) - Generate a URL safe hash with `max_size` from given string/bytes.



  * [`ElementsNotFoundError()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/html_utils.py#L44-L48) - Happens if requested HTML elements cannot be found
  * [`InvalidHtml()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/html_utils.py#L18-L41) - XMLSyntaxError with better error messages: used in validate_html()
  * [`get_html_elements()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/html_utils.py#L95-L106) - Returns the selected HTML elements as string
  * [`pretty_format_html()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/html_utils.py#L87-L92) - Pretty format given HTML document via BeautifulSoup (Needs 'beautifulsoup4' package)
  * [`validate_html()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/html_utils.py#L51-L73) - Validate a HTML document via XMLParser (Needs 'lxml' package)



  * [`pformat()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/humanize/pformat.py#L5-L16) - Format given object: Try JSON fist and fallback to pformat()



  * [`human_timedelta()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/humanize/time.py#L14-L52) - Converts a time duration into a friendly text representation.



  * [`import_string()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/import_utils.py#L18-L31) - Import a dotted module path and return the attribute/class designated by the last name in the path.



  * [`chunk_iterable()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/iteration.py#L4-L21) - Returns a generator that yields slices of iterable of the given `chunk_size`.



  * [`ChangeCurrentWorkDir()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/path.py#L57-L72) - Context Manager change the "CWD" to an other directory.
  * [`MockCurrentWorkDir()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/path.py#L75-L94) - Context Manager to move the "CWD" to a temp directory.
  * [`assert_is_dir()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/path.py#L7-L15) - Check if given path is a directory
  * [`assert_is_file()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/path.py#L18-L28) - Check if given path is a file



  * [`processify()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/processify.py#L12-L53) - Decorator to run a function as a process.



  * [`get_pyproject_config()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/pyproject_toml.py#L17-L41) - Get a config section from "pyproject.toml". The path can be optional specify.



  * [`rison_dumps()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/rison.py#L4-L31) - Encode as RISON, a URL-safe encoding format.



  * [`FrameNotFound()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/stack_info.py#L8-L13) - Base class for lookup errors.
  * [`last_frame_outside_path()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/stack_info.py#L16-L44) - Returns the stack frame that is the direct successor of given "file_path".



  * [`compare_sentences()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/string_utils.py#L68-L89) - Calculates the Levenshtein distance between text1 and text2. With filter functionality.
  * [`ensure_lf()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/string_utils.py#L130-L140) - Replace line endings to unix-style.
  * [`get_words()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/string_utils.py#L41-L65) - Extract words from a text. With filter functionality.
  * [`is_uuid()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/string_utils.py#L105-L127) - Returns True if text is a valid UUID (https://www.rfc-editor.org/rfc/rfc9562#name-uuid-format).
  * [`levenshtein_distance()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/string_utils.py#L9-L38) - Calculates the Levenshtein distance between two strings.
  * [`startswith_prefixes()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/string_utils.py#L143-L159) - >>> startswith_prefixes('foobar', prefixes=('foo','bar'))
  * [`truncate()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/string_utils.py#L162-L187) - Truncates the given string to the given length
  * [`uuid_from_text()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/string_utils.py#L92-L102) - Generate a UUID instance from the given text in a determinism may via SHA224 hash.



  * [`assert_equal()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/assertion.py#L64-L77) - Check if the two objects are the same. Display a nice diff, using `pformat()`
  * [`assert_text_equal()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/assertion.py#L80-L95) - Check if the two text strings are the same. Display an error message with a diff.
  * [`pformat_ndiff()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/assertion.py#L16-L26) - Generate a `ndiff` from two objects, using `pformat()`
  * [`pformat_unified_diff()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/assertion.py#L47-L61) - Generate a unified diff from two objects, using `pformat()`
  * [`text_ndiff()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/assertion.py#L8-L13) - Generate a `ndiff` between two text strings.
  * [`text_unified_diff()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/assertion.py#L40-L44) - Generate a unified diff between two text strings.



  * [`MassContextManager()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/context_managers.py#L4-L25) - A context manager / decorator that enter/exit a list of mocks.



  * [`parse_dt()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/datetime.py#L4-L15) - Helper for easy generate a `datetime` instance via string.



  * [`DenyAnyRealRequestContextManager()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/deny_requests.py#L24-L38) - Context manager that denies any request via docket/urllib3. Will raise DenyCallError.
  * [`deny_any_real_request()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/deny_requests.py#L41-L50) - Deny any request via docket/urllib3. Useful for tests, because they should mock all requests.



  * [`FileWatcher()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/filesystem_utils.py#L6-L49) - Helper to record which new files have been created.



  * [`NoLogs()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/log_utils.py#L14-L31) - Context manager to Suppress all logger outputs
  * [`RaiseLogUsage()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/log_utils.py#L4-L11) - A log handler, that raise an error on every log output.



  * [`SecretsManagerMock()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/mock_aws_secret_manager.py#L1-L16) - Mock for `bx_py_utils.aws.secret_manager.SecretsManager()`



  * [`MockedBoto3Session()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/mock_boto3session.py#L4-L46) - Mock for `boto3.session.Session()`



  * [`MockUUIDGenerator()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/mock_uuid.py#L5-L25) - Helper to mock `uuid.uuid4()` with reproducible results (e.g. for snapshot tests)



  A simple mock for Boto3's S3 modules.

  * [`PseudoS3Client()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/mocks3.py#L61-L258) - Simulates a boto3 S3 client object in tests



  * [`RedirectOut()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/redirect.py#L7-L34) - Redirect stdout + stderr into a buffer (with optional strip the output)



  * [`assert_json_requests_mock()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/requests_mock_assertion.py#L29-L44) - Check the requests mock history. In this case all requests must be JSON.
  * [`assert_json_requests_mock_snapshot()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/requests_mock_assertion.py#L47-L54) - Check requests mock history via snapshot. Accepts only JSON requests.
  * [`assert_requests_mock()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/requests_mock_assertion.py#L57-L77) - Check the requests mock history. Accept mixed "text" and "JSON".
  * [`assert_requests_mock_snapshot()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/requests_mock_assertion.py#L80-L85) - Check requests mock history via snapshot. Accept mixed "text" and "JSON".



  Assert complex output via auto updated snapshot files with nice diff error messages.

  * [`SnapshotChanged()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/snapshot.py#L50-L51) - Assertion failed.
  * [`assert_binary_snapshot()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/snapshot.py#L366-L407) - Assert binary data via snapshot file
  * [`assert_html_snapshot()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/snapshot.py#L301-L350) - Assert "html" string via snapshot file with validate and pretty format
  * [`assert_py_snapshot()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/snapshot.py#L252-L298) - Assert complex python objects vio PrettyPrinter() snapshot file.
  * [`assert_snapshot()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/snapshot.py#L202-L249) - Assert given data serialized to JSON snapshot file.
  * [`assert_text_snapshot()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/snapshot.py#L154-L199) - Assert "text" string via snapshot file
  * [`get_snapshot_file()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/snapshot.py#L124-L151) - Generate a file path use stack information to fill not provided path components.



  * [`MockTimeMonotonicGenerator()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/time.py#L1-L19) - Helper to mock `time.monotonic()` in tests.



  * [`BaseDocTests()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/unittest_utils.py#L40-L91) - Helper to include all doctests in unittests, without change unittest setup. Just add a normal TestCase.
  * [`assert_no_flat_tests_functions()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/unittest_utils.py#L16-L30) - Check if there exists normal test functions (That will not be executed by normal unittests)



  * [`FreezeXlsxTimes()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/xlsx.py#L84-L97) - Context manager / decorator intended to freeze timestamps of xlsx files creation by e.g.: openpyxl.
  * [`generate_xlsx_md_snapshot()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/xlsx.py#L68-L81) - Generate a markdown snapshot of a XLSX: Display ZIP info + Sheets content as Markdown.
  * [`xlsx2dict()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/xlsx.py#L27-L51) - Convert a XLSX file content into a dictionary: Every sheet is a key, and the value is a list of dictionaries.
  * [`xlsx2markdown()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/xlsx.py#L54-L65) - Convert all Sheets of a XLSX into markdown tables.



  * [`FreezeZipFileDatetime()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/zip_file_utils.py#L15-L30) - Context manager / decorator to freezes the modification time of files written to a zip file.
  * [`zip_info()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/zip_file_utils.py#L44-L68) - Generates similar information than `unzip -v`: Yields ZipFileInfo for each file in the zip file.
  * [`zip_info_markdown()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/test_utils/zip_file_utils.py#L71-L75) - Generates a markdown representation of the zip file content. Similar to `unzip -v` output.



  * [`cutout()`](https://github.com/boxine/bx_py_utils/blob/master/bx_py_utils/text_tools.py#L1-L36) - Mark a point in a long text by line no + column with context lines around.

  [comment]: <> (✂✂✂ auto generated end ✂✂✂)




  Quick hint about snapshot. If you have many snapshots in your project and you need to change many with a code change, then you can run the tests without a snapshot change leading to an error, by set `RAISE_SNAPSHOT_ERRORS=0` in your environment.

  e.g.:

  ```bash
  RAISE_SNAPSHOT_ERRORS=0 python3 -m unittest
  ```

  Renew all snapshot files with:
  ```bash
  make update-test-snapshot-files
  ```





  We split `bx_py_utils` and moved all Django related utilities into the separated project:

  * https://github.com/boxine/bx_django_utils

  So, `bx_py_utils` is better usable in non-Django projects, because Django will not installed as decency of "bx_py_utils"




  To start developing e.g.:

  ```bash
  ~$ git clone https://github.com/boxine/bx_py_utils.git
  ~$ cd bx_py_utils
  ~/bx_py_utils$ make
  help                       List all commands
  install-base-req           Install needed base packages via apt
  install                    Install the project in a Python virtualenv
  update-requirements        Update requirements
  lint                       Run code formatters and linter
  fix-code-style             Fix code formatting
  tox-listenvs               List all tox test environments
  tox                        Run tests via tox with all environments
  test                       Run tests
  coverage                   Run tests with coverage
  update-test-snapshot-files Update all snapshot files (by remove and recreate all snapshot files)
  mypy                       Run mypy
  safety                     Run https://github.com/pyupio/safety
  publish                    Release new version to PyPi
  clean                      Remove created files from the test project
  ```




  * Increase verion number in `bx_py_utils/__init__.py`
  * Create pull request
  * After merge, call: `make publish`




  [MIT](https://github.com/boxine/bx_py_utils/blob/master/LICENSE). Patches welcome!



  We’ve been rethinking the listening experience for kids and have created an ecosystem where haptic and listening experience are combined via smart technology - the Toniebox.

  We are constantly looking for engineers to join our team in different areas. If you’d be interested in contributing to our platform, have a look at: https://tonies.com/jobs/



  * https://pypi.org/project/bx-py-utils/


