# packages

pkgId: 3ed23dc488b5d50010f494ad31a72450d7778f718225a8141274f2dc37f61606
name: python-fastled-help
arch: noarch
version: 1.1.61
epoch: 0
release: 1
summary: Development documents and examples for fastled
url: https://github.com/zackees/fastled-wasm
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fastled-1.1.61-1.src.rpm
location_href: Packages/python-fastled-help-1.1.61-1.noarch.rpm
checksum_type: sha256
description:
  Compiles an Arduino/Platformio sketch into a wasm binary that can be run directly in the web browser.


  [![Linting](https://github.com/zackees/fastled-wasm/actions/workflows/lint.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/lint.yml)
  [![MacOS_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_macos.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_macos.yml)
  [![Ubuntu_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_ubuntu.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_ubuntu.yml)
  [![Win_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_win.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_win.yml)

  [![Build and Push Multi Docker Image](https://github.com/zackees/fastled-wasm/actions/workflows/build_multi_docker_image.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/build_multi_docker_image.yml)
  [![Build Executables](https://github.com/zackees/fastled-wasm/actions/workflows/test_build_exe.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_build_exe.yml)
  [![Publish Release](https://github.com/zackees/fastled-wasm/actions/workflows/publish_release.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/publish_release.yml)




  This python app will compile your FastLED style sketches into html/js/wasm output that runs directly in the browser.

  Compile times are extremely fast, thanks to aggressive object caching for C++ and sketch fingerprinting with a zip file cache. Recompilation of sketch files with minimal changes will occure in less than a second.

  By default the web compiler will always be used unless that user specifies `--local`, in which case this compiler will invoke docker to bring in a runtime necessary to run the compiler toolchain.

  The local compiler will be much faster than the web version in most circumstances after the first compile. The web compiler
  has the advantage that as a persistant service the compile cache will remain much more up to date.


  https://github.com/user-attachments/assets/64ae0e6c-5f8b-4830-ab87-dcc25bc61218



  https://zackees.github.io/fastled-wasm/




  ```bash
  pip install fastled
  ```

  **Note that you may need to install x86 docker emulation on Mac-m1 and later, as this is an x86 only image at the prsent.**



  Change to the directory where the sketch lives and run, will run the compilation
  on the web compiler.

  ```bash


  cd <SKETCH-DIRECTORY>
  fastled
  ```

  Forces the local server to to spawn in order to run to do the compile.

  ```bash
  cd <SKETCH-DIRECTORY>
  fastled --local  # if server doesn't already exist, one is created.
  ```

  You can also spawn a server in one process and then access it in another, like this:

  ```bash
  fastled --server  # server will now run in the background.

  fastled examples/wasm --local  # local will find the local server and use it to do the compile.
  ```

  After compilation a web browser windows will pop up. Changes to the sketch will automatically trigger a recompilation.



  **Compiling through the api**
  ```python

  from fastapi import Api, CompileResult

  out: CompileResult = Api.web_compile("path/to/sketch")
  print(out.success)
  print(out.stdout)

  ```

  **Launching a compile server**
  ```python

  from fastapi import Api, CompileServer

  server: CompileServer = Api.spawn_server()
  print(f"Local server running at {server.url()}")
  server.web_compile("path/to/sketch")  # output will be "path/to/sketch/fastled_js"
  server.stop()
  ```

  **Launching a server in a scope**
  ```python

  from fastapi import Api


  with Api.server() as server:
      server.web_compile("path/to/sketch")

  ```

  **Initializing a project example from the web compiler**
  ```python

  from fastapi import Api

  examples = Api.get_examples()
  print(f"Print available examples: {examples}")
  Api.project_init(examples[0])


  ```

  **Initializing a project example from the CompileServer**
  ```python

  from fastapi import Api

  with Api.server() as server:
      examples = server.get_examples()
      server.project_init(examples[0])

  ```

  **LiveClient will auto-trigger a build on code changes, just like the cli does**
  ```python


  from fastapi import Api, LiveClient
  client: LiveClient = Api.live_client(
      "path/to/sketch_directory",
  )


  client.stop()
  ```

  **LiveClient with local CompileServer**
  ```python


  from fastapi import Api, LiveClient

  with Api.server() as server:
      client: LiveClient = Api.live_client(
          "path/to/sketch_directory",
          host=server
      )
      
      
      client.stop()
  ```





  Once launched, the compiler will remain open, listening to changes and recompiling as necessary, hot-reloading the sketch into the current browser.

  This style of development should be familiar to those doing web development.



  If you launch `fastled` in the FastLED repo then this tool will automatically detect this and map the src directory into the
  host container. Whenever there are changes in the source code from the mapped directory, then these will be re-compiled
  on the next change or if you hit the space bar when prompted. Unlike a sketch folder, a re-compile on the FastLED src
  can be much longer, for example, if you modify a header file.



  Huge blobs of data like video will absolutely kill the compile performance as these blobs would normally have to be shuffled
  back and forth. Therefore a special directory `data/` is implicitly used to hold this blob data. Any data in this directory
  will be replaced with a stub containing the size and hash of the file during upload. On download, these stubs are swapped back
  with their originals during decompression.

  The wasm compiler will recognize all files in the `data/` directory and generate a `files.json` manifest which can be used
  in your wasm sketch using an emulated SD card system mounted at `/data/` on the SD Card. In order to increase load speed, these
  files will be asynchronously streamed into the running sketch instance during runtime. Files named with *.json, *.csv, *.txt will be
  immediately injected in the app before setup() is called and can be used immediately in setup() in their entirety.

  All other files will be streamed in. The `Video` element in FastLED is designed to gracefully handle missing data streamed in through
  the file system.

  For an example of how to use this see `examples/SdCard` which is fully wasm compatible.



  There are three compile settings available to the user. The default is `--quick`. Aggressive optimizations are done with `--release` which will optimize for size, although the speed difference between `--release` and `--quick` seems negligible. But `--release` will produce a ~1/3 smaller binary. There is also `--debug`, which will include symbols necessary for debugging and getting the C++ function symbols working correctly in the browser during step-through debugging. In my personal tests it works better than expected, but don't expect to have gdb or msvc debugger level of the debugging experience.

  We use `ccache` to cache object files. This seems actually help a lot and is better than Platformio's method of tracking what needs to be rebuilt. This works as a two-tier cache system. What Platformio misses will be covered by ccache's more advanced file changing system.

  The compilation to wasm will happen under a lock. Removing this lock requires removing the Platformio toolchain as the compiler backend which enforces its own internal lock preventing parallel use.



  Sketches are aggressively fingerprinted and stored in a cache. White space, comments, and other superficial data will be stripped out during pre-processing and minimization for fingerprinting. This source file decimation is only used for finger
  printing while the actual source files are sent to the compiler to preserve line numbers and file names.

  This pre-processing done is done via gcc and special regex's and will happen without a lock. This will allow you to have extremely quick recompiles for whitespace and changes in comments.



  If the web compiler gets congested then it's recommended that you run the compiler locally. This requires docker and will be invoked whenever you pass in `--local`. This will first pull the most recent Docker image of the Fastled compiler, launch a webserver, and then connect to it with the client once it's been up.



  In server mode, the git repository will be cloned as a side repo and then periodically updated and rsync'd to the src directory. This allows a long-running instance to stay updated.



  The compatibility is pretty good. Most simple sketches should compile out of the box. Even some of the AVR platforms are stubbed out to make it work. For Arduino, the familiar `digitalWrite()`, `Serial.println()`, and other common functions work. Although `digitalRead()` will always return 0 and `analogRead()` will return random numbers.



  Q: How often is the docker image updated?
  A: It's scheduled for rebuild once a day at 3am Pacific time, and also on every change to this repo.

  Q: How can I run my own cloud instance of the FastLED wasm compiler?
  A: Render.com (which fastled is hosted on) or DigialOcean can accept a GitHub repo and auto-build the docker image.

  Q: Why does FastLED tend to become choppy when the browser is in the background?
  A: FastLED Wasm currently runs on the main thread and therefor Chrome will begin throttling the event loop when the browser is not in the foreground. The solution to this is to move FastLED to a web worker where it will get a background thread that Chrome / Firefox won't throttle.

  Q: Why does a long `delay()` cause the browser to freeze and become sluggish?
  A: `delay()` will block `loop()` which blocks the main thread of the browser. The solution is a webworker which will not affect the main thread performance of the browser.


  Q: How can I get the compiled size of my FastLED sketch smaller?
  A: A big chunk of space is being used by unnecessary javascript `emscripten` bundling. The wasm_compiler_settings.py file in the FastLED repo can tweak this.



    * 1.1.61 - Excluded non compiling examples from the Test object as part of the api - no sense in having them if they won't compile.
    * 1.1.60 - Platform executables (macos-arm/macos-x86/windows/linux-x86) now auto building with each release. Add tests.
    * 1.1.52 - Add linux-arm
    * 1.1.49 - Try again.
    * 1.1.46 - Add mac x86 exe
    * 1.1.45 - Another try for web publishing from github.
    * 1.1.42 - Second test for web publishing from github.
    * 1.1.41 - Platform executable (through pyinstaller) now enabled.
    * 1.1.40 - Remove `sketch_directory` from Api object. This was only needed before we had a client/server architecture.
    * 1.1.39 - Added `LiveClient`, `fastled.Api.live_server()` will spawn it. Allows user to have a live compiling client that re-triggers a compile on file changes.
    * 1.1.38 - Cleanup the `fastled.Api` object and streamline for general use.
    * 1.1.37 - `Test.test_examples()` is now unit tested to work correctly.
    * 1.1.36 - We now have an api. `from fastled import Api` and `from fastled import Test` for testing.
    * 1.1.35 - When searching for files cap the limit at a high amount to prevent hang.
    * 1.1.34 - On windows check to make sure we are in linux container mode, if not try to switch and if that fails then use `--web` compiler.
    * 1.1.33 - Auto updating frequency has been reduced from one hour to one day. To update immediatly use `--update`.
    * 1.1.32 - `--init` now asks for which example you want, then tells you where the example was downloaded to. No longer auto-compiles.
    * 1.1.31 - `--local` is auto-enabled if docker is installed, use `--web` to force web compiler. Updating is much more pretty.
    * 1.1.30 - Added `--init` to initialize a demo project.
    * 1.1.29 - Remove annoying dbg messages i left in.
    * 1.1.28 - Adds cache control headers to the live server to disable all caching in the live browser.
    * 1.1.27 - Fixed `--interactive` so that it now works correctly.
    * 1.1.25 - Improved detecting which sketch directory the user means by fuzzy matching.
    * 1.1.24 - Adds progress spinning bar for pulling images, which take a long time.
    * 1.1.23 - Various fixes for MacOS
    * 1.1.22 - Selecting sketch now allows strings and narrowing down paths if ambiguity
    * 1.1.21 - Now always watches for space/enter key events to trigger a recompile.
    * 1.1.20 - Fixed a regression for 1.1.16 involving docker throwing an exception before DockerManager.is_running() could be called so it can be launched.
    * 1.1.19 - Automatically does a limit searches for sketch directories if you leave it blank.
    * 1.1.18 - Fixes for when the image has never been downloaded.
    * 1.1.17 - Added `--update` and `--no-auto-update` to control whether the compiler in docker mode will try to update.
    * 1.1.16 - Rewrote docker logic to use container suspension and resumption. Much much faster.
    * 1.1.15 - Fixed logic for considering ipv6 addresses. Auto selection of ipv6 is now restored.
    * 1.1.14 - Fixes for regression in using --server and --localhost as two instances, this is now under test.
    * 1.1.13 - Disable the use of ipv6. It produces random timeouts on the onrender server we are using for the web compiler.
    * 1.1.12 - By default, fastled will default to the web compiler. `--localhost` to either attach to an existing server launched with `--server` or else one will be created automatically and launched.
    * 1.1.11 - Dev improvement: FastLED src code volume mapped into docker will just in time update without having to manually trigger it.
    * 1.1.10 - Swap large assets with embedded placeholders. This helps video sketches upload and compile instantly. Assets are re-added on after compile artifacts are returned.
    * 1.1.9 - Remove auto server and instead tell the user corrective action to take.
    * 1.1.8 - Program now knows it's own version which will be displayed with help file. Use `--version` to get it directly.
    * 1.1.7 - Sketch cache re-enabled, but selectively invalidated on cpp/h updates. Cleaned up deprecated args. Fixed double thread running for containers that was causing slowdown.
    * 1.1.6 - Use the fast src volume map allow quick updates to fastled when developing on the source code.
    * 1.1.5 - Filter out hidden files and directories from being included in the sketch archive sent to the compiler.
    * 1.1.4 - Fix regression introduced by testing out ipv4/ipv6 connections from a thread pool.
    * 1.1.3 - Live editing of *.h and *.cpp files is now possible. Sketch cache will be disabled in this mode.
    * 1.1.2 - `--server` will now volume map fastled src directory if it detects this. This was also implemented on the docker side.
    * 1.1.1 - `--interactive` is now supported to debug the container. Volume maps and better compatibilty with ipv4/v6 by concurrent connection finding.
    * 1.1.0 - Use `fastled` as the command for the wasm compiler.
    * 1.0.17 - Pulls updates when necessary. Removed dependency on keyring.
    * 1.0.16 - `fastled-wasm` package name has been changed to `fled`
    * 1.0.15 - `fled` is an alias of `fastled-wasm` and will eventually replace it. `--web-host` was folded into `--web`, which if unspecified will attempt to run a local docker server and fallback to the cloud server if that fails. Specifying `--web` with no arguments will default to the cloud server while an argument (like `localhost`) will cause it to bind to that already running server for compilation.
    * 1.0.14 - For non significant changes (comments, whitespace) in C++/ino/*.h files, compilation is skipped. This significantly reduces load on the server and prevents unnecessary local client browser refreshes.
    * 1.0.13 - Increase speed of local compiles by running the server version of the compiler so it can keep it's cache and not have to pay docker startup costs because now it's a persistant server until exit.
    * 1.0.12 - Added suppport for compile modes. Pass in `--release`, `--quick`, `--debug` for different compile options. We also support `--profile` to profile the build process.
    * 1.0.11 - `--web` compile will automatically be enabled if the local build using docker fails.
    * 1.0.10 - Watching files is now available for `--web`
    * 1.0.9 - Enabled web compile. Access it with `--web` or `--web-host`
    * 1.0.8 - Allow more than one fastled-wasm browser instances to co-exist by searching for unused ports after 8081.
    * 1.0.7 - Docker multi image build implemented, tool now points to new docker image compile.
    * 1.0.6 - Removed `--no-open` and `--watch`, `--watch` is now assumed unless `--just-compile` is used.
    * 1.0.5 - Implemented `--update` to update the compiler image from the docker registry.
    * 1.0.4 - Implemented `--watch` which will watch for changes and then re-launch the compilation step.
    * 1.0.3 - Integrated `live-server` to launch when available.
    * 1.0.2 - Small bug with new installs.
    * 1.0.1 - Re-use is no longer the default, due to problems.
    * 1.0.0 - Initial release.


pkgId: f1e814fb05867da28bedfe02910a34eed5fd224d7cefdb2085f8ee4df3cf27e4
name: python-fastnumbers-debuginfo
arch: aarch64
version: 5.1.1
epoch: 0
release: 1
summary: Debug information for package python-fastnumbers
url: https://github.com/SethMMorton/fastnumbers
rpm_license: MIT
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-fastnumbers-5.1.1-1.src.rpm
location_href: Packages/python-fastnumbers-debuginfo-5.1.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-fastnumbers.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 3285e6c7b5881ef8fd01cfb4c7d0c852c15c6bbb3635bb2760a64ea759347612
name: python-fastnumbers-debugsource
arch: aarch64
version: 5.1.1
epoch: 0
release: 1
summary: Debug sources for package python-fastnumbers
url: https://github.com/SethMMorton/fastnumbers
rpm_license: MIT
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-fastnumbers-5.1.1-1.src.rpm
location_href: Packages/python-fastnumbers-debugsource-5.1.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-fastnumbers.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 90d8cae4a472b01594478ff8d240d45d12765ea73af2c03b6bbcc0916c551c4d
name: python-fastnumbers-help
arch: aarch64
version: 5.1.1
epoch: 0
release: 1
summary: Development documents and examples for fastnumbers
url: https://github.com/SethMMorton/fastnumbers
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fastnumbers-5.1.1-1.src.rpm
location_href: Packages/python-fastnumbers-help-5.1.1-1.aarch64.rpm
checksum_type: sha256
description:
  Super-fast and clean conversions to numbers.
      - Source Code: https://github.com/SethMMorton/fastnumbers
      - Downloads: https://pypi.org/project/fastnumbers/
      - Documentation: https://fastnumbers.readthedocs.io/
      - `Quick Start`_
      - `Timing`_
      - `High-level Algorithm`_
      - `How To Run Tests`_
      - `History`_
  ``fastnumbers`` is a module with the following three objectives (in order
  of decreasing importance as to why the module was created):
      
         ``int`` and ``float`` and provides easy, concise, powerful, fast
         and flexible error handling.
      
         an input *could* be converted to *int* or *float*.
      
         ``float`` that are on par or faster with the Python equivalents
         (see the `Timing`_ section for details). These functions
         should behave *identically* to the Python built-ins except for a few
         specific corner-cases as mentioned in the
         `API documentation for those functions <https://fastnumbers.readthedocs.io/en/stable/api.html#the-built-in-replacement-functions>`_.
         - **PLEASE** read the quick start for these functions to fully
           understand the caveats before using them.
  **What kind of speedups can you expect?** Here are some highlights, but please
  see the `Timing`_ section for the raw data if you want details.
      - Up to 2x faster conversion of strings to integers than the built-in
        ``int()`` function
      - Up to 5x faster conversion of strings to floats than the built-in
        ``float()`` function (possibly greater for very long strings)
      - Up to 10x faster handling of errors during conversion than using
        user-side error handling
      - On top of the above, operations to convert a list of strings
        (with the ``map`` option or ``try_array`` function) is 2x faster
        than the equivalent list comprehension.
  **NOTICE**: As of ``fastnumbers`` version 4.0.0, only Python >= 3.7 is
  supported.
  **NOTICE**: As of ``fastnumbers`` version 4.0.0, the functions ``fast_real``,
  ``fast_float``, ``fast_int``, ``fast_forceint``, ``isreal``, ``isfloat``,
  ``isint``, and ``isintlike`` have been deprecated and are replaced with
  ``try_real``, ``try_float``, ``try_int``, ``try_forceint``, ``check_real``,
  ``check_float``, ``check_int``, and ``check_intlike``, respectively. These
  new functions have more flexible APIs and have names that better reflect
  the intent of the functions. The old functions can still be used (they will
  *never* be removed from ``fastnumbers``), but the new ones should be
  preferred for new development.
  **NOTICE**: As of ``fastnumbers`` version 4.0.0, ``query_type`` now sets
  ``allow_underscores`` to ``False`` by default instead of ``True``.


pkgId: 9374a188f78606c2af8f4453062e25e136e60643f4207edfc39cf4155f6a93a1
name: python-fastrlock-debuginfo
arch: aarch64
version: 0.8.3
epoch: 0
release: 1
summary: Debug information for package python-fastrlock
url: https://github.com/scoder/fastrlock
rpm_license: MIT style
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-fastrlock-0.8.3-1.src.rpm
location_href: Packages/python-fastrlock-debuginfo-0.8.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-fastrlock.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 3a98c9cc1aa00eae76bf1d3dad7dc9b3b1c92480dc45310cc2d27151e8db6bc3
name: python-fastrlock-debugsource
arch: aarch64
version: 0.8.3
epoch: 0
release: 1
summary: Debug sources for package python-fastrlock
url: https://github.com/scoder/fastrlock
rpm_license: MIT style
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-fastrlock-0.8.3-1.src.rpm
location_href: Packages/python-fastrlock-debugsource-0.8.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-fastrlock.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 6521a51af41006076364ed2d9875ef155574cad02d651f4bc7ad8d6c02a78e35
name: python-fastrlock-help
arch: aarch64
version: 0.8.3
epoch: 0
release: 1
summary: Development documents and examples for fastrlock
url: https://github.com/scoder/fastrlock
rpm_license: MIT style
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fastrlock-0.8.3-1.src.rpm
location_href: Packages/python-fastrlock-help-0.8.3-1.aarch64.rpm
checksum_type: sha256
description:
  This is a C-level implementation of a fast, re-entrant, optimistic lock for CPython.
  It is a drop-in replacement for
  `threading.RLock <https://docs.python.org/3/library/threading.html#threading.RLock>`_.
  FastRLock is implemented in `Cython <https://cython.org>`_ and also provides a C-API
  for direct use from Cython code via ``from fastrlock cimport rlock`` or
  ``from cython.cimports.fastrlock import rlock``.
  Under normal conditions, it is about 10x faster than ``threading.RLock`` in Python 2.7
  because it avoids all locking unless two or more threads try to acquire it at the
  same time.  Under congestion, it is still about 10% faster than RLock due to being
  implemented in Cython.
  This is mostly equivalent to the revised RLock implementation in Python 3.2,
  but still faster due to being implemented in Cython.  However, in Python 3.4 and
  later, the ``threading.RLock`` implementation in the stdlib tends to be as fast
  or even faster than the lock provided by this package, when called through the
  Python API.  ``FastRLock`` is still faster also on these systems when called
  through its Cython API from other Cython modules.
  It was initially published as a code recipe here:
  https://code.activestate.com/recipes/577336-fast-re-entrant-optimistic-lock-implemented-in-cyt/
  FastRLock has been used and tested in `Lupa <https://github.com/scoder/lupa>`_ for several years.


pkgId: 2ab480a796ce020c056b806c2ffc24dc2b6aaf7d46ab06aa37d293f56a2a96d1
name: python-fasttenet-help
arch: noarch
version: 0.1.15
epoch: 0
release: 1
summary: Development documents and examples for fasttenet
url: http://github.com/cxinsys/fasttenet
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fasttenet-0.1.15-1.src.rpm
location_href: Packages/python-fasttenet-help-0.1.15-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center"><img src="assets/logo.png" alt="Drawing" width="395px"/></p>



  - FastTENET is an accelerated [TENET](https://github.com/neocaleb/TENET) algorithm based on manycore computing.


  - :snake: [Anaconda](https://www.anaconda.com) is recommended to use and develop FastTENET.
  - :penguin: Linux distros are tested and recommended to use and develop FastTENET.



  After installing anaconda, create a conda virtual environment for FastTENET.
  In the following command, you can change the Python version
  (e.g.,`python=3.7` or `python=3.9`).

  ```
  conda create -n fasttenet python=3.9
  ```

  Now, we can activate our virtual environment for FastTENET as follows.

  ```
  conda activate fasttenet
  ```
  <br>



  ```
  pip install fasttenet
  ```
  - **Default backend framework of the FastTENET is PyTorch Lightning.**
  - **You need to install other backend frameworks such as CuPy, Jax, and TensorFlow**

  <br>




  [//]: # (**You must install [MATE]&#40;https://github.com/cxinsys/mate&#41; before installing FastTENET**)

  First, clone the recent version of this repository.

  ```
  git clone https://github.com/cxinsys/fasttenet.git
  ```


  Now, we need to install FastTENET as a module.

  ```
  cd fasttenet
  pip install -e .
  ```


  - **Default backend framework of the FastTENET is PyTorch Lightning.**

  <br>



  FastTENET supports several backend frameworks including CuPy, JAX, TensorFlow, PyTorch and PyTorch-Lightning. \
  To use frameworks, you need to install the framework manually

  <br>

  - **PyTorch Lightning**

  PyTorch Lightning is a required dependency library for FastTENET and is installed automatically when you install FastTENET.\
  If the library is not installed, you can install it manually via pip.

  ```angular2html
  python -m pip install lightning
  ```
  <br>

  - **PyTorch**: [Installing custom PyTorch version](https://pytorch.org/get-started/locally/#start-locally)

  PyTorch is a required dependency library for FastTENET and is installed automatically when you install FastTENET.\
  If the library is not installed, you can install it manually.

  ```angular2html
  conda install pytorch torchvision torchaudio pytorch-cuda=xx.x -c pytorch -c nvidia (check your CUDA version)
  ```
  <br>

  - **CuPy**: [Installing CuPy from Conda-Forge with cudatoolkit](https://docs.cupy.dev/en/stable/install.html#installing-cupy-from-conda-forge)

  Install Cupy from Conda-Forge with cudatoolkit supported by your driver
  ```angular2html
  conda install -c conda-forge cupy cuda-version=xx.x (check your CUDA version)
  ```
  <br>

  - **JAX**: [Installing JAX refer to the installation guide in the project README](https://github.com/google/jax#installation)

  [//]: # (**You must first install [CUDA]&#40;https://developer.nvidia.com/cuda-downloads&#41; and [CuDNN]&#40;https://developer.nvidia.com/cudnn&#41; before installing JAX**)

  [//]: # ()
  [//]: # (After install CUDA and CuDNN you can specify a particular CUDA and CuDNN version for jax explicitly)
  Install JAX with CUDA > 12.x
  ```angular2html
  pip install -U "jax[cuda12]"
  ```

  [//]: # (JAX preallocate 90% of the totla GPU memory when the first JAX operation is run \)
  Use 'XLA_PYTHON_CLIENT_PREALLOCATE=false' to disables the preallocation behavior\
  (https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html)

  <br>

  - **TensorFlow**: [Installing TensorFlow refer to the installation guide](https://www.tensorflow.org/install/pip?hl=en#linux)

  [//]: # (**You must first install [CUDA]&#40;https://developer.nvidia.com/cuda-downloads&#41; and [CuDNN]&#40;https://developer.nvidia.com/cudnn&#41; before installing JAX**)

  [//]: # ()
  [//]: # (After install CUDA and CuDNN you can specify a particular CUDA and CuDNN version for jax explicitly)
  Install TensorFlow-GPU with CUDA
  ```angular2html
  python3 -m pip install tensorflow[and-cuda]
  ```

  <br>






  FastTENET class requires data path as parameter


  - **dpath_exp_data**: expression data path, required
  - **dpath_trj_data**: trajectory data path, required
  - **dpath_branch_data**: branch(cell select) data path, required
  - **dpath_tf_data**: tf data path, required
  - **spath_result_matrix**: result matrix data path, optional, default: None
  - **make_binary**: if True, make binary expression and node name file, optional, default: False

  ```angular2html
  import fasttenet as fte

  worker = fte.FastTENET(dpath_exp_data=dpath_exp_data,
                         dpath_trj_data=dpath_trj_data,
                         dpath_branch_data=dpath_branch_data,
                         dpath_tf_data=dpath_tf_data,
                         spath_result_matrix=spath_result_matrix,
                         make_binary=True)
  ```

  <br>

  - **aligned_data**: when directly using rearranged data with expression data, trajectory data and branch data, optional
  - **node_name**: 1d array of node names, required when using data directly
  - **tf**: 1d array of tf names, optional when using data directly

  ```angular2html
  import fasttenet as fte

  node_name, exp_data = fte.load_exp_data(dpath_exp_data, make_binary=True)
  trajectory = fte.load_time_data(dpath_trj_data, dtype=np.float32)
  branch = fte.load_time_data(dpath_branch_data, dtype=np.int32)
  tf = np.loadtxt(dpath_tf_data, dtype=str)

  aligned_data = fte.align_data(data=exp_data, trj=trajectory, branch=branch)

  worker = fte.FastTENET(aligned_data=aligned_data,
                         node_name=node_name,
                         tfs=tf,
                         spath_result_matrix=spath_result_matrix) # Optional
  ```

  <br>
  <br>




  - **backend**: optional, default: 'cpu'
  - **device_ids**: list or number of devcies to use, optional, default: [0] (cpu), [list of whole gpu devices] (gpu)
  - **procs_per_device**: The number of processes to create per device when using non 'cpu' devices, optional, default: 1
  - **batch_size**: Required
  - **kp**: kernel percentile, optional, default: 0.5
  - **binning_method**: discretization method for expression values, optional, 'FSBW-L' is recommended to achieve results similar to TENET.


  ```angular2html
  result_matrix = worker.run(backend='gpu',
                             device_ids=8,
                             procs_per_device=4,
                             batch_size=2 ** 16,
                             kp=0.5,
                             binning_method='FSBW-L')
  ```

  <br>
  <br>



  - **Before run tutorial_config.py, batch_size parameter must be modified to fit your gpu memory size**
  - **You can set parameters and run FastTENET via a YAML file**
  - **The config file must have values set for all required parameters**


  ```angular2html
  python tutorial_config.py --config [config file path]
  ```


  ```angular2html
  python tutorial_config.py --config ../configs/config_tuck_sub.yml
  ```


  ```angular2html
  TE_result_matrix.txt

  ex)
  TE	GENE_1	GENE_2	GENE_3	...	GENE_M
  GENE_1	0	0.05	0.02	...	0.004
  GENE_2	0.01	0	0.04	...	0.12
  GENE_3	0.003	0.003	0	...	0.001
  .
  .
  .
  GENE_M	0.34	0.012	0.032	...	0
  ```



  - **Before run tutorial_notf.py, batch_size parameter must be modified to fit your gpu memory size**


  ```angular2html
  python tutorial_notf.py --fp_exp [expression file path]
                          --fp_trj [trajectory file path]
                          --fp_br [cell select file path]
                          --backend [name of backend framework]
                          --num_devices [number of devices]
                          --batch_size [batch size]
                          --sp_rm [save file path]
  ```


  ```angular2html
  python tutorial_notf.py --fp_exp expression_dataTuck.csv
                          --fp_trj pseudotimeTuck.txt
                          --fp_br cell_selectTuck.txt
                          --backend lightning
                          --num_devices 8
                          --batch_size 32768
                          --sp_rm TE_result_matrix.txt
  ```


  ```angular2html
  TE_result_matrix.txt
  ```


  - **Before run tutorial_tf.py, batch_size parameter must be modified to fit your gpu memory size**


  ```angular2html
  python tutorial_tf.py --fp_exp [expression file path]
                        --fp_trj [trajectory file path]
                        --fp_br [cell select file path]
                        --fp_tf [tf file path]
                        --backend [name of backend framework]
                        --num_devices [number of devices]
                        --batch_size [batch size]
                        --sp_rm [save file path]
  ```


  ```angular2html
  python tutorial_tf.py --fp_exp expression_dataTuck.csv
                        --fp_trj pseudotimeTuck.txt
                        --fp_br cell_selectTuck.txt
                        --fp_tf mouse_tfs.txt
                        --backend lightning
                        --num_devices 8
                        --batch_size 32768
                        --sp_rm TE_result_matrix.txt
  ```


  ```angular2html
  TE_result_matrix.txt

  ex)
  TE	GENE_1	GENE_2	GENE_3	...	GENE_M
  GENE_1	0	0.05	0.02	...	0.004
  GENE_2	0.01	0	0.04	...	0.12
  GENE_3	0.003	0.003	0	...	0.001
  .
  .
  .
  GENE_M	0.34	0.012	0.032	...	0
  ```

  <br>
  <br>









  - **result_matrix**: result TE matrix of FastTENET, required
  - **gene_names**: gene names from result matrix, required
  - **tfs**: tf list, optional
  - **fdr**: specifying fdr, optional, default: 0.01
  - **links**: specifying number of outdegrees, optional, default: 0
  - **is_trimming**: if set True, trimming operation is applied on grn, optional, default: True
  - **trim_threshold**: trimming threshold, optional, default: 0

  ```angular2html
  result_matrix = np.loadtxt(fpath_result_matrix, delimiter='\t', dtype=str)
  gene_name = result_matrix[0][1:]
  result_matrix = result_matrix[1:, 1:].astype(np.float32)

  tf = np.loadtxt(fpath_tf, dtype=str)

  weaver = fte.NetWeaver(result_matrix=result_matrix,
                         gene_names=gene_name,
                         tfs=tf,
                         fdr=fdr,
                         links=links,
                         is_trimming=True,
                         trim_threshold=trim_threshold,
                         dtype=np.float32
                         )
  ```


  - **backend**: optional, default: 'cpu'
  - **device_ids**: list or number of devices to use, optional, default: [0] (cpu), [list of whole gpu devices] (gpu)
  - **batch_size**: if set to 0, batch size will automatically calculated, optional, default: 0

  ```angular2html
  grn, trimmed_grn = weaver.run(backend=backend,
                                device_ids=device_ids,
                                batch_size=batch_size)
  ```


  - **grn**: required

  ```angular2html
  outdegrees = weaver.count_outdegree(grn)
  trimmed_ods = weaver.count_outdegree(trimmed_grn)
  ```

  <br>
  <br>



  reconstruct_grn.py is a tutorial script for the output of grn and outdegree files.


  When specifying an fdr
  ```angular2html
  python reconstruct_grn.py --fp_rm [result matrix path] --fp_tf [tf file path] --fdr [fdr] --backend [backend] --device_ids [number of device]
  ```


  ```angular2html
  python reconstruct_grn.py --fp_rm TE_result_matrix.txt --fp_tf mouse_tf.txt --fdr 0.01 --backend gpu --device_ids 1
  ```


  ```angular2html
  TE_result_matrix.fdr0.01.sif, TE_result_matrix.fdr0.01.sif.outdegrees.txt
  TE_result_matrix.fdr0.01.trimIndirect0.sif, TE_result_matrix.fdr0.01.trimIndirect0.sif.outdegrees.txt
  ```

  <br>


  When specifying the links
  ```angular2html
  python reconstruct_grn.py --fp_rm [result matrix path] --fp_tf [tf file path] --links [links] --backend [backend] --device_ids [number of device]
  ```


  ```angular2html
  python reconstruct_grn.py --fp_rm TE_result_matrix.txt--fp_tf mouse_tf.txt --links 1000 --backend gpu --device_ids 1
  ```


  ```angular2html
  TE_result_matrix.links1000.sif, TE_result_matrix.links1000.sif.outdegrees.txt
  TE_result_matrix.links1000.trimIndirect0.sif, TE_result_matrix.links1000.trimIndirect0.sif.outdegrees.txt
  ```



  - [x] add 'JAX' backend module
  - [x] add 'PyTorch Lightning' backend module
  - [x] add 'TensorFlow' backend module


pkgId: 51f0fdd8e2064f91c3bd1fd8d0953d0cb8a5e22ef326545dc798ed80059ce13d
name: python-fawltydeps-help
arch: noarch
version: 0.18.0
epoch: 0
release: 1
summary: Development documents and examples for fawltydeps
url: https://github.com/tweag/FawltyDeps
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fawltydeps-0.18.0-1.src.rpm
location_href: Packages/python-fawltydeps-help-0.18.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI Latest Release](https://img.shields.io/pypi/v/fawltydeps.svg)](https://pypi.org/project/fawltydeps/) [![Supported Python versions](https://img.shields.io/pypi/pyversions/fawltydeps.svg)](https://pypi.org/project/fawltydeps/) ![Build](https://img.shields.io/github/actions/workflow/status/tweag/fawltydeps/ci.yaml) [![Licence](https://img.shields.io/pypi/l/fawltydeps.svg)](https://pypi.org/project/fawltydeps/) [![Code of conduct](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](code_of_conduct.md) [![Discord channel](https://img.shields.io/discord/1174731094726295632)](https://discord.gg/V2d9xpgD4D)



  FawltyDeps is a dependency checker for Python that finds _undeclared_ and/or
  _unused_ 3rd-party dependencies in your Python project.
  The name is inspired by the Monty Python-adjacent
  [Fawlty Towers](https://en.wikipedia.org/wiki/Fawlty_Towers) sitcom.

  ![FawltyDeps demo](https://github.com/tweag/FawltyDeps/raw/main/docs/fawltydeps_demo_tqdm.gif)

  We [invite you](https://discord.gg/V2d9xpgD4D) to join our [Discord channel](https://discord.com/channels/1174731094726295632/1176462512212951090)! It's a great place to ask questions, share your ideas, and collaborate with other contributors.



  [Key Concepts](#key-concepts)

  [Installation](#installation)

  [Usage](#usage)

  [Configuration](#configuration)

  [Documentation](#documentation)

  [Development](#development)

  [Integration tests](#integration-tests)

  [FAQ](#faq)



  - **_undeclared_ dependency**: a package that's used (in particular, `import`ed) by a project and which lacks a corresponding declaration to ensure that it's available.
    For example, you `import numpy`, but you've forgotten to include `numpy` in your `requirements.txt`.
    Pragmatically, this means the project is prone to runtime errors.
  - **_unused_ dependency**: a package that's declared as necessary for a project but which is never used by project code.
    For example, you have `numpy` listed in your `requirements.txt`, but you never actually `import numpy`.
    Pragmatically, this means that project installation may consume more space than needed and will be more likely to break with future software releases; in short, these are costs paid for no benefit.



  The library is distributed with PyPI, so simply:

  ```sh
  pip install fawltydeps
  ```

  or any other way to install Python packages from PyPI should be enough to make it available in your environment.

  Consider adding `fawltydeps` to your development dependencies, to help you catch undeclared and unused dependencies in your projects.



  To check the project in the current directory run:

  ```sh
  fawltydeps
  ```

  This will find imports in all the Python code under the current directory,
  extract dependencies declared by your project, and then report
  [_undeclared_ and _unused_ dependencies](#key-concepts).



  FawltyDeps provides the following options for controlling what actions to perform. Only
  one of these can be used at a time:

  - `--check`: Report both undeclared and unused dependencies
  - `--check-undeclared`: Report only undeclared dependencies
  - `--check-unused`: Report only unused dependencies
  - `--list-imports`: List third-party imports extracted from the project
  - `--list-deps`: List declared dependencies extracted from the project
  - `--list-sources`: List files/directories from which imports, declared
    dependencies and installed packages would be extracted

  When none of these are specified, the default action is `--check`.



  By default, FawltyDeps will look for Python code (`*.py` and `*.ipynb`) and
  dependency declarations (see list of supported files below) under the current
  directory. If you want FawltyDeps to look elsewhere, you can pass a different
  directory (aka `basepath`) as a positional argument:

  ```sh
  fawltydeps my_project/
  ```

  If you want to separately declare the source of the code and the source of the
  dependencies, you may use the `--code` and `--deps` options documented in the
  next section. In short, giving the `basepath` positional argument is equivalent
  to passing both the `--code` and the `--deps` options, like this:

  ```sh
  fawltydeps --code my_project/ --deps my_project/
  ```



  The `--code` option tells FawltyDeps where to find the Python code to parse for
  `import` statements. You can pass any number of these:

  - a single file: Either a Python file (`*.py`) or a Jupyter Notebook (`*.ipynb`)
  - a directory: FawltyDeps will find all Python files and Jupyter notebooks under this directory.
  - `-`: Passing a single dash (`--code=-`) tells FawltyDeps to read Python code
    from stdin.

  If no `--code` option is passed, FawltyDeps will find all Python code under the
  `basepath`, if given, or the current directory (i.e. same as `--code=.`).
  To include both code from stdin (`import foo`) and a file path (`file.py`), use:

  ```sh
  echo "import foo" | fawltydeps --list-imports --code - file.py
  ```

  At any time, if you want to see where FawltyDeps is looking for Python code,
  you can use the `--list-sources --detailed` options.



  The `--deps` option tells FawltyDeps where to look for your project's declared
  dependencies. A number of file formats are supported:

  - `*requirements*.txt` and `*requirements*.in`
  - `pyproject.toml` (following PEP 621, Poetry, or Pixi conventions)
  - `setup.py` (only limited support for simple files with a single `setup()`
    call and no computation involved for setting the `install_requires` and
    `extras_require` arguments)
  - `setup.cfg`
  - `pixi.toml`
  - `environment.yml`

  The `--deps` option accepts a space-separated list of files or directories.
  Each file will be parsed for declared dependencies; each directory will
  be searched, parsing all of the supported files (see the above list) found
  within. You would typically want to pass individual files, if you want to
  be explicit about where to find the declared dependencies.

  If no `--deps` option is passed, FawltyDeps will look for the above files under
  the `basepath`, if given, or the current directory (i.e. same as `--deps .`).



  When FawltyDeps looks for undeclared and unused dependencies, it needs to match
  `import` statements in your code with corresponding package dependencies
  declared in your project configuration.

  To solve this, FawltyDeps uses a sequence of resolvers (aka. mapping strategies)
  to determine which Python packages provide which import names. The diagram below
  shows the dependencies' flow through the sequence of mappings supported by
  FawltyDeps (each of which is introduced in the following subsections):
  - Local Python environment mapping
  - Mapping via temporarily installed packages
  - Identity mapping
  - User-defined mapping

  <img src="./images/resolvers_sequence.png" alt="Sequence of resolvers used by FawltyDeps" width="500"/>


  The priority of each of these mappings, together with their default values and
  customization options are summarized in the table below:

  | Priority | Mapping strategy        | Options |
  |----------|----------------------|------------|
  | 1        | User-defined mapping | Provide a custom mapping in TOML format via `--custom-mapping-file` or a `[tool.fawltydeps.custom_mapping]` section in `pyproject.toml`. <br /> Default: No custom mapping|
  | 2        | Mapping from installed packages found inside project | Point to one or more environments with `--pyenv`.<br />Default: auto-discovery of Python environments under the project’s basepath.|
  | 3        | Mapping from packages installed in `sys.path` | Active by default. No CLI option. This finds packages installed in the Python environment in which FawltyDeps itself runs.|
  | 4a       | Mapping via temporary installation of packages  | Activated with the `--install-deps` option.|
  | 4b       | Identity mapping | Active by default. Deactivated when `--install-deps` is used. |




  Local Python environment mapping refers to using packages already installed
  in local Python environments on your system to resolve dependencies into
  the imports they expose. This leverages the functionality provided
  by the excellent [`importlib_metadata`](https://importlib-metadata.readthedocs.io/en/latest/)
  library.

  You can use the `--pyenv` option (or the `pyenvs` configuration directive)
  to point FawltyDeps at one [or more] specific Python environment(s) located
  within your project or elsewhere. For example:

  ```sh
  fawltydeps --code my_package/ --deps pyproject.toml --pyenv /path/to/project/venv
  ```

  This will tell FawltyDeps:

  - to look for `import` statements in the `my_package/` directory,
  - to parse dependencies from `pyprojects.toml`, and
  - to use the Python environment at `/path/to/project/venv` to map dependency names in
    `pyproject.toml` into import names used in your code under `my_package/`

  If `--pyenv` is not used, FawltyDeps will look for _Python environments_
  (virtualenvs or similar directories like `.venv` or `__pypackages__`.) inside
  your project (i.e. under `basepath`, if given, or the current directory).

  You can use `--pyenv` multiple times to have FawltyDeps look for packages in
  multiple Python environments. In this case (or when multiple Python environments
  are found inside your project) FawltyDeps will use the union (superset) of all
  imports provided by all matching packages across those Python environments as
  valid import names for that dependency.



  In addition to the local Python environments found above, FawltyDeps will also
  look at your _current Python environment_, i.e. the environment in which
  FawltyDeps itself is installed. This works well when you, for example,
  `pip install fawltydeps` into the same virtualenv as your project dependencies,
  no matter where this virtualenv may be located.



  When unable to find an installed package that corresponds to a declared
  dependency either via a user-provided mapping or local Python environments,
  FawltyDeps will fall back to one of two strategies. "Identity mapping", which we
  present in this section is the default fallback strategy. We discuss the other
  strategy in the next subsection.

  Identity mapping relies on the simplistic assumption that the dependency provides
  a single import of the same name, i.e. it will expect that when you depend on
  `some_package`, then that should correspond to `import some_package` statements
  in your code.

  This assumption is correct for many packages and it allows FawltyDeps to
  produce results (albeit sometimes inaccurate ones) when the current Python
  environment does not contain all of your declared dependencies.

  To ensure correctness, however, refer to the next subsection outlining the other
  fallback strategy.



  Your local Python environments might not always have all your project's
  dependencies installed. Assuming that you don’t want to go through the
  bother of installing packages manually, and you also don't want to rely on
  the inaccurate identity mapping as your fallback strategy, you can use the
  `--install-deps` option. This will automatically install missing dependencies
  (from [PyPI](https://pypi.org/), by default) into a _temporary virtualenv_,
  and allow FawltyDeps to use this to come up with the correct mapping.

  Since this is a potentially expensive strategy (e.g. downloading packages from
  PyPI), we have chosen to hide it behind the `--install-deps` command-line
  option. If you want to always enable this option, you can set the corresponding
  `install_deps` configuration variable to `true` in the `[tool.fawltydeps]`
  section of your `pyproject.toml`.

  FawltyDeps will use [`uv`](https://github.com/astral-sh/uv) by default to
  temporarily install missing dependencies. If `uv` not available, `pip` will be
  used instead. If you want to ensure that the faster `uv` is available, you can
  install `fawltydeps` with the `uv` extra (e.g. `pip install fawltydeps[uv]`).

  To further customize how this automatic installation is done (e.g. if you need
  to use a different package index), you can use environment variables to alter
  [`uv`'s](https://github.com/astral-sh/uv?tab=readme-ov-file#environment-variables)
  or [`pip`’s ](https://pip.pypa.io/en/stable/topics/configuration/) behavior.

  Note that we’re never guaranteed to be able to resolve _all_ dependencies with
  this method: For example, there could be a typo in your `requirements.txt` that
  means a dependency will _never_ be found on PyPI, or there could be other
  circumstances (e.g. network issues or restrictions in your CI environment) that
  prevent this strategy from working at all.
  In this case, FawltyDeps will throw an error and abort.



  We provide a custom mapping functionality to users wishing to take control
  over the way FawltyDeps resolves dependencies. You may define your own mapping
  of dependency names to import names, by providing a TOML file like this:

  ```toml
  my-package = ["mpkg"]
  scikit-learn = ["sklearn"]
  multiple-modules = ["module1", "module2"]
  ```

  To use your mapping, run:

  ```sh
  fawltydeps --custom-mapping-file my_mapping.toml
  ```

  FawltyDeps will parse your `my_mapping.toml` file and use the extracted mapping
  for matching dependencies to imports.

  You may also place the custom mapping in the `pyproject.toml` file of your
  project, inside a `[tool.fawltydeps.custom_mapping]` section, like this:

  ```toml
  [tool.fawltydeps.custom_mapping]
  my-package = ["mpkg"]
  scikit-learn = ["sklearn"]
  multiple-modules = ["module1", "module2"]
  ```

  The provided mapping can be complete or partial. When a dependency is not
  present in the given mapping, FawltyDeps will continue to resolve it using
  the sequence of resolvers illustrated in the diagram above.

  Caution when using your mapping is advised: As illustrated in the diagram, the
  user-defined mapping takes precedence over the other resolvers documented
  above. For example, if the mapping file has some stale/incorrect mapping
  entries, they will _not_ be resolved by the Python environment resolver (which
  is usually more accurate).



  If you want FawltyDeps to exclude parts of your source tree when loooking for
  code, dependency declarations, or Python environments, then you can use the
  `--exclude` option to specify path patterns to exclude, e.g. the following
  command will skip everything under `tests/`:

  ```sh
  fawltydeps --exclude tests/
  ```

  The format of the exclude patterns is the same as used by `.gitignore` files,
  [see here for a full description](https://git-scm.com/docs/gitignore#_pattern_format).

  When the `--exclude` option is not specified, its default value is `".*"`, which
  matches all paths that start with a dot (`.`), aka. "hidden" paths. In the above
  example, if you want to exclude both hidden paths, and everything under
  `tests/`, then instead use:

  ```sh
  fawltydeps --exclude tests/ ".*"
  ```

  (The extra quotes here are needed to prevent the shell from interpreting and
  replacing the `*` wildcard.)

  You can also point to exclude patterns stored in a file, with the
  `--exclude-from` option. E.g. to read exclude patterns from `./my_excludes.txt`:

  ```sh
  fawltydeps --exclude-from my_excludes.txt
  ```

  Exclude patterns have lower priority than any paths you pass directly on the
  command line, e.g. in this command:

  ```sh
  fawltydeps --code my_file.py --exclude my_file.py
  ```

  the `--code` options "wins" (i.e. imports in `my_file.py` will be found); the
  `--exclude` option only takes affect when traversing directories to look for
  more files. E.g. use this to find code inside `my_dir`, but skip Jupyter
  notebooks:

  ```sh
  fawltydeps --code my_dir --exclude "*.ipynb"
  ```



  There may be `import` statements in your code that should not be considered an
  undeclared dependency. This might happen if you for example do a conditional
  `import` with a `try: ... except ImportError: ...` block (or similar).
  FawltyDeps is not able to recognize whether these dependencies should have been
  declared or not, but you can ask for them to be ignored with the
  `--ignore-undeclared` option, for example:
  `--ignore-undeclared some_module some_other_module`

  Conversely, there may be dependencies that you have declared without intending
  to `import` them. This is often the case for developer tools like Black or Mypy
  that are part of your project's development environment.
  We've introduced a `DEFAULT_IGNORE_UNUSED` list, which includes various
  categories of commonly used development tools and dependencies.
  FawltyDeps can automatically ignore these dependencies when checking for unused
  imports. For the complete list, please see the `DEFAULT_IGNORE_UNUSED`
  variable in the [`fawltydeps/settings.py`](./fawltydeps/settings.py) file
  in the repository. If you have additional dependencies that you want to exclude
  from the check for unused imports, you can use the `--ignore-unused` option
  to customize the ignore list. By providing your own list of dependencies with
  this option, you can effectively overwrite the default list. For example:
  `--ignore-unused black mypy some_other_module`



  The default output from FawltyDeps is a summary outlining the relevant
  dependencies found (according to the selected actions).
  However you can also ask for more information from FawltyDeps:

  - `--summary`: Default (human-readable) summary output
  - `--detailed`: Longer (human-readable) output that includes the location of
    the relevant dependencies.
  - `--json`: Verbose JSON-formatted output for other tools to consume and
    process further.

  Only one of these options can be used at a time.



  Run `fawltydeps --help` to get the full list of available options.



  You can use a `[tool.fawltydeps]` section in `pyproject.toml` to configure the
  default behavior of FawltyDeps. Here's a fairly comprehensive example:

  ```toml
  [tool.fawltydeps]
  code = ["myproject"]  # Only search for imports under ./myproject
  deps = ["pyproject.toml"]  # Only look for declared dependencies here
  ignore_unused = ["black"]  # We use `black`, but we don't intend to import it
  output_format = "human_detailed"  # Detailed report by default
  ```

  Here is a complete list of configuration directives we support:

  - `actions`: A list of one or more of these actions to perform: `list_imports`,
    `list_deps`, `check_undeclared`, `check_unused`. The default behavior
    corresponds to `actions = ["check_undeclared", "check_unused"]`.
  - `output_format`: Which output format to use by default. One of `human_summary`,
    `human_detailed`, or `json`.
    The default corresponds to `output_format = "human_summary"`.
  - `code`: Files or directories containing the code to parse for import statements.
    Defaults to the current directory, i.e. like `code = ["."]`.
  - `deps`: Files or directories containing the declared dependencies.
    Defaults to the current directory, i.e. like `deps = ["."]`.
  - `pyenvs`: Where to look for Python environments (directories like `.venv`,
    `__pypackages__`, or similar) to be used for resolving project dependencies
    into provided import names. Defaults to looking for Python environments under
    the current directory, i.e. like `pyenvs = ["."]`.
  - `ignore_undeclared`: A list of specific dependencies to ignore when reporting
    undeclared dependencies, for example: `["some_module", "some_other_module"]`.
    The default is the empty list: `ignore_undeclared = []`.
  - `ignore_unused`: A list of specific dependencies to ignore when reporting
    unused dependencies, for example: `["black", "mypy", "some_other_module"]`.
    The default is a list including common development tools. However, you have the
    flexibility to overwrite this list according to your project's specific requirements.
    For the complete default list, please see the `DEFAULT_IGNORE_UNUSED`
    variable in the [`fawltydeps/settings.py`](./fawltydeps/settings.py) file
    in the repository.
  - `deps_parser_choice`: Manually select which format to use for parsing
    declared dependencies. Must be one of `"requirements.txt"`, `"setup.py"`,
    `"setup.cfg"`, `"pyproject.toml"`, `"pixi.toml"`, `"environment.yml"`, or
    leave it unset (i.e. the default) for auto-detection (based on filename).
  - `install-deps`: Automatically install Python dependencies gathered with
    FawltyDeps into a temporary virtual environment. This will use `uv` or `pip`
    to download and install packages from PyPI by default.
  - `exclude`: File/directory patterns to exclude/ignore when looking for code
    (imports), dependency declarations and/or Python environments. Defaults to
    `exclude = [".*"]`, meaning that hidden/dot paths are excluded from traversal.
  - `exclude_from`: Files (following the .gitignore format) containing exclude
    patterns to use when looking for code (imports), dependency declarations
    and/or Python environments. Defaults to an empty list: `exclude_from = []`.
  - `verbosity`: An integer controlling the default log level of FawltyDeps:
    - `-2`: Only `CRITICAL`-level log messages are shown.
    - `-1`: `ERROR`-level log messages and above are shown.
    - `0`: `WARNING`-level log messages and above are shown. This is the default.
    - `1`: `INFO`-level log messages and above are shown.
    - `2`: All log messages (including `DEBUG`) are shown.
  - `custom_mapping_file`: Paths to files containing user-defined mapping.
    Expected file format is defined in the User-defined mapping [section](#user-defined-mapping).
  - `[tool.fawltydeps.custom_mapping]`: Section in the configuration, under which a custom mapping
    can be added. Expected format is described in the User-defined mapping [section](#user-defined-mapping).



  In addition to configuring FawltyDeps via `pyproject.toml` as show above, you
  may also pass the above configuration directives via the environment, using a
  `fawltydeps_` prefix. For example, to enable JSON output via the environment,
  set `fawltydeps_output_format=json` in FawltyDeps' environment.



  - Command-line options take precedence, and override corresponding settings
    passed via the environment or `pyproject.toml`.
  - Environment variables override corresponding settings from `pyproject.toml`.
  - Configuration in `pyproject.toml` override only the ultimate hardcoded defaults.
  - The ultimate defaults when no cutomizations takes place are hardcoded inside
    FawltyDeps, and are documented above.



  This project began with an exploration and design phase, yielding this [design document](./docs/DesignDoc.md), which lays out the main objective for this project and compares various strategies considered

  In the [code design](./docs/CodeDesign.md) section of documentation we lay out rules which we adopt to guide code architecture decisions and maintain code quality as the project evolves.



  For details on setting up your development environment, please refer to the
  contributing guidelines of how to [set up your development environment](./CONTRIBUTING.md#set-up-your-development-environment)
  in our [CONTRIBUTING.md](CONTRIBUTING.md) file.



  For details on integration tests, please refer to the
  [Testing section](./CONTRIBUTING.md#testing) in our [CONTRIBUTING.md](./CONTRIBUTING.md) file.





  You can run a detailed report to see the exact location (file and line number), in which
  the undeclared dependencies were imported:

  ```sh
  fawltydeps --detailed
  ```

  and debug each occurrence. Typically an undeclared dependency can be fixed in a couple of ways:

  - A true undeclared dependency is fixed by _declaring_ it, e.g. adding it to your `pyproject.toml` or similar.
  - If you disagree with FawltyDeps' classification, you can always use `--ignore-undeclared` to silence the error. If you're sure this dependency should not have been reported by FawltyDeps, you may consider filing a bug report.



  By default, all packages declared as dependencies by your project are included
  in the FawltyDeps analysis, even if they only contain tools that were not meant
  to be `import`ed, but rather meant to be run by, say, in a pre-commit hook or a
  CI script. In such cases you may use either:

  ```sh
  fawltydeps --ignore-unused black pylint
  ```

  or add an equivalent directive to the FawltyDeps configuration in your
  `pyproject.toml` (see below).



  You can run:

  ```sh
  fawltydeps --generate-toml-config
  ```

  to generate a `[tool.fawltydeps]` section with the current configuration that
  you can then directly copy into your `pyproject.toml`. Options that have their
  default value are commented in this output, so you have quickly see where your
  settings differ from the FawltyDeps defaults.

  This also works together with other command line options, so for example in the
  previous question, you could add `--generate-toml-config` to the command line
  (i.e. run `fawltydeps --ignore-unused black pylint --generate-toml-config`),
  to get this:

  ```toml
  [tool.fawltydeps]

  ignore_unused = ["black", "pylint"]
  ```



  Running `fawltydeps` without arguments at the root of a monorepo
  will most likely not give you a useful result:
  it will collect dependencies and import statements from across the _entire_ monorepo.
  The produced report may be overwhelming and at the same time not granular enough.

  Instead, you should run FawltyDeps for each package separately.
  This collects dependencies and import statements for one package at a time.

  Having:

  ```sh
  ├ lib1
  | ├ pyproject.toml
  | ├ ....
  ├ lib2
  | ├ pyproject.toml
  | ├ ....
  ```

  run for each `libX`:

  ```sh
  fawltydeps libX
  ```



  (This is no longer true since FawltyDeps v0.11: FawltyDeps should be able to
  automatically find your project dependencies when they are installed in a Python
  environment that exists within your project. If your project dependencies are
  installed elsewhere, you can point FawltyDeps in their direction with `--pyenv`,
  as explained above in the section on
  [Python environment mapping](#python-environment-mapping))

  The reason why FawltyDeps need to find your project dependencies _somewhere_ is
  that the core logic of FawltyDeps needs to match `import` statements in your
  code with dependencies declared in your project configuration. This seems
  straightforward for many packages: for example you `pip install requests` and
  then you can `import requests` in your code. However, this mapping from the name
  you install to the name you `import` is not always self-evident:

  - There are sometimes differences between the package name that you
    declare as a dependency, and the `import` name it provides. For example, you
    depend on `PyYAML`, but you `import yaml`.
  - A dependency can expose more than one import name. For example the
    `setuptools` package exposes three `import`able packages: `_distutils_hack`,
    `pkg_resources`, and `setuptools`. So when you `import pkg_resources`,
    FawltyDeps need to figure out that this corresponds to the `setuptools`
    dependency.

  To solve this, FawltyDeps looks at the packages installed in your Python
  environment to correctly map dependencies (package names) into the imports that
  they provide. This is:

  - any Python environment found via the `--pyenv` option,
  - or if `--pyenv` is not given: any Python environment found within your
    project (`basepath` or the current directory).
  - In addition, FawltyDeps will use the _current Python environment_,
    i.e. the one in which FawltyDeps itself is running.

  As a final resort, when an installed package is not found for a declared
  dependency, the
  _identity mapping_ that FawltyDeps falls back to will still do a good job for
  the majority of dependencies where the import name is indeed identical to the
  package name that you depend on.

  This is an area of active development in FawltyDeps, and we are
  [working on better solutions](https://github.com/tweag/FawltyDeps/issues/195),
  to avoid having to fall back to this identity mapping.



  There are cases, where FawltyDeps may not match imports and obviously related
  dependencies, like `sklearn` and `scikit-learn`. It will report `sklearn` as
  _undeclared_ and `scikit-learn` as an _unused_ dependency.

  This is very much related to the above question. `scikit-learn` is an example
  of a package that exposes a different import name: `sklearn`.
  When `scikit-learn` is not found in the Python environment(s) used by FawltyDeps,
  then FawltyDeps is unable to make the connection between these two names.

  To solve this problem, make sure that `scikit-learn` is installed in a Python
  environment that belongs to your project. Alternatively, you can use the
  `--pyenv` option to point at a Python environment where `scikit-learn` and your
  other dependencies are installed.



  The `--code` argument accepts a single hyphen (`-`) as a special value meaning
  that code should be read from standard input. When using this you may pipe or
  redirect your Python code into FawltyDeps like this:

  ```sh
  cat some/source/of/python/code | fawltydeps --code -

  fawltydeps --code - < some/source/of/python/code
  ```

  You can also use this directly in the terminal to e.g. have FawltyDeps analyze
  some Python code that is in your clipboard:

  ```sh
  fawltydeps --code -


  ```



  Yes! Assuming that you already use the [pre-commit](https://pre-commit.com)
  tool, you can add something like this to your project's
  `.pre-commit-config.yaml`:

  ```yaml
  repos:
    - repo: https://github.com/tweag/FawltyDeps
      rev: v0.18.0
      hooks:
        - id: check-undeclared
        - id: check-unused
  ```




  Yes! This works well when run as a lint step in continuous integration systems.

  Please see [tweag/FawltyDeps-action](https://github.com/tweag/FawltyDeps-action) for a GitHub Action that implements FawltyDeps linting. You can also get the FawltyDeps GitHub Action from the [Actions Marketplace](https://github.com/marketplace/actions/fawltydeps).


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

  fbnconfig is a Python library (and commandline tool) to allow a declarative description of a LUSID
  environment. It allows you to specify the desired state and, when you deploy, it converges the
  LUSID environment to your desired state by creating, updating, or deleting entities within LUSID
  so that the LUSID environment and the desired state match.



  fbnconfig is available from PyPi

  ```cli
  pip install fbnconfig
  ```



  ```cli
  fbnconfig -e https://foo.lusid.com -t <token> run path/to/script.py
  ```

  This will apply the deployment script (script.py) to the foo.lusid.com domain.

  For a list of commands that let you view what's already deployed, use `fbnconfig --help`.



  fbnconfig needs a valid LUSID url and a token to create and modify a LUSID environment.
  The token will most likely be a personal access token (PAT), but could be a token from an
  authentication exchange. For more information on PATs and how to create them, start by reading
  [What is a personal access token?](https://support.lusid.com/knowledgebase/article/KA-01911/) on
  FINBOURNE's Knowledge Base.

  We recommend configuring the url and token as environment variables:

  ```environment
  FBN_ACCESS_TOKEN=xyzabc1234
  LUSID_ENV=https://foo.lusid.com
  fbnconfig setup
  ```

  Alternatively, you can use the commandline:

  ```cli
  fbnconfig setup -e https://foo.lusid.com -t xyzabc1234
  ```



  Before being able to run a deployment, a one time per-domain setup is required. This creates a
  required CustomEntityDefinition where deployment logs are stored.

  To run using the cli, assuming the appropriate environment variables are set, then run the following:

  ```cli
  fbnconfig setup
  ```

  To run using the library:

  ```python
  import fbnconfig
  import os

  lusid_env = os.environ["LUSID_ENV"]
  token = os.environ["FBN_ACCESS_TOKEN"]
  client = fbnconfig.create_client(lusid_env, token)
  fbnconfig.setup(client)
  ```



  A fbnconfig configure script is a Python file that includes the `configure(env):` function. When you
  create an fbnconfig configure script, you must define one or more `Deployments`.

  For example, the following code is a valid fbnconfig configure script. The configure script defines
  the desired state, and running it changes the remote LUSID environment to match.

  ```Python
  from fbnconfig import drive
  from fbnconfig import Deployment


  def configure(env):
      f1 = drive.FolderResource(id="base_folder", name="my_folder", parent=drive.root)
      return Deployment("my_deployment", [f1])
  ```

  * Configure scripts need to import references resource like a normal Python
    script would.
  * The `configure(env):`  function is the entrypoint, which should return a `Deployment`.
  * `Deployments` contain one or more resources. In this case, the `Deployment` contains a single
    `FolderResource` Resource that's saved in the `f1` variable.

  When we run this script the first time it will create a folder in LUSID Drive called `my_folder`.
  The second time we run it, fbnconfig knows the folder already exists and will not make any changes.
  If we change the name of the folder (for example `name="another_name"`) and run fbnconfig again it
  will rename the folder in LUSID Drive.



  Deployments require an `id`. In this example we define a value of `my_deployment` for the
  Deployment's `id` when we return the Deployment object.

  Be careful if you change the ID of a Deployment. If you change the ID and re-run the configure
  script, fbnconfig creates a new LUSID environment with a new Deployment ID and new Resources.
  The previous Deployment's Resources are not automatically removed.

  Each Resource must also have an `id` and these `id`s must be unique within the fbnconfig Deployment.
  In this example, we use `id="base_folder"` to uniquely identify the folder Resource we create.

  * We can change the `name` of a folder and it will get renamed
    because it has the same `id`.
  * If we change the `id` then the existing folder will be deleted and a new one will be created. Note
    that the original folder does not persist, because fbnconfig configure scripts are declarative
    fbnconfig makes the LUSID state match the configure file state. If the original folder disappears
    from the configure file, fbnconfig makes the original folder disappear from the corresponding
    LUSID environment.
  * The Python variable `f1` that references the folder is only used to identify the resource within
    the Python configure script. This variable is not used for tracking changes in LUSID, therefore
    changing the Python variable names does not affect what gets deployed.



  Resources may need to reference other resources. For example, the following code creates the nested
  folder Resources.

  ```Python
  def configure(env):
      f1 = drive.FolderResource(id="base_folder", name="my_folder", parent=drive.root)
      f2 = drive.FolderResource(id="sub_folder", name="my_subfolder", parent=f1)
      return Deployment("my_deployment", [f1, f2])
  ```

  If we run this it will create the structure `/my_folder/my_subfolder`. Using the Python variable
  names we say that `my_subfolder` (`f1` in the script) is a subfolder of its parent `my_folder`
  (`f2` in the script).  Relationships are defined by the Python variables, in this case `parent=f1`.

  When we have nested structures like this, fbnconfig creates the parents before the children. For
  example, `f1` would get created (or updated) before `f2`, and if they are removed from the
  deployment then `f2` will be deleted before `f1`.

  This example references both folders (`[f1, f2]`), however we could instead reference just the
  subfolder (`[f2]`). Because `f2` depends on `f1`, `f1` will be implicitly included.



  When we define a Deployment in a configure script and use fbnconfig to create the corresponding
  LUSID environment, all the underlying Resources are fully managed by fbnconfig. This means we want
  to use fbnconfig to manage all related Resources within a single Deployment.

  However, if we need to establish a relationship between existing Resources and our configure script,
  we can use a `Ref`. In the following example, we account for the `downloads` folder which already
  exists because it has been created manually or is part of another Deployment.

  ```Python
  def configure(env):
      f1 = drive.FolderRef(id="downloads", name="downloads")
      f2 = drive.FolderResource(id="sub_folder", name="my_subfolder", parent=f1)
      return Deployment("my_deployment", [f1, f2])
  ```

  * This code will create `sub_folder` within the existing `downloads` Resource. We tell fbnconfig
    that `downloads` already exists by using the `drive.FolderRef()` function instead of
    `drive.FolderResource()`.
  * If `downloads` doesn't exist at the time this is run, we get an error.
  * The `downloads` folder will be the parent of `sub_folder`, but it won't be managed within this
    Deployment.
  * If `f1` is removed, it won't get deleted because it is not being managed in this deployment.



  To aid with using the same script for dev, uat, and prod, fbnconfig takes a commandline argument to
  a json file called the "vars file". The vars file (called `env` in the examples above) is
  parsed and passed into the configure function.

  For example, suppose we wanted to use different email for dev and prod (like the environment
  variable example above).

  We would:

  1. Create two vars files.

  ```json
  // prod.json                                    // dev.json
  {                                               {
      "email": "prod@company.com"                     "email": "dev@company.com"
  }                                               }
  ```

  1. Reference the files from the script var env.

      ```Python
      def configure(env):
          export_user = identity.UserResource(
              id="user2",
              ...
              emailAddress=env.email,
          )
      ```

  1. Run the following command to use the `dev@company.com` email..

      ```cli
      fbnconfig -e https://dev.lusid.com -v dev.json script.py
      ```

  These vars files can be comitted to the repo to capture variations between environments. For
  secrets, it's better to use explicit environment variables in the script (see below).



  A deployment script is normal Python, so Python language features are available. For example
  variables and f-strings. To allow values to depend on the environment, you can use `os.environ` to
  initialise the variables. This is useful when setting up secrets in the config store.

  For example, the following code:

  1. Passes the secret as an environment variable.
  2. Makes an http request or use a library from a vault provider to source the
  secret.
  3. Uses the secret inside the configure function.

  ```Python
  import os

  company = os.environ["company"]

  def configure(env):
      export_user = identity.UserResource(
          id="user2",
          ...
          emailAddress=f"exports@{company}",
          login=f"exports@{company}",
      )
  ```

  You can even create resources in a loop, for example:

  ```Python
  def configure(env):
      folders = [
          drive.FolderResource(id=f"folder_{i}", name="i", parent=drive.root)
          for i in range(0, 10)
      ]
      return Deployment('ten-folders', folders)
  ```

  The Python variables for the Resources need to be added to the deployment and each Resource must
  have a unique `id`.



  Using fbnconfig from the commandline dyamically loads your Python script and executes the
  Deployment. In some cases (for example using fbnconfig as part of another application) you can call
  it from Python as well.

  The following example creates an empty deployment called "my-jobs":

  ```Python
  from os import environ
  from fbnconfig import Deployment, deploy


  def configure(env):
      return Deployment("my-jobs", [])


  host_vars = {}
  lusid_url = "https://foo.lusid.com"
  token = environ["MY_TOKEN_VAR"]
  deployment = configure(host_vars)
  deploy(deployment, lusid_url, token)
  ```


pkgId: 43667cdd942559790ea877988d98d417f623fa791ba9c3f785f087761e7faf17
name: python-fdtdx-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for fdtdx
url: https://pypi.org/project/fdtdx/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fdtdx-0.1.0-1.src.rpm
location_href: Packages/python-fdtdx-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  FDTDX is an efficient open-source Python package for the inverse design of three-dimensional photonic nanostructures using the Finite-Difference Time-Domain (FDTD) method. Built on JAX, it provides native GPU support and automatic differentiation capabilities, making it ideal for large-scale 3D design in nanophotonics.



  - **High Performance**: GPU-accelerated FDTD simulations with multi-GPU scaling capabilities
  - **Memory Efficient**: Leverages time-reversibility in Maxwell's equations for efficient gradient computation
  - **Automatic Differentiation**: Built-in gradient-based optimization for complex 3D structures
  - **User-Friendly API**: Intuitive positioning and sizing of objects in absolute or relative coordinates
  - **Large-Scale Design**: Capable of handling simulations with billions of grid cells
  - **Open Source**: Freely available for research and development



  Visit our [documentation](https://ymahlau.github.io/fdtdx) for:
  - Detailed API reference
  - Tutorial guides
  - Example simulations
  - Best practices




  Install FDTDX using pip:

  ```bash
  pip install fdtdx
  ```

  For development installation, clone the repository and install in editable mode:

  ```bash
  git clone https://github.com/ymahlau/fdtdx
  cd fdtdx
  pip install -e .
  ```



  ```bash


  export XLA_PYTHON_CLIENT_ALLOCATOR=platform
  export XLA_PYTHON_CLIENT_PREALLOCATE=false
  export NCCL_LL128_BUFFSIZE="-2"
  export NCCL_LL_BUFFSIZE="-2"
  export NCCL_PROTO="SIMPLE,LL,LL128"
  ```


  If you find this repository helpful for you work, please consider citing:
  ```
  @article{schubert2024quantized,
    title={Quantized Inverse Design for Photonic Integrated Circuits},
    author={Schubert, Frederik and Mahlau, Yannik  and Bethmann, Konrad and Hartmann, Fabian and Caspary, Reinhard and Munderloh, Marco and Ostermann, J{\"o}rn and Rosenhahn, Bodo},
    journal={arXiv preprint arXiv:2407.10273},
    year={2024}
  }
  ```


pkgId: 5815c7e7dc02e4f1b558c10fefd2820fae834a38e3724f8dfdff0a69d7625dcd
name: python-fdtooldf-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for fdtooldf
url: https://pypi.org/project/fdtooldf/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fdtooldf-0.0.1-1.src.rpm
location_href: Packages/python-fdtooldf-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  This is fork of https://github.com/kristian10007/FDTool which is fork of https://github.com/USEPA/FDTool

  This fork introduces:
  - Functionality of using pandas and polars dataframes as inputs.
  - Better logging.
  - (Experiments planned) Multithreaded search optimization.



  ```python

  !pip install fdtooldf


  from fdtooldf.runner import run_fdtool
  import seaborn as sns

  df = sns.load_dataset("tips")  # just to demonstrate
  result = run_fdtool(df)  # result have two elements - [str to print, real_containers]

  print(result[0])
























  result[1]



















  ```


  Notes:
  Module REPO/fdtooldf/modules/dbschema released under C-FSL license and copyright held by Elmar Stellnberger.


pkgId: c42960cc10dc16204f4b6d5230866271dde3e7e2cc6ac3ce5534af4a3a691190
name: python-feature-gen-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for feature-gen
url: https://github.com/ArminCS97/masters_project
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-feature-gen-0.1.0-1.src.rpm
location_href: Packages/python-feature-gen-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This project utilizes **genetic algorithms** and **ensemble learning** techniques to identify the optimal set of
  features for predictive models. It combines the power of **evolutionary computation** with the robustness of ensemble
  methods to improve model performance by selecting the best features from a dataset.



  - Implements a **Genetic Algorithm (GA)** to explore the feature space.
  - Integrates with popular ensemble learning models like **XGBoost** and **Random Forest**.
  - Provides a flexible interface for customizing the GA parameters such as population size, number of generations, and
    mutation rate.
  - Outputs the best feature set along with detailed performance metrics.



  Install the package using `pip`:

  ```bash
  pip install feature_gen
  ```


pkgId: 9329afcf5b41596a8a6b9183118bbd18e204498c8b06b23f7028d31770182f92
name: python-feature-gen-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for feature-gen
url: https://github.com/ArminCS97/masters_project
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-feature-gen-0.1.2-1.src.rpm
location_href: Packages/python-feature-gen-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  - **Automated Feature Engineering**: Automatically identifies and optimizes feature subsets for classification tasks.
  - **Advanced Transformations**: Includes transformations like logarithmic, square, cubic, sigmoid, and tanh to uncover complex, non-linear relationships.
  - **Multi-objective Optimization**: Leverages the NSGA-II genetic algorithm to optimize both classification accuracy and feature subset size.
  - **Ensemble Learning Integration**: Combines Logistic Regression, SVM, and XGBoost to ensure diverse model perspectives.
  - **Flexible Ensemble Methods**: Supports strategies like Majority Voting, Weighted Averaging, and Greedy Selection for robust feature evaluation.
  - **Scalable Architecture**: Uses multithreading and multiprocessing to handle large datasets efficiently.


pkgId: b45f9f8516fa9728cb1bb5c47ee75458e9ee380f4cb3322828d4a878097e5f4c
name: python-featurebyte-help
arch: noarch
version: 2.1.0
epoch: 0
release: 1
summary: Development documents and examples for featurebyte
url: https://featurebyte.com
rpm_license: Elastic-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-featurebyte-2.1.0-1.src.rpm
location_href: Packages/python-featurebyte-help-2.1.0-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center"> FeatureByte's Declarative Feature Engineering Framework</h1>
  <div align="center">

  [![Build status](https://github.com/featurebyte/featurebyte/workflows/build/badge.svg?branch=main&event=push)](https://github.com/featurebyte/featurebyte/actions?query=workflow%3Abuild)
  [![Python Version](https://img.shields.io/pypi/pyversions/featurebyte.svg)](https://pypi.org/project/featurebyte/)
  [![Dependencies Status](https://img.shields.io/badge/dependencies-up%20to%20date-brightgreen.svg)](https://github.com/featurebyte/featurebyte/pulls?utf8=%E2%9C%93&q=is%3Apr%20author%3Aapp%2Fdependabot)

  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Security: bandit](https://img.shields.io/badge/security-bandit-green.svg)](https://github.com/PyCQA/bandit)
  [![Pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/featurebyte/featurebyte/blob/main/.pre-commit-config.yaml)
  [![Semantic Versions](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--versions-e10079.svg)](https://github.com/featurebyte/featurebyte/releases)
  [![License](https://img.shields.io/badge/license-elastic%202.0-yellowgreen)](https://github.com/featurebyte/featurebyte/blob/main/LICENSE)
  ![Coverage Report](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/kchua78/773e2960183c0a6fe24c644d95d71fdb/raw/coverage.json)

  </div>

  FeatureByte SDK is the core engine of FeatureByte's [Self-Service Feature Platform](https://featurebyte.com/). It is a **free and source available feature platform** designed to:

  * **Create state-of-the-art features, not data pipelines:** Create features for Machine Learning with just a few lines of code. Leave the plumbing and pipelining to FeatureByte. We take care of orchestrating the data ops - whether it’s time-window aggs or backfilling, so you can deliver more value from data.
  * **Improve Accuracy through data:** Use the intuitive feature declaration framework to transform creative ideas into training data in minutes. Ditch the limitations of ad-hoc pipelines for features with much more scale, complexity and freshness.
  * **Streamline machine learning data pipelines:** Get more value from AI. Faster. Deploy and serve features in minutes, instead of weeks or months. Declare features in Python and automatically generate optimized data pipelines — all using tools you love like Jupyter Notebooks.






  Feature Engineering and management doesn’t have to be complicated. Take charge of the entire ML feature lifecycle. With FeatureByte, you can **create, experiment, serve and manage your features in one tool**.


  - Create and share state-of-the-art ML features effortlessly
  - Search and reuse features to create feature lists tailored to your use case

  ``` python

  invoice_view = catalog.get_view("GROCERYINVOICE")

  customer_purchases = invoice_view.groupby("GroceryCustomerGuid").aggregate_over(
      "Amount",
      method="sum",
      feature_names=["CustomerTotalSpent_7d", "CustomerTotalSpent_28d"],
      fill_value=0,
      windows=['7d', '28d']
  )
  customer_purchases.save()
  ```


  - Immediately access historical features through automated backfilling - let FeatureByte handle the complexity of time-aware SQL
  - Experiment on live data at scale, innovating faster
  - Iterate rapidly with different feature lists to create more accurate models

  ``` python

  feature_list = catalog.get_feature_list(
      "200 Features on Active Customers"
  )

  observation_set = catalog.get_observation_table(
      "5M rows of active Customers in 2021-2022"
  )


  training = \
      feature_list.compute_historical_feature_table(
        observation_set,
        name="Training set to predict purchases next 2w"
      )
  ```


  - Deploy AI data pipelines and serve features in minutes
  - Access features with low latency
  - Reduce costs and security risk by performing computations in your existing data platform
  - Ensure data consistency between model training and inferencing

  ``` python

  feature_list = catalog.get_feature_list(
      "200 Features on Active Customers"
  )

  deployment = feature_list.deploy(
      name="Features for customer purchases next 2w",
  )

  deployment.enable()

  deployment.get_online_serving_code(language="sh")
  ```


  - Organize feature engineering assets with domain-specific catalogs
  - Centralize cleaning operations and feature job configurations
  - Differentiate features that are prototype versus production ready
  - Create new versions of your features to handle changes in data
  - Keep full lineage of your training data and features in production
  - Monitor the health of feature pipelines centrally

  ``` python

  items_table = catalog.get_table("GROCERYITEMS")


  items_table.Discount.update_critical_data_info(
      cleaning_operations=[
          fb.MissingValueImputation(
              imputed_value=0
          ),
          fb.ValueBeyondEndpointImputation(
              type="less_than",
              end_point=0,
              imputed_value=0
          ),
      ]
  )
  ```

  Get an [overview of the typical workflow](https://docs.featurebyte.com/latest/about/workflow/) in FeatureByte.


  Discover FeatureByte via its tutorials. All you need is to install the FeatureByte SDK.

  Install FeatureByte SDK with pip:
  ```shell
  pip install featurebyte
  ```
  **Note**: To avoid potential conflicts with other packages we strongly recommend using a [virtual environment](https://docs.python.org/3/tutorial/venv.html) or a [conda environment](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html).

  Sign up for access to the Hosted Tutorial server [here](https://tutorials.featurebyte.com/tutorial/sign-up) and register your credentials with FeatureByte SDK:
  ``` python
  import featurebyte as fb


  fb.register_tutorial_api_token("<api_token>")
  ```
  This will create a "tutorial" profile that uses the hosted tutorial server.
  You can now [download](https://docs.featurebyte.com/latest/get_started/tutorials/overview/#download-tutorials) and run notebooks from the [tutorials](https://docs.featurebyte.com/latest/get_started/tutorials/overview/) section.



  FeatureByte integrates seamlessly with your **Snowflake, Databricks, or Spark** data warehouses, enhancing security and efficiency by bypassing large-scale outbound data transfers. This integration allows feature calculations to be performed within the data warehouse, leveraging scalability, stability, and efficiency.

  <div align="center">
    <img src="https://github.com/featurebyte/featurebyte/blob/main/assets/images/Data%20Warehouse.png" width="600" alt="Warehouse Diagram">
  </div>

  FeatureByte utilizes your data warehouse as a:

  * data source.
  * compute engine to leverage its scalability, stability, and efficiency.
  * storage of partial aggregates (tiles) and precomputed feature values to support feature serving.



  ![FeatureByte Architecture](https://github.com/featurebyte/featurebyte/blob/main/assets/images/system_architecture.png)
  The FeatureByte platform comprises the following components:
  - **FeatureByte SDK** (Python Package): Connects to the API service to provide feature authoring and management functionality through python classes and functions.
  - **FeatureByte Service** (Docker Containers):
    - **API Service**: REST-API service that validates and executes requests, queries data warehouses, and stores data.
    - **Worker**: Executes asynchronous or scheduled tasks.
    - **MongoDB**: Store metadata for created assets.
    - **Redis**: Broker and queue for workers, messenger service for publishing progress updates.
  - **Query Graph Transpiler** (Python Package): Construct data transformation steps as a query graph, which can be transpiled to platform-specific SQL.
  - **Source Tables** (Data Warehouse): Tables used as data sources for feature engineering.
  - **Feature Store** (Data Warehouse): Database that store data used to support feature serving.


  The **FeatureByte Service** can be installed in three different modes:

  * **Local installation:** The easiest way to get started with the FeatureByte SDK. It is a single-user installation that can be used to prototype features locally with your data warehouse.


  * **Hosted on a single server:** A light-weight option to support collaboration and job scheduling with limited scalability and availability. Multiple users can connect to the service using the FeatureByte SDK, and deploy features for production.


  * **High availability installation (coming soon):** The recommended way to run the service in production. Scale to a large number of users and deployed features, and provide highly available services.

  The FeatureByte Service runs on **Docker** for the first two installation modes, and is deployed on a **Kubernetes Cluster** for the high availability installation mode.

  Refer to the [installation](https://docs.featurebyte.com/latest/get_started/installation/) section of the documentation for more details.



  The FeatureByte Python SDK offers a comprehensive set of objects for feature engineering, simplifying the management and manipulation of tables, entities, views, features, feature lists and other necessary objects for feature serving.

  * [**Catalog**](https://docs.featurebyte.com/latest/reference/core/catalog/) objects help you organize your feature engineering assets per domain and maintain clarity and easy access to these assets.
  * [**Entity**](https://docs.featurebyte.com/latest/reference/core/entity/) objects contain metadata on entity types represented or referenced by tables within your data warehouse.
  * [**Table**](https://docs.featurebyte.com/latest/reference/core/table/) objects centralize key metadata about the table type, important columns, default cleaning operations and default feature job configurations.
  * [**View**](https://docs.featurebyte.com/latest/reference/core/view/) objects work like SQL views and are local virtual tables that can be modified and joined to other views to prepare data before feature definition.
  * [**Feature**](https://docs.featurebyte.com/latest/reference/core/feature/) objects contain the logical plan to compute a feature in the form of a feature definition file.
  * [**FeatureList**](https://docs.featurebyte.com/latest/reference/core/feature_list/) objects are collection of Feature objects tailored to meet the needs of a particular use case.

  Refer to the [SDK overview](https://docs.featurebyte.com/latest/about/sdk_overview/) for a complete list of the objects supported by the SDK and the SDK reference for more information about each object.



  The SDK offers an intuitive declarative framework to create feature objects with different signal types, including timing, regularity, stability, diversity, and similarity in addition to the traditional recency, frequency and monetary types.


  Features can be as simple as an entity’s attribute:

  ``` python
  customer_view = catalog.get_view("GROCERYCUSTOMER")

  customer_view["OperatingSystemIsWindows"] = \
      customer_view.BrowserUserAgent.str.contains("Windows")

  uses_windows = customer_view.OperatingSystemIsWindows.as_feature("UsesWindows")
  ```

  Features can be more complex such as aggregations over a window:

  ``` python
  invoice_view = catalog.get_view("GROCERYINVOICE")

  invoices_by_customer = invoice_view.groupby("GroceryCustomerGuid")

  customer_purchases = invoices_by_customer.aggregate_over(
      "Amount",
      method=fb.AggFunc.SUM,
      feature_names=["CustomerTotalSpent_7d", "CustomerTotalSpent_28d"],
      fill_value=0,
      windows=['7d', '28d']
  )
  ```

  To capture more complex signals, features can involve a series of joins and aggregates and be derived from multiple features:

  ``` python

  items_view = catalog.get_view("INVOICEITEMS")
  product_view = catalog.get_view("GROCERYPRODUCT")

  items_view = items_view.join(product_view)

  customer_basket_28d = items_view.groupby(
      by_keys = "GroceryCustomerGuid", category=”ProductGroup”
  ).aggregate_over(
     "TotalCost",
      method=fb.AggFunc.SUM,
      feature_names=["CustomerBasket_28d"],
      windows=['28d']
  )

  customer_view = catalog.get_view("GROCERYCUSTOMER")
  items_view = items_view.join(customer_view)


  state_basket_28d = items_view.groupby(
      by_keys="State", category="ProductGroup"
  ).aggregate_over(
     "TotalCost",
      method=fb.AggFunc.SUM,
      feature_names=["StateBasket_28d"],
      windows=['28d']
  )


  customer_state_similarity_28d = \
      customer_basket_28d["CustomerBasket_28d"].cd.cosine_similarity(
          state_basket_28d["StateBasket_28d"]
      )

  customer_state_similarity_28d.name = \
      "Customer Similarity with purchases in the same state over 28 days"
  customer_state_similarity_28d.save()
  ```


  Once a feature is defined, you can obtain its feature definition file that is the source of truth and provides an explicit outline of the intended operations of the feature declaration, including those inherited but not explicitly declared by you.

  ``` python
  customer_state_similarity_28d.definition
  ```

  Refer to the SDK reference for the [Feature](https://docs.featurebyte.com/latest/reference/core/feature/) object for more information.



  Great Machine Learning models require great training data. Great training data require great features (columns) and great observation data points (rows). Great observation data points are historical data points that replicate the production environment. If predictions are expected to be any time, observation points-in-time should also be any time during a period covering at least one seasonal cycle.

  Observation data points are in FeatureByte in the form of observation sets that combine entity values and any past points-in-time you want to learn from.

  You can choose to get training data as a Pandas DataFrame or as a Table in the feature store that contains metadata on how the table was created for reuse or audit.

  ``` python

  feature_list = catalog.get_feature_list(
      "200 Features on Active Customers"
  )

  customer_state_similarity_28d = catalog.get_feature(
      "Customer Similarity with purchases in the same state over 28 days"
  )
  new_feature_list = fb.FeatureList(
      [feature_list, customer_state_similarity_28d],
      name="Improved feature list with Customer State similarity"
  )

  observation_set = catalog.get_observation_table(
      "5M of active Customers in 2021-2022"
  )

  training_table = new_feature_list.compute_historical_feature_table(
      observation_set,
      name="Improved Data to predict purchases next 2w with 2021-2022 history"
  )

  training_df = training_table.to_pandas()
  ```

  Refer to the SDK reference for the [FeatureList](https://docs.featurebyte.com/latest/reference/core/feature_list/), [ObservationTable](https://docs.featurebyte.com/latest/reference/core/observation_table/) and [HistoricalFeatureTable](https://docs.featurebyte.com/latest/reference/core/historical_feature_table/) objects, for more information.



  Once a feature list is deployed, the FeatureByte Service automatically orchestrates the pre-computation of feature values and stores them in an online feature store for online and batch serving.

  ``` python

  feature_list = catalog.get_feature_list(
      "200 Features on Active Customers"
  )


  print(feature_list.production_ready_fraction)

  my_deployment = feature_list.deploy(
      name="Deployment of 200 Features to predict customers purchases amount next 2 weeks",
  )

  my_deployment.enable()
  ```

  Use the REST API service to retrieve feature values from the online feature store for online serving or use the SDK to retrieve batch of feature values from the online feature store for batch serving.


  For online serving, the Deployment object provides REST API service templates that can be used to serve features. Python or shell script templates for the REST API service are retrieved from the Deployment object.

  Get online scoring code as a Python script:
  ``` python
  deployment = catalog.get_deployment(
      "Deployment of 200 Features to predict customers purchases amount next 2 weeks"
  )
  deployment.get_online_serving_code(language="python")
  ```

  Get online scoring code as a Shell script:
  ``` python
  deployment.get_online_serving_code(language="sh")
  ```


  For batch serving, the Deployment object is used to retrieve feature values for a batch request table containing entities values.

  ``` python
  from datetime import datetime
  batch_features = deployment.compute_batch_feature_table(
      batch_request_table=batch_request_table,
      batch_feature_table_name=
          "Data to predict customers purchases next 2 w as of " +
          datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')
  )

  batch_features_df = batch_features.to_pandas()
  ```

  Refer to the SDK reference for the [Deployment](https://docs.featurebyte.com/latest/reference/core/deployment/), [BatchRequestTable](https://docs.featurebyte.com/latest/reference/core/batch_request_table/) and [BatchFeatureTable](https://docs.featurebyte.com/latest/reference/core/batch_feature_table/) objects, for more information.




  You can see the list of available releases on the [Change Log](https://github.com/featurebyte/featurebyte/blob/main/CHANGELOG.md) page.
  Releases are versioned using the [Semantic Versions](https://semver.org/) specification.



  [![License](https://img.shields.io/badge/license-elastic%202.0-yellowgreen)](https://github.com/featurebyte/featurebyte/blob/main/LICENSE)

  This project is licensed under the terms of the `Elastic License 2.0` license. See [LICENSE](https://github.com/featurebyte/featurebyte/blob/main/LICENSE) for more details.


  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](code_of_conduct.md)

  All contributions are welcomed. Please adhere to the [Code of Conduct](https://github.com/featurebyte/featurebyte/blob/main/CODE_OF_CONDUCT.md) and read the
  [Developer's Guide](https://github.com/featurebyte/featurebyte/blob/main/CONTRIBUTING.md) to get started.


pkgId: a132cdab42a2995499d6cf9b3506c85b0a171b3ef8c3a255b6ac2583dfc437aa
name: python-feautils-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for feautils
url: https://pypi.org/project/feautils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-feautils-0.0.8-1.src.rpm
location_href: Packages/python-feautils-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  Useful code snippets and helper methods that Future Energy Associates frequently use for data science.

  Install with `pip install feautils`



  Publishing a package is now done with the `Trusted Publisher Management` workflow via github. See this example for more details

  https://medium.com/@blackary/publishing-a-python-package-from-github-to-pypi-in-2024-a6fb8635d45d


pkgId: 99bedd53bdcacd0e7c3ef415e2ee70dd0bb946e48162ab9ae64779898bc1932a
name: python-fedibooster-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for fedibooster
url: https://pypi.org/project/fedibooster/
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fedibooster-1.1.1-1.src.rpm
location_href: Packages/python-fedibooster-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  It's ease to install fedibooster from Pypi using the following command::
      pip install fedibooster
  Once installed fedibooster can be started by typing ``fedibooster`` into the command line.


pkgId: 80f9f290bcff5ae361afcb1572e85411ca0456d28014e250b7f919dcc408c93c
name: python-feffery-dash-utils-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for feffery-dash-utils
url: https://github.com/CNFeffery/feffery-dash-utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-feffery-dash-utils-0.1.5-1.src.rpm
location_href: Packages/python-feffery-dash-utils-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  简体中文 | [English](./README-en_US.md)

  包含一系列用于提升`Dash`应用开发效率的工具函数/工具类。

  <div>

  [![GitHub](https://shields.io/badge/license-MIT-informational)](https://github.com/CNFeffery/feffery-antd-components/blob/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/feffery-dash-utils.svg?color=dark-green)](https://pypi.org/project/feffery-dash-utils/)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

  </div>



  [安装](#install)<br>
  [配合 vscode 插件](#with-vscode)<br>
  [已有工具函数/工具类列表](#utils-list)<br>
  [参与贡献](#contribute)<br>
  [开发计划](#roadmap)

  <a name="install" ></a>



  ```bash
  pip install feffery-dash-utils -U
  ```

  <a name="with-vscode" ></a>



  在`vscode`中配合插件[feffery-dash-snippets](https://github.com/CNFeffery/feffery-dash-snippets)可快捷实现对各工具函数/工具类的快捷导入，在`Python`文件中输入`utils:`即可触发相关快捷命令。

  <a name="utils-list" ></a>



  - style_utils
    - [style()](#style)<br>
  - tree_utils
    - [TreeManager](#TreeManager)<br>
      - [update_tree_node()](#update_tree_node)<br>
      - [add_node_before()](#add_node_before)<br>
      - [add_node_after()](#add_node_after)<br>
      - [delete_node()](#delete_node)<br>
      - [get_node()](#get_node)<br>
  - i18n_utils
    - [Translator](#Translator)

  <a name="style" ></a>



  用于快捷生成`Dash`组件的`style`参数字典，内置了绝大多数小驼峰命名格式的常用`css`属性，在常见 ide 中将鼠标悬停于参数名之上可查看对应的中英文属性功能介绍，内容基于`w3cschool`自动生成。

  > 使用示例

  ```Python
  from feffery_dash_utils.style_utils import style


  fac.AntdText(
      '测试',
      style=style(
          fontSize=16,
          color='red'
      )
  )


  fac.AntdText(
      '测试',
      style=style(
          """
  .IvkwhTOsc9wu6RdvHESR .yK52Sq0w7wspWaS28YNl {
      width: 91.46%;
      margin-left: 4.27%;
      margin-bottom: 5%;
      position: relative;
  }"""
      )
  )


  fac.AntdText(
      '测试',
      style=style(
          """
  .IvkwhTOsc9wu6RdvHESR .yK52Sq0w7wspWaS28YNl {
      width: 91.46%;
      margin-left: 4.27%;
      margin-bottom: 5%;
      position: relative;
  }""",
          fontSize=16,
          color='red'
      )
  )
  ```

  <a name="TreeManager" ></a>



  用于对类似`AntdTree`、`AntdTreeSelect`等树形组件所依赖的树形结构数据进行快捷管理操作，具体包含的方法有：

  <a name="update_tree_node" ></a>



  用于对树形结构数据中指定`key`对应节点进行整体或增量更新。

  > 使用示例

  ```Python
  from feffery_dash_utils.tree_utils import TreeManager


  demo_tree = [
      {
          'title': '节点1',
          'key': '节点1',
          'children': [
              {
                  'title': '节点1-1',
                  'key': '节点1-1',
                  'children': [
                      {
                          'title': '节点1-1-1',
                          'key': '节点1-1-1',
                      },
                      {
                          'title': '节点1-1-2',
                          'key': '节点1-1-2',
                      },
                  ],
              }
          ],
      },
      {'title': '节点2', 'key': '节点2'},
  ]


  TreeManager.update_tree_node(
      demo_tree,
      '节点1-1',
      {'title': '节点1-1', 'key': '节点1-1'},
  )


  TreeManager.update_tree_node(
      demo_tree,
      '节点1-1',
      {'title': '节点1-1new'},
      'overlay',
  )
  ```

  <a name="add_node_before" ></a>



  在树形结构数据中指定`key`对应节点之前插入平级新节点。

  > 使用示例

  ```Python
  from feffery_dash_utils.tree_utils import TreeManager


  demo_tree = [
      {
          'title': '节点1',
          'key': '节点1',
          'children': [
              {
                  'title': '节点1-1',
                  'key': '节点1-1',
                  'children': [
                      {
                          'title': '节点1-1-1',
                          'key': '节点1-1-1',
                      },
                      {
                          'title': '节点1-1-2',
                          'key': '节点1-1-2',
                      },
                  ],
              }
          ],
      },
      {'title': '节点2', 'key': '节点2'},
  ]


  TreeManager.add_node_before(
      demo_tree,
      '节点1-1',
      {'title': '节点1-0', 'key': '节点1-0'},
  )
  ```

  <a name="add_node_after" ></a>



  在树形结构数据中指定`key`对应节点之后插入平级新节点。

  > 使用示例

  ```Python
  from feffery_dash_utils.tree_utils import TreeManager


  demo_tree = [
      {
          'title': '节点1',
          'key': '节点1',
          'children': [
              {
                  'title': '节点1-1',
                  'key': '节点1-1',
                  'children': [
                      {
                          'title': '节点1-1-1',
                          'key': '节点1-1-1',
                      },
                      {
                          'title': '节点1-1-2',
                          'key': '节点1-1-2',
                      },
                  ],
              }
          ],
      },
      {'title': '节点2', 'key': '节点2'},
  ]


  TreeManager.add_node_after(
      demo_tree,
      '节点1-1',
      {'title': '节点1-2', 'key': '节点1-2'},
  )
  ```

  <a name="delete_node" ></a>



  删除树形结构数据中指定`key`对应节点。

  > 使用示例

  ```Python
  from feffery_dash_utils.tree_utils import TreeManager


  demo_tree = [
      {
          'title': '节点1',
          'key': '节点1',
          'children': [
              {
                  'title': '节点1-1',
                  'key': '节点1-1',
                  'children': [
                      {
                          'title': '节点1-1-1',
                          'key': '节点1-1-1',
                      },
                      {
                          'title': '节点1-1-2',
                          'key': '节点1-1-2',
                      },
                  ],
              }
          ],
      },
      {'title': '节点2', 'key': '节点2'},
  ]


  TreeManager.delete_node(demo_tree, '节点2')
  ```

  <a name="get_node" ></a>



  查询树形结构数据中指定`key`对应节点。

  > 使用示例

  ```Python
  from feffery_dash_utils.tree_utils import TreeManager


  demo_tree = [
      {
          'title': '节点1',
          'key': '节点1',
          'children': [
              {
                  'title': '节点1-1',
                  'key': '节点1-1',
                  'children': [
                      {
                          'title': '节点1-1-1',
                          'key': '节点1-1-1',
                      },
                      {
                          'title': '节点1-1-2',
                          'key': '节点1-1-2',
                      },
                  ],
              }
          ],
      },
      {'title': '节点2', 'key': '节点2'},
  ]


  TreeManager.get_node(demo_tree, '节点1-1')


  TreeManager.get_node(demo_tree, '节点1-666')
  ```

  <a name="Translator" ></a>



  用于在`Dash`应用中快捷构建国际化多语种方案，基于前端`cookies`和本地国际化配置文件驱动。

  > 使用示例

  示例应用见[i18n_test_app.py](/tests/i18n_utils/i18n_test_app.py)、[i18n_multi_test_app.py](/tests/i18n_utils/i18n_multi_test_app.py)，参考配置文件见[locales.json](/tests/i18n_utils/locales.json)、[locales1.json](/tests/i18n_utils/multi_locales/locales1.json)、[locales2.json](/tests/i18n_utils/multi_locales/locales2.json)

  <a name="contribute" ></a>



  ```bash
  git clone https://github.com/CNFeffery/feffery-dash-utils.git
  cd feffery-dash-utils

  pip install -r requirements/dev.txt
  ```

  <a name="roadmap" ></a>



  - [ ] 样式相关工具函数子模块`style_utils`
    - [x] `style`参数编写辅助函数`style()`
  - [ ] 布局相关工具函数子模块`layout_utils`
  - [ ] 路由相关工具函数子模块`router_utils`
  - [ ] 模板相关工具函数子模块`template_utils`
  - [ ] 表格相关工具函数子模块`table_utils`
  - [ ] 回调函数相关工具函数子模块`callback_utils`
  - [ ] 树形处理相关工具函数子模块`tree_utils`
    - [x] 树形数据结构管理类`TreeManager`
      - [x] 树节点更新函数`update_tree_node()`
      - [x] 树节点前置插入函数`add_node_before()`
      - [x] 树节点后置插入函数`add_node_after()`
      - [x] 树节点删除函数`delete_node()`
      - [x] 树节点查询函数`get_node()`
  - [ ] 主题样式相关工具函数子模块`theme_utils`
  - [ ] 国际化相关工具函数子模块`i18n_utils`
    - [x] 文案内容快捷国际化操作类`Translator`


pkgId: 4c3b6dc6078d84dcc9776a86be375cd592be42eb2bb43e12896a0d0b02bb76ef
name: python-feffery-leaflet-components-help
arch: noarch
version: 0.1.0rc9
epoch: 0
release: 1
summary: Development documents and examples for feffery-leaflet-components
url: https://github.com/CNFeffery/feffery-leaflet-components
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-feffery-leaflet-components-0.1.0rc9-1.src.rpm
location_href: Packages/python-feffery-leaflet-components-help-0.1.0rc9-1.noarch.rpm
checksum_type: sha256
description:
  > 本项目处于早期活跃开发测试阶段

  <p align="center">
  	<img src="./flc-logo.svg" height=200></img>
  </p>
  <h1 align="center">feffery-leaflet-components</h1>
  <div align="center">


  [![GitHub](https://img.shields.io/github/license/plotly/dash.svg?color=dark-green)](https://github.com/plotly/dash/blob/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/feffery-leaflet-components.svg?color=dark-green)](https://pypi.org/project/feffery-leaflet-components/)
  [![Downloads](https://pepy.tech/badge/feffery-leaflet-components)](https://pepy.tech/project/feffery-leaflet-components)
  [![Downloads](https://pepy.tech/badge/feffery-leaflet-components/month)](https://pepy.tech/project/feffery-leaflet-components)

  </div>

  `feffery-components`计划子项目，`Plotly Dash`第三方组件库，基于`Leaflet`，将更好用的地图交互及可视化组件引入`Dash`的世界🥳，最新版本：`0.1.0-rc8`



  ```bash
  pip install feffery-leaflet-components -U
  ```



  ```bash
  pip install feffery-leaflet-components --pre -U
  ```



  ```Python


  app = dash.Dash(serve_locally=False)
  ```



  <a href='http://flc.feffery.tech/' target='_blank'>文档地址</a>


pkgId: 0f17a5166abe9d7ad3ffd4baa1f7567b64ac765a8e02459aa8dbc0061960206f
name: python-fence-llm-help
arch: noarch
version: 0.0.28
epoch: 0
release: 1
summary: Development documents and examples for fence-llm
url: https://github.com/WouterDurnez/fence
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fence-llm-0.0.28-1.src.rpm
location_href: Packages/python-fence-llm-help-0.0.28-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://github.com/WouterDurnez/fence/blob/main/docs/logo.png?raw=true" alt="tests" height="200"/>

  [![Python](https://img.shields.io/pypi/pyversions/fence-llm)](https://pypi.org/project/fence-llm/)
  [![Test Status](https://github.com/WouterDurnez/fence/actions/workflows/ci-pipeline.yaml/badge.svg)](https://github.com/WouterDurnez/fence/actions)
  [![codecov](https://codecov.io/gh/WouterDurnez/fence/branch/main/graph/badge.svg?token=QZQZQZQZQZ)](https://codecov.io/gh/WouterDurnez/fence)
  [![PyPI version](https://badge.fury.io/py/fence-llm.svg)](https://badge.fury.io/py/fence-llm)
  [![Documentation Status](https://readthedocs.org/projects/fence-llm/badge/?version=latest)](https://fence-llm.readthedocs.io/en/latest/?badge=latest)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](code_of_conduct.md)



  `Fence` is a simple, lightweight library for LLM communication. A lot of the functionality was inspired by/derived of LangChain (the OG LLM package) basics, since that's how the package was born - as a stripped down version of LangChain functionality, with cooler names.



  The simple answer: by accident. The slightly longer answer: LangChain used to be (is?) a pretty big package with a ton of dependencies. The upside is that it's powerful for PoC purposes, because it has it all.

  The downsides:

  - It's **_big_**. It takes up a lot of space (which can be an issue in some environments/runtimes), often for functionality that isn't needed.
  - It's fairly **_complex_**. It's a big package with a lot of functionality, which can be overwhelming for new users.
  - It **_wasn't exactly dependable_** in an industrial setting before. Version jumps were common, and the package was often broken after a new release.

  As a result, many developers (particularly those working in large production environments) have advocated for more lightweight, custom functionality that favors stability and robustness.



  Since our work was in a production environment, mostly dealing with Bedrock, we just started building some **basic components** from scratch. We needed a way to communicate with our models, which turned out to as the `Link` class (_wink wink_).
  Then, some other things were added left and right, and this eventually turned into a miniature package. Not in small part because it was fun to go down this road. But mostly because it strikes the right balance between convenience and flexiblity.

  Naturally, it's nowhere as powerful as, for instance, LangChain. If you want to build a quick PoC with relatively complex logic, maybe go for the OG instead. If you want to be set on your way with a simple, lightweight package that's easy to understand and extend, Fence might be the way to go.



  Fence just has a few basic components. See the [notebooks](notebooks) for examples on how to use them. Documentation is coming soon, but for now, you can check out the [source code](fence) for more details.



  You can install Fence from PyPI:

  ```bash
  pip install fence-llm
  ```



  Here's a hello world example:

  ```python
  from fence import Link
  from fence.templates.string import StringTemplate
  from fence.models.openai import GPT4omini


  link = Link(
      model=GPT4omini(),
      template=StringTemplate("Write a poem about the value of a {topic}!"),
      name='hello_world_link'
  )


  output = link.run(topic='fence')['state']
  print(output)
  ```

  This will output something like:

  ```bash
  [2024-10-04 17:45:15] [ℹ️ INFO] [links.run:203]              Executing <hello_world_link> Link
  Sturdy wood and nails,
  Boundaries draw peace and calm,
  Guarding hearts within.
  ```

  Much wow, very next level. There's more in the [notebook](notebooks) section, with a _lot_ more to cover!





  - **Uniform interface for `LLMs`**. Since our main use case was Bedrock, we built Fence to work with Bedrock models. However, it also has openAI support, and it's easy to extend to other models (contributors welcome!)
  - **Links and Chains** help you build complex pipelines with multiple models. This is a feature that's been around since LangChain, and it's still here. You can parametrize templates, and pass the output of one model to another.
  - **Template classes** that handle the basics, and that work across models (e.g., a MessageTemplate can be sent to a Bedrock Claude3 model, _or_ to an openAI model - system/user/assistant formatting is handled under the hood).
  - **Agents** to move on to the sweet, sweet next level of LLM orchestration. Built using the ReAct pattern.
  - **Basic utils on board** for typical tasks like retries, parallelization, logging, output parsers, etc.



  It's obviously not as powerful as some of the other packages out there, that hold tons more of features. We're also not trying to fall into the trap of building 'yet another framework' (insert [XKCD](https://xkcd.com/927/) here), so we're trying to guard our scope. If you need a lot of bells and whistles, you might want to look at any of these:

  - [`LangChain`](https://www.langchain.com/)

  The OG, no explanation needed.

  - [`Griptape`](https://www.griptape.ai)

  A more recent package, with a lot of cool features! Great for building PoCs, too. Built by ex-AWS folks, and promises to be a lot more industry-oriented.



  - [ ] Add more models (e.g., native Anthropic models)
  - [ ] Add more tests 😬
  - [ ] Add more notebook tutorials to showcase features



  We welcome contributions! Check out the [CONTRIBUTING.md](CONTRIBUTING.md) for more details.


pkgId: 1957e6c0faf367f7bbf17b1256932e819f7e70019c4da5b8646dc62743f3c8bb
name: python-fennel-ai-help
arch: noarch
version: 1.5.60
epoch: 0
release: 1
summary: Development documents and examples for fennel-ai
url: https://pypi.org/project/fennel-ai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fennel-ai-1.5.60-1.src.rpm
location_href: Packages/python-fennel-ai-help-1.5.60-1.noarch.rpm
checksum_type: sha256
description:
  Fennel is a modern realtime feature engineering platform written in Rust and this repo contains the Python client to talk to the server.
  Quick Links:
  - [Documentation](https://docs.fennel.ai/)
  - [Fennel Website](https://fennel.ai/)
  - [Main Concepts Behind Fennel](https://docs.fennel.ai/concepts/introduction/)
  - [Quickstart Tutorial](https://docs.fennel.ai/getting-started/quickstart/)


pkgId: 80047ec0d35b755b580894fc3704339dabe666d2346c8c12dc02f3e062738d78
name: python-fev-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for fev
url: https://github.com/autogluon/fev
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fev-0.2.1-1.src.rpm
location_href: Packages/python-fev-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  A lightweight library that makes it easy to benchmark time series forecasting models.

  - Extensible: Easy to define your own forecasting tasks and benchmarks.
  - Reproducible: Ensures that the results obtained by different users are comparable.
  - Easy to use: Compatible with most popular forecasting libraries.
  - Minimal dependencies: Just a thin wrapper on top of 🤗[`datasets`](https://huggingface.co/docs/datasets/en/index).



  Existing forecasting benchmarks usually fall into one of two categories:

  - Standalone datasets without any supporting infrastructure. These provide no guarantees that the results obtained by different users are comparable. For example, changing the start date or duration of the forecast horizon totally changes the meaning of the scores.
  - Bespoke end-to-end systems that combine models, datasets and forecasting tasks. Such packages usually come with lots of dependencies and assumptions, which makes extending or integrating these libraries into existing systems difficult.

  `fev` aims for the middle ground - it provides the core benchmarking functionality without introducing unnecessary constraints or bloated dependencies. The library supports point & probabilistic forecasting, different types of covariates, as well as all popular forecasting metrics.


  ```
  pip install fev
  ```



  Create a task from a dataset stored on Hugging Face Hub
  ```python
  import fev

  task = fev.Task(
      dataset_path="autogluon/chronos_datasets",
      dataset_config="monash_kdd_cup_2018",
      horizon=12,
  )
  ```
  Load data available as input to the forecasting model
  ```python
  past_data, future_data = task.get_input_data()
  ```
  - `past_data` contains the past data before the forecast horizon (item ID, past timestamps, target, all covariates).
  - `future_data` contains future data that is known at prediction time (item ID, future timestamps, and known covariates)

  Make predictions
  ```python
  def naive_forecast(y: list, horizon: int) -> list:
      return [y[-1] for _ in range(horizon)]

  predictions = []
  for ts in past_data:
      predictions.append(
          {"predictions": naive_forecast(y=ts[task.target_column], horizon=task.horizon)}
      )
  ```
  Get an evaluation summary
  ```python
  task.evaluation_summary(predictions, model_name="naive")


























  ```
  The evaluation summary contains all information necessary to uniquely identify the forecasting task.

  Multiple evaluation summaries produced by different models on different tasks can be aggregated into a single table.
  ```python

  summaries = "https://raw.githubusercontent.com/autogluon/fev/refs/heads/main/benchmarks/example/results/results.csv"
  fev.leaderboard(summaries)






  ```


  - Quick start tutorial: [docs/tutorials/quickstart.ipynb](./docs/tutorials/quickstart.ipynb).
  - An in-depth walkthrough of the library: [docs/tutorials/in-depth.ipynb](./docs/tutorials/in-depth.ipynb).

  Examples of model implementations compatible with `fev` are available in [`examples/`](./examples/).



  We host leaderboards obtained using `fev` under https://huggingface.co/spaces/autogluon/fev-leaderboard.

  Currently, the leaderboard includes the results from the Benchmark II introduced in [Chronos: Learning the Language of Time Series](https://arxiv.org/abs/2403.07815). We expect to extend this list in the future.

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


pkgId: ea417c6d3e9e2551dd51adafb3a0ad92a1f2b4fb13444494fa67cb5c20e1901b
name: python-fewsats-help
arch: noarch
version: 0.0.6
epoch: 0
release: 1
summary: Development documents and examples for fewsats
url: https://github.com/Fewsats/fewsats-python
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fewsats-0.0.6-1.src.rpm
location_href: Packages/python-fewsats-help-0.0.6-1.noarch.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

  This file will become your README and also the index of your
  documentation.



  If you are new to using `nbdev` here are some useful pointers to get you
  started.



  ``` sh

  $ pip install -e .





  $ nbdev_prepare
  ```





  Install latest from the GitHub
  [repository](https://github.com/Fewsats/fewsats-python):

  ``` sh
  $ pip install git+https://github.com/Fewsats/fewsats-python.git
  ```

  or from [conda](https://anaconda.org/Fewsats/fewsats-python)

  ``` sh
  $ conda install -c Fewsats fewsats
  ```

  or from [pypi](https://pypi.org/project/fewsats-python/)

  ``` sh
  $ pip install fewsats
  ```



  Documentation can be found hosted on this GitHub
  [repository](https://github.com/Fewsats/fewsats-python)’s
  [pages](https://Fewsats.github.io/fewsats-python/). Additionally you can
  find package manager specific guidelines on
  [conda](https://anaconda.org/Fewsats/fewsats-python) and
  [pypi](https://pypi.org/project/fewsats-python/) respectively.



  The library allows you to check which payment methods you have available
  and to pay for an offer.

  ``` python
  from fewsats.core import *
  ```

  ``` python
  fs = Client()
  fs.get_payment_methods()
  ```

      [{'id': 2,
        'last4': '0355',
        'brand': 'mastercard',
        'exp_month': 12,
        'exp_year': 2026,
        'is_default': False},
       {'id': 4,
        'last4': '7346',
        'brand': 'visa',
        'exp_month': 12,
        'exp_year': 2028,
        'is_default': True}]


pkgId: 50647436c408daf701bd67f7142fc63282545ee6f1deeba7d986b05d4a4560aa
name: python-ffmpeg-normalize-help
arch: noarch
version: 1.31.0
epoch: 0
release: 1
summary: Development documents and examples for ffmpeg-normalize
url: https://github.com/slhck/ffmpeg-normalize
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ffmpeg-normalize-1.31.0-1.src.rpm
location_href: Packages/python-ffmpeg-normalize-help-1.31.0-1.noarch.rpm
checksum_type: sha256
description:
  You need Python 3.9 or higher, and ffmpeg.

  - ffmpeg 5.x is required, ffmpeg 6.x is recommended (it fixes [a bug for short files](https://github.com/slhck/ffmpeg-normalize/issues/87))
  - Download a [static build](https://ffmpeg.org/download.html) for your system
  - Place the `ffmpeg` executable in your `$PATH`, or specify the path to the binary with the `FFMPEG_PATH` environment variable in `ffmpeg-normalize`
  For instance, under Linux:
  ```bash
  wget https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz
  mkdir -p ffmpeg
  tar -xf ffmpeg-release-amd64-static.tar.xz -C ffmpeg --strip-components=1
  sudo cp ffmpeg/ffmpeg /usr/local/bin
  sudo cp ffmpeg/ffprobe /usr/local/bin
  sudo chmod +x /usr/local/bin/ffmpeg /usr/local/bin/ffprobe
  ```
  For Windows, follow [this guide](https://www.wikihow.com/Install-FFmpeg-on-Windows).
  For macOS and Linux, you can also use [Homebrew](https://brew.sh):
  ```bash
  brew install ffmpeg
  ```
  Note that using distribution packages (e.g., `apt install ffmpeg`) is not recommended, as these are often outdated.

  For Python 3 and pip:
  ```bash
  pip3 install ffmpeg-normalize
  ```
  Or download this repository, then run `pip3 install .`.
  To later upgrade to the latest version, run `pip3 install --upgrade ffmpeg-normalize`.

  This tool provides shell completions for bash and zsh. To install them:
  <!--
  Note to self: Generate the shtab ones with:
    shtab --shell=bash -u ffmpeg_normalize.__main__.create_parser > completions/ffmpeg-normalize-shtab.bash
    shtab --shell=zsh -u ffmpeg_normalize.__main__.create_parser > completions/ffmpeg-normalize-shtab.zsh
  but these are not properly working yet.
  -->

  If you have [`bash-completion`](https://github.com/scop/bash-completion) installed, you can just copy your new completion script to the `/usr/local/etc/bash_completion.d` directory.
  ```bash
  curl -L https://raw.githubusercontent.com/slhck/ffmpeg-normalize/master/completions/ffmpeg-normalize-completion.bash \
    -o /usr/local/etc/bash_completion.d/ffmpeg-normalize
  ```
  Without bash-completion, you can manually install the completion script:
  ```bash

  mkdir -p ~/.bash_completions.d

  curl -L https://raw.githubusercontent.com/slhck/ffmpeg-normalize/master/completions/ffmpeg-normalize-completion.bash \
    -o ~/.bash_completions.d/ffmpeg-normalize

  echo 'source ~/.bash_completions.d/ffmpeg-normalize' >> ~/.bashrc
  ```

  Download the completion script and place it in the default `site-functions` directory:
  ```bash
  curl -L https://raw.githubusercontent.com/slhck/ffmpeg-normalize/master/completions/ffmpeg-normalize.zsh \
    -o /usr/local/share/zsh/site-functions/
  ```
  You may choose any other directory that is in your `$FPATH` variable.
  Make sure your `.zshrc` file contains `autoload -Uz compinit && compinit`.

  You can use the pre-built image from Docker Hub:
  ```bash
  docker run -v "$(pwd):/tmp" -it slhck/ffmpeg-normalize
  ```
  Alternatively, download this repository and run
  ```bash
  docker build -t ffmpeg-normalize .
  ```
  Then run the container with:
  ```bash
  docker run  -v "$(pwd):/tmp" -it ffmpeg-normalize
  ```
  This will mount your current directory to the `/tmp` directory inside the container. Everything else works the same way as if you had installed the program locally. For example, to normalize a file:
  ```bash
  docker run  -v "$(pwd):/tmp" -it ffmpeg-normalize /tmp/yourfile.mp4 -o /tmp/yourfile-normalized.wav
  ```
  You will then find the normalized file in your current directory.

  Please read this section for a high level introduction.
  **What does the program do?**
  The program takes one or more input files and, by default, writes them to a folder called `normalized`, using an `.mkv` container. All audio streams will be normalized so that they have the same (perceived) volume according to the EBU R128 standard. This is done by analyzing the audio streams and applying a filter to bring them to a target level. Under the hood, the program uses ffmpeg's `loudnorm` filter to do this.
  **How do I specify the input?**
  Just give the program one or more input files as arguments. It works with most media files, including video files.
  **How do I specify the output?**
  You don't have to specify an output file name (the default is `normalized/<input>.mkv`), but if you want to override it, you can specify one output file name for each input file with the `-o` option. In this case, the container format (e.g. `.wav`) will be inferred from the file name extension that you've given.
  Example:
  ```bash
  ffmpeg-normalize 1.wav 2.wav -o 1-normalized.wav 2-normalized.wav
  ```
  Note that if you don't specify the output file name for an input file, the container format will be MKV, and the output will be written to `normalized/<input>.mkv`. The reason for choosing the MKV container is that it can handle almost any codec combination.
  Using the `-ext` option, you can supply a different output extension common to all output files, e.g. `-ext m4a`. However, you need to make sure that the container supports the codecs used for the output (see below).
  **What will get normalized?**
  By default, all streams from the input file will be written to the output file. For example, if your input is a video with two language tracks and a subtitle track, both audio tracks will be normalized independently. The video and subtitle tracks will be copied over to the output file.
  **How will the normalization be done?**
  The normalization will be performed according to the EBU R128 algorithm with the [`loudnorm` filter](https://ffmpeg.org/ffmpeg-filters.html#loudnorm) from FFmpeg, which was [originally written by Kyle Swanson](https://k.ylo.ph/2016/04/04/loudnorm.html). It will bring the audio to a specified target level. This ensures that multiple files normalized with this filter will have the same perceived loudness.
  **What codec is chosen?**
  The default audio encoding method is uncompressed PCM (`pcm_s16le`) to avoid introducing compression artifacts. This will result in a much higher bitrate than you might want, for example if your input files are MP3s.
  Some containers (like MP4) also cannot handle PCM audio. If you want to use such containers and/or keep the file size down, use `-c:a` and specify an audio codec (e.g., `-c:a aac` for ffmpeg's built-in AAC encoder).

  Supply one or more input files, and optionally, output file names:
  ```bash
  ffmpeg-normalize input [input ...][-h][-o OUTPUT [OUTPUT ...]] [options]
  ```
  Example:
  ```bash
  ffmpeg-normalize 1.wav 2.wav -o 1-normalized.m4a 2-normalized.m4a -c:a aac -b:a 192k
  ```
  For more information on the options (`[options]`) available, run `ffmpeg-normalize -h`, or read on.

  [Read the examples on the wiki.](https://github.com/slhck/ffmpeg-normalize/wiki/examples)


  - `input`: Input media file(s)
  - `-o OUTPUT [OUTPUT ...], --output OUTPUT [OUTPUT ...]`: Output file names.
      Will be applied per input file.
      If no output file name is specified for an input file, the output files
      will be written to the default output folder with the name `<input>.<ext>`, where `<ext>` is the output extension (see `-ext` option).
      Example: `ffmpeg-normalize 1.wav 2.wav -o 1n.wav 2n.wav`
  - `-of OUTPUT_FOLDER, --output-folder OUTPUT_FOLDER`: Output folder (default: `normalized`)
      This folder will be used for input files that have no explicit output name specified.

  - `-f, --force`: Force overwrite existing files
  - `-d, --debug`: Print debugging output
  - `-v, --verbose`: Print verbose output
  - `-q, --quiet`: Only print errors
  - `-n, --dry-run`: Do not run normalization, only print what would be done
  - `-pr`, `--progress`: Show progress bar for files and streams
  - `--version`: Print version and exit

  - `-nt {ebu,rms,peak}, --normalization-type {ebu,rms,peak}`: Normalization type (default: `ebu`).
      EBU normalization performs two passes and normalizes according to EBU R128.
      RMS-based normalization brings the input file to the specified RMS level.
      Peak normalization brings the signal to the specified peak level.
  - `-t TARGET_LEVEL, --target-level TARGET_LEVEL`: Normalization target level in dB/LUFS (default: -23).
      For EBU normalization, it corresponds to Integrated Loudness Target in LUFS. The range is -70.0 - -5.0.
      Otherwise, the range is -99 to 0.
  - `-p, --print-stats`: Print loudness statistics for both passes formatted as JSON to stdout.

  - `-lrt LOUDNESS_RANGE_TARGET, --loudness-range-target LOUDNESS_RANGE_TARGET`: EBU Loudness Range Target in LUFS (default: 7.0).
      Range is 1.0 - 50.0.
  - `--keep-loudness-range-target`: Keep the input loudness range target to allow for linear normalization.
  - `--keep-lra-above-loudness-range-target`: Keep input loudness range above loudness range target.
      Can be used as an alternative to `--keep-loudness-range-target` to allow for linear normalization.
  - `-tp TRUE_PEAK, --true-peak TRUE_PEAK`: EBU Maximum True Peak in dBTP (default: -2.0).
      Range is -9.0 - +0.0.
  - `--offset OFFSET`: EBU Offset Gain (default: 0.0).
      The gain is applied before the true-peak limiter in the first pass only. The offset for the second pass will be automatically determined based on the first pass statistics.
      Range is -99.0 - +99.0.
  - `--lower-only`: Whether the audio should not increase in loudness.
      If the measured loudness from the first pass is lower than the target loudness then normalization pass will be skipped for the measured audio source.
  - `--auto-lower-loudness-target`: Automatically lower EBU Integrated Loudness Target.
      Automatically lower EBU Integrated Loudness Target to prevent falling back to dynamic filtering.
      Makes sure target loudness is lower than measured loudness minus peak loudness (input_i - input_tp) by a small amount.
  - `--dual-mono`: Treat mono input files as "dual-mono".
      If a mono file is intended for playback on a stereo system, its EBU R128 measurement will be perceptually incorrect. If set, this option will compensate for this effect. Multi-channel input files are not affected by this option.
  - `--dynamic`: Force dynamic normalization mode.
      Instead of applying linear EBU R128 normalization, choose a dynamic normalization. This is not usually recommended.
      Dynamic mode will automatically change the sample rate to 192 kHz. Use `-ar`/`--sample-rate` to specify a different output sample rate.

  - `-c:a AUDIO_CODEC, --audio-codec AUDIO_CODEC`: Audio codec to use for output files.
      See `ffmpeg -encoders` for a list.
      Will use PCM audio with input stream bit depth by default.
  - `-b:a AUDIO_BITRATE, --audio-bitrate AUDIO_BITRATE`: Audio bitrate in bits/s, or with K suffix.
      If not specified, will use codec default.
  - `-ar SAMPLE_RATE, --sample-rate SAMPLE_RATE`: Audio sample rate to use for output files in Hz.
      Will use input sample rate by default, except for EBU normalization, which will change the input sample rate to 192 kHz.
  - `-ac`, `--audio-channels`: Set the number of audio channels. If not specified, the input channel layout will be used. This is equivalent to `-ac` in ffmpeg.
  - `-koa, --keep-original-audio`: Copy original, non-normalized audio streams to output file
  - `-prf PRE_FILTER, --pre-filter PRE_FILTER`: Add an audio filter chain before applying normalization.
      Multiple filters can be specified by comma-separating them.
  - `-pof POST_FILTER, --post-filter POST_FILTER`: Add an audio filter chain after applying normalization.
      Multiple filters can be specified by comma-separating them.
      For EBU, the filter will be applied during the second pass.

  - `-vn, --video-disable`: Do not write video streams to output
  - `-c:v VIDEO_CODEC, --video-codec VIDEO_CODEC`: Video codec to use for output files (default: 'copy').
      See `ffmpeg -encoders` for a list.
      Will attempt to copy video codec by default.
  - `-sn, --subtitle-disable`: Do not write subtitle streams to output
  - `-mn, --metadata-disable`: Do not write metadata to output
  - `-cn, --chapters-disable`: Do not write chapters to output

  - `-ei EXTRA_INPUT_OPTIONS, --extra-input-options EXTRA_INPUT_OPTIONS`: Extra input options list.
      A list of extra ffmpeg command line arguments valid for the input, applied before ffmpeg's `-i`.
      You can either use a JSON-formatted list (i.e., a list of comma-separated, quoted elements within square brackets), or a simple string of space-separated arguments.
      If JSON is used, you need to wrap the whole argument in quotes to prevent shell expansion and to preserve literal quotes inside the string. If a simple string is used, you need to specify the argument with `-e=`.
      Examples: `-ei '[ "-f", "mpegts", "-r", "24" ]'` or `-ei="-f mpegts -r 24"`
  - `-e EXTRA_OUTPUT_OPTIONS, --extra-output-options EXTRA_OUTPUT_OPTIONS`: Extra output options list.
      A list of extra ffmpeg command line arguments valid for the output.
      You can either use a JSON-formatted list (i.e., a list of comma-separated, quoted elements within square brackets), or a simple string of space-separated arguments.
      If JSON is used, you need to wrap the whole argument in quotes to prevent shell expansion and to preserve literal quotes inside the string. If a simple string is used, you need to specify the argument with `-e=`.
      Examples: `-e '[ "-vbr", "3", "-preset:v", "ultrafast" ]'` or `-e="-vbr 3 -preset:v ultrafast"`
  - `-ofmt OUTPUT_FORMAT, --output-format OUTPUT_FORMAT`: Media format to use for output file(s).
      See `ffmpeg -formats` for a list.
      If not specified, the format will be inferred by ffmpeg from the output file name. If the output file name is not explicitly specified, the extension will govern the format (see '--extension' option).
  - `-ext EXTENSION, --extension EXTENSION`: Output file extension to use for output files that were not explicitly specified. (Default: `mkv`)

  The program additionally respects environment variables:
  - `TMP` / `TEMP` / `TMPDIR`
      Sets the path to the temporary directory in which files are
      stored before being moved to the final output directory.
      Note: You need to use full paths.
  - `FFMPEG_PATH`
      Sets the full path to an `ffmpeg` executable other than
      the system default or you can provide a file name available on $PATH

  This program has a simple API that can be used to integrate it into other Python programs.
  For more information see the [API documentation](https://htmlpreview.github.io/?https://github.com/slhck/ffmpeg-normalize/blob/master/docs/ffmpeg_normalize.html).


  This is because the default output codec is PCM, which is uncompressed. If you want to reduce the file size, you can specify an audio codec with `-c:a` (e.g., `-c:a aac` for ffmpeg's built-in AAC encoder), and optionally a bitrate with `-b:a`.
  For example:
  ```bash
  ffmpeg-normalize input.wav -o output.m4a -c:a aac -b:a 192k
  ```

  EBU R128 is a method for normalizing audio loudness across different tracks or programs. It works by analyzing the audio content and adjusting it to meet specific loudness targets. The main components are:
  * Integrated Loudness (I): The overall loudness of the entire audio.
  * Loudness Range (LRA): The variation in loudness over time.
  * True Peak (TP): The maximum level of the audio signal.
  The normalization process involves measuring these values (input) and then applying gain adjustments to meet target levels (output), typically -23 LUFS for integrated loudness. You can also specify a target loudness range (LRA) and true peak level (TP).
  **Linear mode** applies a constant gain adjustment across the entire audio file. This is generally preferred because:
  * It preserves the original dynamic range of the audio.
  * It maintains the relative loudness between different parts of the audio.
  * It avoids potential artifacts or pumping effects that can occur with dynamic processing.
  **Dynamic mode**, on the other hand, can change the volume dynamically throughout the file. While this can achieve more consistent loudness, it may alter the original artistic intent and potentially introduce audible artifacts (possibly due to some bugs in the ffmpeg filter).
  For most cases, linear mode is recommended. Dynamic mode should only be used when linear mode is not suitable or when a specific effect is desired. In some cases, `loudnorm` will still fall back to dynamic mode, and a warning will be printed to the console. Here's when this can happen:
  * When the input loudness range (LRA) is larger than the target loudness range: If the input file has a loudness range that exceeds the specified loudness range target, the loudnorm filter will automatically switch to dynamic mode. This is because linear normalization alone cannot reduce the loudness range without dynamic processing (limiting). The `--keep-loudness-range-target` option can be used to keep the input loudness range target above the specified target.
  * When the required gain adjustment to meet the integrated loudness target would result in the true peak exceeding the specified true peak limit. This is because linear processing alone cannot reduce peaks without affecting the entire signal. For example, if a file needs to be amplified by 6 dB to reach the target integrated loudness, but doing so would push the true peak above the specified limit, the filter might switch to dynamic mode to handle this situation. If your content allows for it, you can increase the true peak target to give more headroom for linear processing. If you're consistently running into true peak issues, you might also consider lowering your target integrated loudness level.
  At this time, the `loudnorm` filter in ffmpeg does not provide a way to force linear mode when the input loudness range exceeds the target or when the true peak would be exceeded. There are some options to mitigate this:
  - The `--keep-lra-above-loudness-range-target` option can be used to keep the input loudness range above the specified target, but it will not force linear mode in all cases.
  - Similarly, the `--keep-loudness-range-target` option can be used to keep the input loudness range target.
  - The `--lower-only` option can be used to skip the normalization pass completely if the measured loudness is lower than the target loudness.

  Make sure you run a recent ffmpeg version and that `loudnorm` is part of the output when you run `ffmpeg -filters`. Many distributions package outdated ffmpeg versions, or (even worse), Libav's `ffmpeg` disguising as a real `ffmpeg` from the FFmpeg project.
  Some ffmpeg builds also do not have the `loudnorm` filter enabled.
  You can always download a static build from [their website](http://ffmpeg.org/download.html) and use that.
  If you have to use an outdated ffmpeg version, you can only use `rms` or `peak` as normalization types, but I can't promise that the program will work correctly.

  Generally, no.
  When you run `ffmpeg-normalize` and re-encode files with MP3 or AAC, you will inevitably introduce [generation loss](https://en.wikipedia.org/wiki/Generation_loss). Therefore, I do not recommend running this on your precious music collection, unless you have a backup of the originals or accept potential quality reduction. If you just want to normalize the subjective volume of the files without changing the actual content, consider using [MP3Gain](http://mp3gain.sourceforge.net/) and [aacgain](http://aacgain.altosdesign.com/).

  I chose MKV as a default output container since it handles almost every possible combination of audio, video, and subtitle codecs. If you know which audio/video codec you want, and which container is supported, use the output options to specify the encoder and output file name manually.

  See the [next section](#the-conversion-does-not-work-and-i-get-a-cryptic-ffmpeg-error).

  Maybe ffmpeg says something like:
  > Could not write header for output file #0 (incorrect codec parameters ?): Invalid argument
  Or the program says:
  > … Please choose a suitable audio codec with the `-c:a` option.
  One possible reason is that the input file contains some streams that cannot be mapped to the output file, or that you are using a codec that does not work for the output file. Examples:
  - You are trying to normalize a movie file, writing to a `.wav` or `.mp3` file. WAV/MP3 files only support audio, not video. Disable video and subtitles with `-vn` and `-sn`, or choose a container that supports video (e.g. `.mkv`).
  - You are trying to normalize a file, writing to an `.mp4` container. This program defaults to PCM audio, but MP4 does not support PCM audio. Make sure that your audio codec is set to something MP4 containers support (e.g. `-c:a aac`).
  The default output container is `.mkv` as it will support most input stream types. If you want a different output container, [make sure that it supports](https://en.wikipedia.org/wiki/Comparison_of_container_file_formats) your input file's video, audio, and subtitle streams (if any).
  Also, if there is some other broken metadata, you can try to disable copying over of metadata with `-mn`.
  Finally, make sure you use a recent version of ffmpeg. The [static builds](https://ffmpeg.org/download.html) are usually the best option.

  - **EBU R128** is an EBU standard that is commonly used in the broadcasting world. The normalization is performed using a psychoacoustic model that targets a subjective loudness level measured in LUFS (Loudness Unit Full Scale). R128 is subjectively more accurate than any peak or RMS-based normalization. More info on R128 can be found in the [official document](https://tech.ebu.ch/docs/r/r128.pdf) and [the `loudnorm` filter description](http://k.ylo.ph/2016/04/04/loudnorm.html) by its original author.
  - **Peak Normalization** analyzes the peak signal level in dBFS and increases the volume of the input signal such that the maximum in the output is 0 dB (or any other chosen threshold). Since spikes in the signal can cause high volume peaks, peak normalization might still result in files that are subjectively quieter than other, non-peak-normalized files.
  - **RMS-based Normalization** analyzes the [RMS power](https://en.wikipedia.org/wiki/Root_mean_square#Average_power) of the signal and changes the volume such that a new RMS target is reached. Otherwise it works similar to peak normalization.

  You absolutely can. However, you can get better accuracy and linear normalization with two passes of the filter. Since ffmpeg does not allow you to automatically run these two passes, you have to do it yourself and parse the output values from the first run.
  If ffmpeg-normalize is too over-engineered for you, you could also use an approach such as featured [in this Ruby script](https://gist.github.com/kylophone/84ba07f6205895e65c9634a956bf6d54) that performs the two `loudnorm` passes.
  If you want dynamic normalization (the loudnorm default), simply use ffmpeg with one pass, e.g.:
  ```bash
  ffmpeg -i input.mp3 -af loudnorm -c:a aac -b:a 192k output.m4a
  ```

  You should check out the `speechnorm` filter that is part of ffmpeg. It is a designed to be used in one pass, so you don't need this script at all.
  See [the documentation](https://ffmpeg.org/ffmpeg-all.html#speechnorm) for more information.

  You are probably using a 0.x version of this program. There are significant changes to the command line arguments and inner workings of this program, so please  adapt your scripts to the new one. Those changes were necessary to address a few issues that kept piling up; leaving the program as-is would have made it hard to extend it. You can continue using the old version (find it under *Releases* on GitHub or request the specific version from PyPi), but it will not be supported anymore.

  If you found this program useful and feel like giving back, feel free to send a donation [via PayPal](https://paypal.me/WernerRobitza).

  - [Create an AppleScript application to drop or open a folder of files in ffmpeg-normalize](https://prehensileblog.wordpress.com/2022/04/15/create-an-applescript-application-to-drop-or-open-a-folder-of-files-in-ffmpeg-normalize/)
  *(Have a link? Please propose an edit to this section via a pull request!)*

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://overtag.dk/"><img src="https://avatars.githubusercontent.com/u/374612?v=4?s=100" width="100px;" alt="Benjamin Balder Bach"/><br /><sub><b>Benjamin Balder Bach</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=benjaoming" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://chaos.social/@eleni"><img src="https://avatars.githubusercontent.com/u/511547?v=4?s=100" width="100px;" alt="Eleni Lixourioti"/><br /><sub><b>Eleni Lixourioti</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=Geekfish" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/thenewguy"><img src="https://avatars.githubusercontent.com/u/77731?v=4?s=100" width="100px;" alt="thenewguy"/><br /><sub><b>thenewguy</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=thenewguy" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/aviolo"><img src="https://avatars.githubusercontent.com/u/560229?v=4?s=100" width="100px;" alt="Anthony Violo"/><br /><sub><b>Anthony Violo</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=aviolo" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://jacobs.af/"><img src="https://avatars.githubusercontent.com/u/952830?v=4?s=100" width="100px;" alt="Eric Jacobs"/><br /><sub><b>Eric Jacobs</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=jetpks" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kostalski"><img src="https://avatars.githubusercontent.com/u/34033008?v=4?s=100" width="100px;" alt="kostalski"/><br /><sub><b>kostalski</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=kostalski" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://justinppearson.com/"><img src="https://avatars.githubusercontent.com/u/8844823?v=4?s=100" width="100px;" alt="Justin Pearson"/><br /><sub><b>Justin Pearson</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=justinpearson" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Nottt"><img src="https://avatars.githubusercontent.com/u/13532436?v=4?s=100" width="100px;" alt="ad90xa0-aa"/><br /><sub><b>ad90xa0-aa</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=Nottt" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Mathijsz"><img src="https://avatars.githubusercontent.com/u/1891187?v=4?s=100" width="100px;" alt="Mathijs"/><br /><sub><b>Mathijs</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=Mathijsz" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mpuels"><img src="https://avatars.githubusercontent.com/u/2924816?v=4?s=100" width="100px;" alt="Marc Püls"/><br /><sub><b>Marc Püls</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=mpuels" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.mvbattista.com/"><img src="https://avatars.githubusercontent.com/u/158287?v=4?s=100" width="100px;" alt="Michael V. Battista"/><br /><sub><b>Michael V. Battista</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=mvbattista" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://auto-editor.com"><img src="https://avatars.githubusercontent.com/u/57511737?v=4?s=100" width="100px;" alt="WyattBlue"/><br /><sub><b>WyattBlue</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=WyattBlue" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/g3n35i5"><img src="https://avatars.githubusercontent.com/u/17593457?v=4?s=100" width="100px;" alt="Jan-Frederik Schmidt"/><br /><sub><b>Jan-Frederik Schmidt</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=g3n35i5" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mjhalwa"><img src="https://avatars.githubusercontent.com/u/8994014?v=4?s=100" width="100px;" alt="mjhalwa"/><br /><sub><b>mjhalwa</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=mjhalwa" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/07416"><img src="https://avatars.githubusercontent.com/u/14923168?v=4?s=100" width="100px;" alt="07416"/><br /><sub><b>07416</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=07416" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/sian1468"><img src="https://avatars.githubusercontent.com/u/58017832?v=4?s=100" width="100px;" alt="sian1468"/><br /><sub><b>sian1468</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=sian1468" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/psavva"><img src="https://avatars.githubusercontent.com/u/1454758?v=4?s=100" width="100px;" alt="Panayiotis Savva"/><br /><sub><b>Panayiotis Savva</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=psavva" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/HighMans"><img src="https://avatars.githubusercontent.com/u/42877729?v=4?s=100" width="100px;" alt="HighMans"/><br /><sub><b>HighMans</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=HighMans" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kanjieater"><img src="https://avatars.githubusercontent.com/u/32607317?v=4?s=100" width="100px;" alt="kanjieater"/><br /><sub><b>kanjieater</b></sub></a><br /><a href="#ideas-kanjieater" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://ahmetsait.com/"><img src="https://avatars.githubusercontent.com/u/8372246?v=4?s=100" width="100px;" alt="Ahmet Sait"/><br /><sub><b>Ahmet Sait</b></sub></a><br /><a href="https://github.com/slhck/ffmpeg-normalize/commits?author=ahmetsait" title="Code">💻</a></td>
      </tr>
    </tbody>
    <tfoot>
      <tr>
        <td align="center" size="13px" colspan="7">
          <img src="https://raw.githubusercontent.com/all-contributors/all-contributors-cli/1b8533af435da9854653492b1327a23a4dbd0a10/assets/logo-small.svg">
            <a href="https://all-contributors.js.org/docs/en/bot/usage">Add your contributions</a>
          </img>
        </td>
      </tr>
    </tfoot>
  </table>
  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->

  The MIT License (MIT)
  Copyright (c) 2015-2022 Werner Robitza
  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.


  * Update docs and completions.
  * Implement `--auto-lower-loudness-target`
  * Fix deprecations and mypy --strict errors.
  * Feat: add completions.
  * Docs: update explainer.
  * Docs: update docs to include lower-only.

  * Change lower-only message to warning.
  * Make setup name PEP 625 compliant.
  * Docs: add @ahmetsait as a contributor.
  * Implement `--lower-only`
  * Fix: `--print-stats` only outputs the last stream.
  * More robust `loudnorm` output parsing.
  * Remove unnecessary conversions.
  * Update .editorconfig.
  * Remove python 3.8, add python 3.12, 3.13.
  * Add README on file size.

  * Fix: show percentage with two decimal digits in progress.
  * Chore: add python 12.

  * Fix: override argparse usage.

  * Add option to set audio channels directly.

  * Make colorama dependency windows-only.
  * Update.
  * Update badges.
  * Docs: add @kanjieater as a contributor.

  * Provide an entrypoint for the Docker image.
  * Add docker push (#261)

  * Fix assignment of audio statistics, fixes #257.

  * Warn if dynamic mode is used but linear specified (#256)
  * Print debug commands in shell-escaped form.

  * Allow cover art in MP3.

  * Remove warning for short files (#87)

  * Building on Windows failed due to character conversion (#244)

  * Docs: add HighMans as a contributor for code (#242)
    * docs: update README.md


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

  `ff4d` takes a video file as its input and encodes it to be less than a target file size. Discord's free-tier file size sharing limit is 10MB. You can change the file's name in a way that trims the file to a timestamped section. I developed this package specifically for swift sharing of large NVIDIA ShadowPlay clips on Discord, eliminating the need for a visual editor.

  The `TwoPass()` class presents a 2-pass encoding approach for the `ffmpeg-python` library, which is not showcased in that package's documentation. Additionally, the class extends support to various FFmpeg video filters such as cropping and resolution scaling, making it adaptable to a range of audio/video workflows.



  This package requires Python >= 3.9. For Windows users, ensure that Python is added to your system's PATH. I highly recommend that you use the [python.org](https://python.org) Python installation.

  Install this package with the following command.

  ```
  pip install ffmpeg4discord
  ```

  You must first have FFmpeg installed on your system. `ffmpeg` needs to be registered in your PATH. macOS or Linux users can use their favorite package manager to do this, but this process is a little more tricky for Windows users.



  After installing this package, Windows users can run this command in a terminal to download the necessary `ffmpeg` binaries:

  ```
  install-ffmpeg-windows
  ```

  This will place `ffmpeg.exe`, `ffprobe.exe`, and `ffplay.exe` into the same location as your Python executable.



  Use `ff4d` in your favorite terminal like this:

  ```
  ff4d path-to-file.mp4 [optional-flags]
  ```

  This command tries to compress the whole video file down to the an output file size of 10MB:

  ```
  ff4d cool_clip.mp4 -s 10
  ```

  This will trim a 20 second section out of `cool_clip.mp4` starting at 10 seconds in and ending at 30 seconds. The output will be less than 10MB. [More on the optional flags](#optional-flags).

  ```
  ff4d cool_clip.mp4 --from 00:00:10 --to 00:00:30 -s 10
  ```

  I've had a good time using this command with a Batch file on Windows. Refer to the [Sample Batch File](#sample-batch-file) section for more information.



  | Flag | Default | Example | Description |
  |---|---|---|---|
  | `-o`<br>`--output` | current working directory | `-o "C:/Users/zflee/A Folder"`<br>`-o "C:/Users/zflee/Desktop/A Folder/filename.mp4"` | If you want your smaller clips to go to a specific folder, use this option. You can also choose a custom output filename, just make sure to include the correct file extension for your video codec. |
  | `-s`<br>`--target-filesize` | 10 | `-s 50` | Change this value if you want to compress your video to something other than the 10MB Discord limit. |
  | `-a`<br>`--audio-br` | 96 | `-a 128` | You can change this value if you want to increase or decrease your audio bitrate. Lowering it will allow for a slight increase in the compressed file's video bitrate. |
  | `-r`<br>`--resolution` | No default | `-r 1280x720` | Modify this value to change the output resolution of your video file. |
  | `-x`<br>`--crop` | No default | `-x 255x0x1410x1080` | [FFmpeg crop documentation](https://ffmpeg.org/ffmpeg-filters.html#Examples-61). From the top-left of your video, this example goes 255 pixels to the right, 0 pixels down, and it carves out a 1410x1080 section of the video. |
  | `-c`<br>`--codec` | libx264 | `-c libvpx-vp9` | Options: `libx264` or `libvpx-vp9`<br>Specify the video codec that you want to use. The default option creates `.mp4` files, while `libvpx-vp9` creates `.webm` video files.<br>`libvpx-vp9` creates better looking video files with the same bitrates, but it takes significantly longer to encode. VP9 is also not as compatible with as many devices or browsers. I can view `.webm` videos on the desktop installation of Discord, but they are not viewable on my iOS Discord installation. |
  | `--web` | No default. Boolean flag. | `--web` | Launch the Web UI for this job. A Boolean flag. No value is needed after the flag. See [Web UI](#web-ui) for more information on the Web UI. |
  | `-p`<br>`--port` | No default. Picks a random port if not specified. | `-p 5333` | Run the Web UI on a specific port. |
  | `--config` | No default | `--config config.json` | Path to a JSON file containing the configuration for the above parameters. This config file takes precedence over all of the other flags. See [JSON Configuration](#json-configuration). |
  | `--from` | No default | `--from 00:01:00` | Start time for trimming the video file to a desired section. |
  | `--to` | No default | `--to 00:01:20` | End time for trimming the video file to a desired section. |
  | `--filename-times` | No default. Boolean flag. | `--filename-times` | Generate From/To timestamps from the clip's file name. See [File Name Formatting](#file-name-formatting) |
  | `--approx` | No default. Boolean flag. | `--approx` | Approximate file size. The job will not loop to output the file under the target size. It will get close enough to the target on the first run. |
  | `-f`<br>`--framerate` | No default. | `-f 30` | Adjust the output's frame rate. Specify a value lower than the input video's frame rate. |
  | `--vp9-opts` | No default. | `--vp9-opts '{"row-mt":1,"deadline":"good","cpu-used":2}'` | Specify options to tweak VP9 encoding speed. `row-mt`, `deadline`, and `cpu-used` are the only values supported at the moment. This can only be set with the command line or JSON configuration file. It is not configurable with the Web UI. |



  Enable this feature with `--filename-times`. You can edit the name of your video file if you need to trim it to a specific section. Here are a few examples.

  1) `000020.mp4`
      - This trims and compresses the video from 00:00:20 to the end of the clip.
  2) `000020-000145.mp4`
      - This trims and compresses the video from 00:00:20 to 00:01:45.
  3) `SomethingElse.mp4`
      - Compresses the entire video if the first six characters of the file's name aren't numeric.



  If your encoding job uses the same settings consistently, you can simplify your workflow by referencing a JSON configuration file instead of specifying multiple command-line arguments. This feature was designed for advanced users or "workflow people."

  When using both a JSON configuration file and command-line flags, the **command-line flag values take precedence** over the values defined in the JSON. For example, if `"target_filesize"` is specified in the JSON file and you include the `--target-filesize` (or `-s`) flag in your command, the command-line value will be used.

  If you supply a configuration JSON file, include only the settings that differ from the [default values](#optional-flags). Any omitted values will automatically use their defaults.



  Create a new plain text JSON file (`my-config.json`) structured like this:

  ```json
  {
      "target_filesize": 10.0,
      "resolution": "1280x720",
      "codec": "libvpx-vp9",
      "to": "00:00:40"
  }
  ```

  And then you would call `ff4d` like this:

  ```bash
  ff4d my-video.mp4 --config my-config.json
  ```



  ```
  ff4d 000050-000145.mp4 \
      -x 1280x0x2560x1440 \
      -r 1920x1080 \
      -s 50 \
      -a 48 \
      -o D:/shadowplay/ \
      --filename-times
  ```

  The example above takes a 5120x1440 resolution video as its input. The script trims the video from 00:00:50 to 00:01:45 (specified in the [file name](#file-name-formatting), and enabled with `--filename-times`). It crops a 2560x1440 section starting at 1280 pixels from the top-left and 0 pixels down (`-x`). The output file will be located in `D:/shadowplay/` (`-o`) with a new resolution of 1920x1080 (`-r`), and it will be 50MB (`-s`). The audio bitrate will be reduced to 48k (`-a`) as well, but that's probably going to sound terrible.

  ![](https://github.com/zfleeman/ffmpeg4discord/assets/1808564/ac0663ee-64df-4b22-a1c3-4a8556c2eb78)



  The web UI can be activated by adding `--web` to your `ff4d` call.

  ```
  ff4d cool_clip.mp4 -r 1280x720 -s 20 --web
  ```

  That command will spin up a Flask server on your local machine and launch a rendered webpage with the video as the centerpiece. The flags you provide to `ff4d` will fill in the defaults for the form. You can override/replace the values with the web form.

  You can drag the video playhead to different portions of the video and click the "Set Start/End Time" buttons to specify the section of the video you want to be clipped out. You can also use the range sliders underneath the buttons if you prefer. A "Preview Selection" button is provided for your convenience, and it does what it sounds like.

  https://github.com/zfleeman/ffmpeg4discord/assets/1808564/ff323bcb-4747-437b-808f-ce48b8c269ce

  Note that the Flask server doesn't automatically shut down, so you'll need to manually terminate it by closing the terminal window where it's running.



  To enable "drag and drop" functionality for this package, Windows users can create a `.bat` file with the following code snippet. Once the file is created, you can drag and drop any `.mp4` file on top of it, and it will run with the flags specified in the "[Optional Flags](#optional-flags)" section. This example is a Batch file that will launch the web UI.

  ```batch
  @echo off
  Set filename=%1
  ff4d %filename% -o "C:/output/folder/" --web
  PAUSE
  ```



  Yes, this is a simple collection of Python files using FFmpeg tricks that is masquerading as a robust Audio/Video tool. But! I use this nearly every day to quickly share videos with people on various messaging apps that have built-in video players. I don't have to share a link that embeds a video player this way, and I guess that's important to me?

  I like working on this! Enjoy!

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  ffmpeg4discord (ff4d) is a video compression library Copyright (C) 2024  Zach Fleeman  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.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  ffmpeg4discord  Copyright (C) 2024  Zach Fleeman This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <https://www.gnu.org/licenses/why-not-lgpl.html>.


pkgId: e286706942ab98a1b87f00fa00cda9925bab93a703794df346fb3c2f9e9ee8b6
name: python-ffmpy-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for ffmpy
url: https://github.com/Ch00k/ffmpy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ffmpy-0.5.0-1.src.rpm
location_href: Packages/python-ffmpy-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  *ffmpy* is a simple `FFmpeg <http://ffmpeg.org/>`_ command line wrapper. It implements a Pythonic interface for FFmpeg command line compilation and uses Python's `subprocess <https://docs.python.org/2/library/subprocess.html>`_ to execute the compiled command line.
  *ffmpy* requires Python 3.8 or greater.


pkgId: e70c379187343d0510e1603bfcfe81113b86e61f880eeb7519465b9fe197cba6
name: python-ffquant-help
arch: noarch
version: 2.5.5
epoch: 0
release: 1
summary: Development documents and examples for ffquant
url: https://github.com/lihuapinghust/ffquant
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ffquant-2.5.5-1.src.rpm
location_href: Packages/python-ffquant-help-2.5.5-1.noarch.rpm
checksum_type: sha256
description:
  ```SHELL
  curl -L https://tljh.jupyter.org/bootstrap.py | sudo -E python3 - --admin tljhadmin --version 1.0.0b1
  ```

  Edit ~/.profile, add the following to the end

  ```SHELL
  export PATH=/opt/tljh/user/bin/:$PATH
  curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash
  nvm install 20.17.0
  nvm alias default 20.17.0
  curl -fsSL https://deb.nodesource.com/setup_current.x | sudo -E bash -
  sudo apt install -y nodejs
  wget https://github.com/apache/rocketmq-client-cpp/releases/download/2.0.0/rocketmq-client-cpp-2.0.0.amd64.deb
  sudo dpkg -i rocketmq-client-cpp-2.0.0.amd64.deb
  sudo -E /opt/tljh/user/bin/python3 -m pip install backtrader matplotlib dash pandas psutil ffquant numpy confluent-kafka apollo-client boto3
  sudo chmod -R 777 /opt/tljh/user/lib/python3.10/site-packages/pyapollo/
  sudo -E /opt/tljh/user/bin/python -m pip install jupyterlab-git==0.44.0
  sudo -E /opt/tljh/user/bin/jupyter lab build
  sudo systemctl restart jupyterhub jupyter-tljhadmin
  ```

  Visit http://192.168.25.144 in your browser

  Log in as tljhadmin and set your password



  ```SHELL
  sudo tljh-config set auth.type nativeauthenticator.NativeAuthenticator
  sudo tljh-config reload
  ```

  BE CAREFULL!!! When this feature is enabled, the admin user has to go through the sign-up process. Username must be the same with the one used in the installation command.

  Admin user authorizes user registration at http://192.168.25.144/hub/authorize


  Log in as admin. Open the terminal and execute commands:

  ```SHELL
  jupyter notebook --generate-config
  sudo mv /home/jupyter-tljhadmin/.jupyter/jupyter_notebook_config.py /opt/tljh/user/etc/jupyter/
  ```

  Edit /opt/tljh/user/etc/jupyter/jupyter_notebook_config.py and change c.NotebookApp.terminals_enabled to False.

  ```SHELL
  sudo systemctl restart jupyterhub jupyter-tljhadmin
  ```


  ```SHELL
  sudo tljh-config set services.cull.max_age 0
  sudo tljh-config set services.cull.timeout 31536000
  sudo systemctl restart jupyterhub jupyter-tljhadmin
  ```


  Install Docker
  ```SHELL
  curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
  echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
  sudo apt-get update
  sudo apt-get install docker-ce docker-ce-cli containerd.io
  sudo systemctl enable docker
  sudo systemctl start docker
  sudo usermod -aG docker $USER
  newgrp docker
  ```
  log out from the terminal and log in.

  Install docker-compose
  ```SHELL
  sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
  sudo chmod +x /usr/local/bin/docker-compose
  ```

  Visit https://github.com/apolloconfig/apollo-quick-start and get docker-compose.yml and sql folder. Rearrange them like:
  ```SHELL
  - docker-quick-start
    - docker-compose.yml
    - sql
      - apolloconfigdb.sql
      - apolloportaldb.sql
  ```
  Execute ```docker-compose up``` under docker-quick-start directory


  Run the following command at the root directory of ffquant on Windows.
  ```SHELL
  python ffquant/utils/make_bt_data_viewer.py
  ```
  Output exe file path is dist/backtest_data_viewer_1.0.0.exe

  Open bt_data_viewer_setup.iss with Inno Setup and Compile. The Setup Installer is Output/mysetup.exe



  python -m pip install setuptools wheel twine

  Increase version number in setup.py

  python setup.py sdist bdist_wheel

  python -m twine upload dist/*

  Ask Joanthan for PyPi API token.


pkgId: 703af7bee3875511c016c65896edc2b69be3b273496258536ad37afdc048903f
name: python-fgutils-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for fgutils
url: https://pypi.org/project/fgutils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fgutils-0.1.4-1.src.rpm
location_href: Packages/python-fgutils-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  FGUtils is a collection of utility functions for querying functional groups in
  molecules from their molecular graph representation.


  - Python (>= 3.11)
  - numpy (>= 1.26.4)
  - networkx (>= 3.2.1)
  - rdkit (>= 2023.09.4 optional)


  You can install [FGUtils](https://pypi.org/project/fgutils/) using pip.
  ```
  pip install fgutils
  ```


  For a comprehensive description of FGUtils features read through the
  [documentation](https://klausweinbauer.github.io/FGUtils/). However, querying
  the functional groups for a molecule like acetylsalicylic acid is as simple as
  running the following:
  ```
  >>> from fgutils import FGQuery
  >>>
  >>> smiles = "O=C(C)Oc1ccccc1C(=O)O" # acetylsalicylic acid
  >>> query = FGQuery()
  >>> query.get(smiles)
  [('ester', [0, 1, 3]), ('carboxylic_acid', [10, 11, 12])]
  ```

  The output is a list of tuples containing the functional group name and the
  corresponding atom indices.


pkgId: 874c9aef3530341e46854013fa8cc87a04da28fca402fb8d6609173c3e004996
name: python-fh-llm-client-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for fh-llm-client
url: https://pypi.org/project/fh-llm-client/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fh-llm-client-0.0.7-1.src.rpm
location_href: Packages/python-fh-llm-client-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)]()

  <!-- [![tests](https://github.com/Future-House/llm-client/actions/workflows/test.yaml/badge.svg)](https://github.com/Future-House/llm-client) -->

  [![PyPI version](https://badge.fury.io/py/fh-llm-client.svg)](https://badge.fury.io/py/fh-llm-client)



  Central FutureHouse LLM client library.



  ```
  $ pip install -e .
  $ uv sync && uv run pytest -n auto
  ```



  - LLMModel
  - LLMResult



  - [PaperQA](https://github.com/Future-House/paper-qa/compare/main...llm-result-client)
  - [LDP](https://github.com/Future-House/ldp/compare/main...llm-result-client)

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


pkgId: 5e6975b2546a3bf03fbfe48a63639d1a4c1042b6431d1843308a62a4fa959465
name: python-fhreloading-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for fhreloading
url: https://pypi.org/project/fhreloading/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fhreloading-1.1.2-1.src.rpm
location_href: Packages/python-fhreloading-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  本项目在`reloading`基础上，做了一些调整，具体如下：

  - 中文支持: json文件统一使用`utf-8`编码;

  A Python utility to reload a loop body from source on each iteration without
  losing state

  Useful for editing source code during training of deep learning models. This lets
  you e.g. add logging, print statistics or save the model without restarting the
  training and, therefore, without losing the training progress.


  ```
  pip install reloading
  ```



  To reload the body of a `for` loop from source before each iteration, simply
  wrap the iterator with `reloading`, e.g.
  ```python
  from reloading import reloading

  for i in reloading(range(10)):
      
      print(i)

  ```

  To reload a function from source before each execution, decorate the function
  definition with `@reloading`, e.g.
  ```python
  from reloading import reloading

  @reloading
  def some_function():
      
      pass
  ```



  Pass the keyword argument `every` to reload only on every n-th invocation or iteration. E.g.
  ```python
  for i in reloading(range(1000), every=10):
      
      
      pass

  @reloading(every=10)
  def some_function():
      
      pass
  ```

  Pass `forever=True` instead of an iterable to create an endless reloading loop, e.g.
  ```python
  for i in reloading(forever=True):
      
      pass
  ```



  Here are the short snippets of how to use reloading with your favourite library.
  For complete examples, check out the [examples folder](https://github.com/julvo/reloading/blob/master/examples).


  ```python
  for epoch in reloading(range(NB_EPOCHS)):
      

      for images, targets in dataloader:
          optimiser.zero_grad()
          predictions = model(images)
          loss = F.cross_entropy(predictions, targets)
          loss.backward()
          optimiser.step()
  ```
  [Here](https://github.com/julvo/reloading/blob/master/examples/pytorch/train.py) is a full PyTorch example.


  ```python
  @reloading
  def update_learner(learner):
      
      
      pass

  class LearnerUpdater(LearnerCallback):
      def on_epoch_begin(self, **kwargs):
          update_learner(self.learn)

  path = untar_data(URLs.MNIST_SAMPLE)
  data = ImageDataBunch.from_folder(path)
  learn = cnn_learner(data, models.resnet18, metrics=accuracy,
                      callback_fns=[LearnerUpdater])
  learn.fit(10)
  ```
  [Here](https://github.com/julvo/reloading/blob/master/examples/fastai/train.py) is a full fastai example.


  ```python
  @reloading
  def update_model(model):
      
      
      
      pass

  class ModelUpdater(Callback):
      def on_epoch_begin(self, epoch, logs=None):
          update_model(self.model)

  model = Sequential()
  model.add(Dense(64, activation='relu', input_dim=20))
  model.add(Dense(10, activation='softmax'))

  sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
  model.compile(loss='categorical_crossentropy',
                optimizer=sgd,
                metrics=['accuracy'])

  model.fit(x_train, y_train,
            epochs=200,
            batch_size=128,
            callbacks=[ModelUpdater()])
  ```
  [Here](https://github.com/julvo/reloading/blob/master/examples/keras/train.py) is a full Keras example.


  ```python
  for epoch in reloading(range(NB_EPOCHS)):
      
      

      train_loss.reset_states()
      train_accuracy.reset_states()
      test_loss.reset_states()
      test_accuracy.reset_states()

      for images, labels in tqdm(train_ds):
        train_step(images, labels)

      for test_images, test_labels in tqdm(test_ds):
        test_step(test_images, test_labels)
  ```
  [Here](https://github.com/julvo/reloading/blob/master/examples/tensorflow/train.py) is a full TensorFlow example.



  Make sure you have `python` and `python3` available in your path, then run:
  ```
  $ python3 reloading/test_reloading.py
  ```


pkgId: 3fd26755d417329fdb64edb8a633556c8e57ae5486782afeb0d3e74ed2402c7d
name: python-fhuserconf-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for fhuserconf
url: https://pypi.org/project/fhuserconf/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fhuserconf-0.5.0-1.src.rpm
location_href: Packages/python-fhuserconf-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  本项目在`UserConf`基础上，做了一些调整，具体如下：

  - 配置文件存储位置, 由用户目录调整到当前目录;
  - 中文支持: json文件统一使用`utf-8`编码; `Key`支持中文;
  - 增加对Python 3.8 的支持;
  - 去除对 os.path 的依赖;
  - 最后重新打包(fhuserconf);

  Install from PyPI (Python Package Index)

  ```bash
  pip install fhuserconf
  ```

  UserConf is a user configuration management Python library. It stores key-value
  settings in a JSON file and manages data files and directories. The JSON file
  and the data files and directories are inside a directory that is inside the
  user home directory.

  - Version: 0.5.0
  - Author: Jose A. Jimenez (jajimenezcarm@gmail.com)
  - License: MIT License
  - Repository: https://github.com/jajimenez/userconf



  ```python
  from userconf import UserConf







  uc = UserConf("example-app")



  uc.settings.set("example-key", "Example value")



  value = uc.settings.get("example-key")
  print(value)


  value = uc.settings.get("example-key-2", "Default value")
  print(value)


  uc.settings.delete("example-key")


  uc.settings.delete_all()





  path = uc.files.get_path("example-file.txt")
  print(path)
  ```



  We can install UserConf in the following ways:



  ```bash
  pip install userconf
  ```



  ```bash
  python setup.py install
  ```



  We can generate and install the **built package** or the **source archive**
  from the source code. The *wheel* package is needed for generating the built
  package.

  To generate and install the **built package** (preferred), run the following
  commands from the project directory:

  ```bash
  pip install wheel
  python setup.py bdist_wheel
  pip install ./dist/userconf*.whl
  ```

  To generate and install the **source archive**, run the following commands from
  the project directory:

  ```bash
  python setup.py sdist
  pip install ./dist/userconf*.tar.gz
  ```



  To run all the unit tests, run the following command from the project
  directory:

  ```bash
  python -m unittest discover test
  ```


pkgId: b590990d9237368a58a062dda3a37bf699eb7e8ba4e1517e94535e36e6abcef6
name: python-fiestaEM-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for fiestaEM
url: https://github.com/ThibeauWouters/fiestaEM
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fiestaEM-0.0.2-1.src.rpm
location_href: Packages/python-fiestaEM-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  `fiesta`: **F**ast **I**nference of **E**lectromagnetic **S**ignals and **T**ransients with j**A**x

  ![fiesta logo](docs/fiesta_logo.jpeg)

  **NOTE:** `fiesta` is currently under development -- stay tuned!



  pip installation is currently work in progress. Install from source by cloning this Github repository and running
  ```
  pip install -e .
  ```

  NOTE: This is using an older and custom version of `flowMC`. Install by cloning the `flowMC` version at [this fork](https://github.com/ThibeauWouters/flowMC/tree/fiesta) (branch `fiesta`).



  To train your own surrogate models, have a look at some of the example scripts in the repository for inspiration, under `trained_models`

  - `train_Bu2019lm.py`: Example script showing how to train a surrogate model for the POSSIS `Bu2019lm` kilonova model.
  - `train_afterglowpy_tophat.py`: Example script showing how to train a surrogate model for `afterglowpy`, using a tophat jet structure.



  - `run_AT2017gfo_Bu2019lm.py`: Example where we infer the parameters of the AT2017gfo kilonova with the `Bu2019lm` model.
  - `run_GRB170817_tophat.py`: Example where we infer the parameters of the GRB170817 GRB with a surrogate model for `afterglowpy`'s tophat jet. **NOTE** This currently only uses one specific filter. The complete inference will be updated soon.



  The logo was created by [ideogram AI](https://ideogram.ai/).


pkgId: 5271a65f67b3c52a78d3d957d14d658cba1a99c8fb04d1aea1a5cca88c62b0d3
name: python-fiftyone-brain-help
arch: noarch
version: 0.18.2
epoch: 0
release: 1
summary: Development documents and examples for fiftyone-brain
url: https://github.com/voxel51/fiftyone-brain
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fiftyone-brain-0.18.2-1.src.rpm
location_href: Packages/python-fiftyone-brain-help-0.18.2-1.noarch.rpm
checksum_type: sha256
description:
  FiftyOne Brain contains the open source AI/ML capabilities for the
  [FiftyOne ecosystem](https://github.com/voxel51/fiftyone), enabling users to
  automatically analyze and manipulate their datasets and models. FiftyOne Brain
  includes features like visual similarity search, query by text, finding unique
  and representative samples, finding media quality problems and annotation
  mistakes, and more 🚀

  Public documentation for the FiftyOne Brain is
  [available here](https://docs.voxel51.com/user_guide/brain.html).

  The FiftyOne Brain is distributed via the `fiftyone-brain` package, and a
  suitable version is automatically included with every `fiftyone` install:
  ```shell
  pip install fiftyone
  pip show fiftyone-brain
  ```

  If you wish to do a source install of the latest FiftyOne Brain version, simply
  clone this repository:
  ```shell
  git clone https://github.com/voxel51/fiftyone-brain
  cd fiftyone-brain
  ```
  and run the install script:
  ```shell

  bash install.bash

  .\install.bat
  ```

  If you are a developer contributing to this repository, you should perform a
  developer installation using the `-d` flag of the install script:
  ```shell

  bash install.bash -d

  .\install.bat -d
  ```
  Check out the [contribution guide](CONTRIBUTING.md) to get started.

  ```shell
  pip uninstall fiftyone-brain
  ```

  -   `fiftyone/brain/` definition of the `fiftyone.brain` namespace
  -   `requirements/` Python requirements for the project
  -   `tests/` tests for the various components of the Brain

  If you use the FiftyOne Brain in your research, please cite the project:
  ```bibtex
  @article{moore2020fiftyone,
    title={FiftyOne},
    author={Moore, B. E. and Corso, J. J.},
    journal={GitHub. Note: https://github.com/voxel51/fiftyone-brain},
    year={2020}
  }
  ```


pkgId: d5300c943e51fd8fc351a993dba742c536966b3b2a383a5ecb9e3d00c677ed21
name: python-fiftyone-devicedetection-cloud-help
arch: noarch
version: 4.4.105.0
epoch: 0
release: 1
summary: Development documents and examples for fiftyone-devicedetection-cloud
url: https://51degrees.com/
rpm_license: EUPL-1.2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fiftyone-devicedetection-cloud-4.4.105.0-1.src.rpm
location_href: Packages/python-fiftyone-devicedetection-cloud-help-4.4.105.0-1.noarch.rpm
checksum_type: sha256
description:
  ![51Degrees](https://51degrees.com/DesktopModules/FiftyOne/Distributor/Logo.ashx?utm_source=github&utm_medium=repository&utm_content=readme_main&utm_campaign=python-open-source "THE Fastest and Most Accurate Device Detection") **v4 Device Detection Python**

  [Developer Documentation](https://51degrees.com/device-detection-python/index.html?utm_source=github&utm_medium=repository&utm_content=property_dictionary&utm_campaign=python-open-source "Developer Documentation") | [Available Properties](https://51degrees.com/resources/property-dictionary?utm_source=github&utm_medium=repository&utm_content=property_dictionary&utm_campaign=python-open-source "View all available properties and values")





  `pip install fiftyone-devicedetection-cloud`

  You can confirm this is working with the following micro-example.

  * Create a resource key for free with the 51Degrees [configurator](https://configure.51degrees.com/np5M4nlF). This defines the properties you want to access.
  * On the 'implement' page of the configurator, copy the resource key and replace YOUR_RESOURCE_KEY in the example below. Save this as exampledd.py
  * Run the example with `python exampledd.py`
  * Feel free to try different user-agents and property values.

  ```python
  from fiftyone_devicedetection_cloud.devicedetection_cloud_pipelinebuilder import DeviceDetectionCloudPipelineBuilder
  pipeline = DeviceDetectionCloudPipelineBuilder({"resource_key": "YOUR_RESOURCE_KEY"}).build()
  fd = pipeline.create_flowdata()
  fd.evidence.add("header.user-agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148")
  fd.process()
  print(fd.device.ismobile.value())
  ```

  For more in-depth examples, check out the [examples](https://51degrees.com/device-detection-python/examples.html) page in the documentation.





  If you've cloned the GitHub repository, you will be able to run the examples in the `fiftyone_devicedetection_examples` directory.



  To run the tests use:

  `python -m unittest discover -s tests -p test*.py -b`


pkgId: 9410bc393370139fbf372606b223e58a309c9d601cc9c3dc9e7eae19354ec522
name: python-fiftyone-devicedetection-help
arch: noarch
version: 4.4.105.0
epoch: 0
release: 1
summary: Development documents and examples for fiftyone-devicedetection
url: https://51degrees.com/
rpm_license: EUPL-1.2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fiftyone-devicedetection-4.4.105.0-1.src.rpm
location_href: Packages/python-fiftyone-devicedetection-help-4.4.105.0-1.noarch.rpm
checksum_type: sha256
description:
  ![51Degrees](https://51degrees.com/DesktopModules/FiftyOne/Distributor/Logo.ashx?utm_source=github&utm_medium=repository&utm_content=readme_main&utm_campaign=python-open-source "THE Fastest and Most Accurate Device Detection") **v4 Device Detection Python**

  [Developer Documentation](https://51degrees.com/device-detection-python/index.html?utm_source=github&utm_medium=repository&utm_content=property_dictionary&utm_campaign=python-open-source "Developer Documentation") | [Available Properties](https://51degrees.com/resources/property-dictionary?utm_source=github&utm_medium=repository&utm_content=property_dictionary&utm_campaign=python-open-source "View all available properties and values")



  This project contains 51Degrees Device Detection Engine builders for Python which can be used to build both on-premise and cloud implementations.

  The Pipeline is a generic web request intelligence and data processing solution with the ability to add a range of 51Degrees and/or custom plug ins (Engines)



  * Python 3.8+
  * fiftyone_devicedetection_onpremise
  * fiftyone_devicedetection_cloud



  `pip install fiftyone_devicedetection`



  To run the tests use:

  `python -m unittest discover -s tests -p test*.py -b`


pkgId: b931b8c4feff6b813049833f3c1c7c70eaa8463a9d6c1cedc818140d25851532
name: python-fiftyone-devicedetection-shared-help
arch: noarch
version: 4.4.105.0
epoch: 0
release: 1
summary: Development documents and examples for fiftyone-devicedetection-shared
url: https://51degrees.com/
rpm_license: EUPL-1.2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fiftyone-devicedetection-shared-4.4.105.0-1.src.rpm
location_href: Packages/python-fiftyone-devicedetection-shared-help-4.4.105.0-1.noarch.rpm
checksum_type: sha256
description:
  ![51Degrees](https://51degrees.com/DesktopModules/FiftyOne/Distributor/Logo.ashx?utm_source=github&utm_medium=repository&utm_content=readme_main&utm_campaign=python-open-source "THE Fastest and Most Accurate Device Detection") **v4 Device Detection Python**

  [Developer Documentation](https://51degrees.com/device-detection-python/index.html?utm_source=github&utm_medium=repository&utm_content=property_dictionary&utm_campaign=python-open-source "Developer Documentation") | [Available Properties](https://51degrees.com/resources/property-dictionary?utm_source=github&utm_medium=repository&utm_content=property_dictionary&utm_campaign=python-open-source "View all available properties and values")



  This project contains 51Degrees Device Detection shared logic for Python which is used by the on-premise and cloud implementations.

  The Pipeline is a generic web request intelligence and data processing solution with the ability to add a range of 51Degrees and/or custom plug ins (Engines)



  * Python 3.8+



  `pip install fiftyone_devicedetection_shared`



  To run the tests use:

  `python -m unittest discover -s tests -p test*.py -b`


pkgId: 0f0d60c3d0a2f668c711bcee72674686b78170438bcee1b3e1156f719d171d64
name: python-figurex-help
arch: noarch
version: 0.2.8
epoch: 0
release: 1
summary: Development documents and examples for figurex
url: https://github.com/mschroen/figurex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-figurex-0.2.8-1.src.rpm
location_href: Packages/python-figurex-help-0.2.8-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPi Version](https://img.shields.io/pypi/v/figurex.svg)](https://pypi.python.org/pypi/figurex/)
  [![MIT License](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/mschroen/figurex/blob/main/LICENSE)
  [![Read the Docs](https://readthedocs.org/projects/figurex/badge/?version=latest)](https://figurex.readthedocs.io/en/latest/?badge=latest)
  [![Issues](https://img.shields.io/github/issues-raw/mschroen/figurex.svg?maxAge=25000)](https://github.com/mschroen/figurex/issues)
  Make figures with context managers in python: quicker, simpler, more readable.
  ```python
  with Figure() as ax:
      ax.plot([1,2],[3,4])
  ```




  Tired of lengthy matplotlib code just for simple plotting?
  ```python

  import matplotlib.pyplot as plt

  fig, axes = plt.subplots(1,2, figsize=(4,5))
  plt.set_title("My plot")
  ax = axes[0]
  ax.plot([1,2],[3,4])
  ax = axes[1]
  ax.plot([2,3],[4,5])
  fig.savefig("file.png", bbox_inches='tight')
  plt.show()
  ```
  Beautify your daily work with shorter and more readable code:
  ```python

  from figurex import Figure, Panel

  with Figure("My plot", layout=(1,2), size=(4,5), save="file.png"):
      with Panel() as ax:
          ax.plot([1,2],[3,4])
      with Panel() as ax:
          ax.plot([2,3],[4,5])
  ```
  The `Figure()` environment generates the `matplotlib`-based figure and axes for you, and automatically shows, saves, and closes the figure when leaving the context. It is just a wrapper around standard matplotlib code, you can use `ax` to modify the plot as you would normally do. Extend it your way without limits!



  Make a simple plot:

  ```python
  with Figure("A simple plot") as ax:
      ax.plot([1,2],[3,4])
  ```

  A plot with two panels:
  ```python
  with Figure(layout=(1,2), size=(6,3)):
      with Panel("a) Magic") as ax:
          ax.plot([1,2],[3,4])
      with Panel("b) Reality", grid="") as ax:
          ax.plot([5,5],[6,4])
  ```

  Save a plot into memory for later use (e.g. in FPDF):
  ```python
  with Figure("Tea party", show=False):
      with Panel() as ax:
          ax.plot([5,5],[6,4])
  my_figure = Figure.as_object()

  ```

  Plotting maps:
  ```python
  from figurex.basemap import Basemap

  with Figure(size=(3,3)):
      with Basemap("Germany", extent=(5,15,46,55), tiles="relief") as Map:
          x,y = Map(12.385, 51.331)
          Map.scatter(x, y,  marker="x", color="red", s=200)
  ```

  - Check out the [Examples Notebook](https://github.com/mschroen/figurex/blob/main/examples.ipynb)!

  ![Figurex examples](https://github.com/mschroen/figurex/blob/main/docs/figurex-examples.png)




  A documentation and API reference can be found on [ReadTheDocs](https://figurex.readthedocs.io/en/latest):
  - [Figure](https://figurex.readthedocs.io/en/latest/#figurex.figure.Figure) (context manager)
  - [Panel](https://figurex.readthedocs.io/en/latest/#figurex.figure.Panel) (context manager)
  - [Basemap](https://figurex.readthedocs.io/en/latest/#figurex.basemap.Basemap) (context manager)
  - [Cartopy](https://figurex.readthedocs.io/en/latest/#figurex.cartopy.Cartopy) (context manager)



  ```bash
  pip install figurex
  ```

  If you want to use geospatial mapping features with [Basemap](https://pypi.org/project/basemap/) or [Cartopy](https://pypi.org/project/Cartopy/), install the corresponding optional features:
  ```bash
  pip install figurex[basemap]
  pip install figurex[cartopy]
  ```



  - python >3.9
  - numpy
  - matplotlib
  - basemap >=1.4.1 (optional)
  - cartopy >=0.23 (optional)
  - scipy (optional, required by cartopy)



  - A discussion on [GitHub/matplotlib](https://github.com/matplotlib/matplotlib/issues/5218/) actually requested this feature long ago.
  - The project [GitHub/contextplt](https://toshiakiasakura.github.io/contextplt/notebooks/usage.html) has implemented a similar concept.


pkgId: 459cb0a67f7c31577c50105d26deb03e504f0ea6d8cfb8b219f90d84d748c0a6
name: python-fild-api-hub-help
arch: noarch
version: 0.0.6
epoch: 0
release: 1
summary: Development documents and examples for fild-api-hub
url: https://github.com/elenakulgavaya/fild-api-hub
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fild-api-hub-0.0.6-1.src.rpm
location_href: Packages/python-fild-api-hub-help-0.0.6-1.noarch.rpm
checksum_type: sha256
description:
  ![Downloads](https://img.shields.io/pypi/dm/fild-api-hub.svg?style=flat)
  ![Python Versions](https://img.shields.io/pypi/pyversions/fild-api-hub.svg?style=flat)
  ![License](https://img.shields.io/pypi/l/fild-api-hub.svg?version=latest)
  [![Build Status](https://github.com/elenakulgavaya/fild-api-hub/workflows/Tests/badge.svg)](https://github.com/elenakulgavaya/fild-api-hub/actions)

  The FILD Api Hub is a set of tools enabling using FILD described contracts
  in tests.

  Configure your project with yaml files in `etc/config.yaml` containing
  ```yaml
  App:
    url: http://localhost:8000
  MockServer:
    host: localhost
    port: 8088
  ```

  Override any local configuration variables by adding `etc/local.yaml`
  ```yaml
  MockServer:
    port: 8080
  ```

  Use `ApiMethod` to describe the API
  ```python
  from fild.sdk import Dictionary, Int, String, Uuid
  from fildapi import ApiMethod, HttpMethod


  SERVICE = 'customer_api'
  BASE_URL = 'http://mydomain.customerapi'


  class CreateUserRequest(Dictionary):
      Name = String(name='name')
      Email = String(name='email')
      Age = Int(name='age', min_val=18, max_val=120)


  class CreateUserResponse(Dictionary):
      Id = Uuid(name='id')


  class CreateUser(ApiMethod):
      method = HttpMethod.POST
      url = 'api/users'
      req_body = CreateUserRequest
      resp_body = CreateUserResponse
  ```

  Use `ApiMethod` for mocking and verifying integrations
  ```python
  from customer_api import CreateUser


  def test_failed_to_create_user():
      CreateUser.reply(status=400)
      


  def test_verify_call_to_customer_api():
      CreateUser.reply()
      
      CreateUser.verify_called()
  ```

  Use `ApiCaller` to test the api:
  ```python
  from fildapi import ApiCaller
  from customer_api import CreateUser


  class CreateUserCall(ApiCaller):
      method = CreateUser


  def test_create_user():
      CreateUserCall().request().verify_response()
  ```


pkgId: 64b254dbe75e3892df229a510752d04b7c8e4c2b6b51b65165fa06b66b559e82
name: python-fild-cfg-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for fild-cfg
url: https://github.com/elenakulgavaya/fild-cfg
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fild-cfg-0.0.1-1.src.rpm
location_href: Packages/python-fild-cfg-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Downloads](https://img.shields.io/pypi/dm/fild-cfg.svg?style=flat)
  ![Python Versions](https://img.shields.io/pypi/pyversions/fild-cfg.svg?style=flat)
  ![License](https://img.shields.io/pypi/l/fild-cfg.svg?version=latest)
  [![Build Status](https://github.com/elenakulgavaya/fild-cfg/workflows/Tests/badge.svg)](https://github.com/elenakulgavaya/fild-cfg/actions)


pkgId: 3bce45e0a607e0a75fc70b4af76f208c483c5d33a3e217fdba35b06058e84182
name: python-fild-db-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for fild-db
url: https://github.com/elenakulgavaya/fild-db
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fild-db-0.0.4-1.src.rpm
location_href: Packages/python-fild-db-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  ![Downloads](https://img.shields.io/pypi/dm/fild-db.svg?style=flat)
  ![Python Versions](https://img.shields.io/pypi/pyversions/fild-db.svg?style=flat)
  ![License](https://img.shields.io/pypi/l/fild-db.svg?version=latest)
  [![Build Status](https://github.com/elenakulgavaya/fild-db/workflows/Tests/badge.svg)](https://github.com/elenakulgavaya/fild-compare/actions)


pkgId: 75508927569b5106cc8a4a8c4ae09cdae98d1332235d86f97a70d619ac87b71a
name: python-fild-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for fild
url: https://github.com/elenakulgavaya/fild
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fild-0.1.1-1.src.rpm
location_href: Packages/python-fild-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Downloads](https://img.shields.io/pypi/dm/fild.svg?style=flat)
  ![Python Versions](https://img.shields.io/pypi/pyversions/fild.svg?style=flat)
  ![License](https://img.shields.io/pypi/l/fild.svg?version=latest)
  [![Build Status](https://github.com/elenakulgavaya/fild/workflows/Tests/badge.svg)](https://github.com/elenakulgavaya/fild/actions)

  FILD is a library for contract testing. FILD allows to store descriptive
  structure of the API and use it further for generating test data based on Faker.

  The basic type for usage is Field, any other types should inherit from.
  Field supports the description of the API parameter within the following:\
  `name`: key in json\
  `required`: identifies the necessity of presense of the
  key in the resulting json.\
  `allow_none`: should be true if the value can be null in the
  json.\
  `default`: default value to be used in regular generation.
  Can either be the value or the callable to generate.

  Abstract method `generate_value` is used to specify the rules
  based on which the value should be generated. When defining
  new type, inherited from Field, the method should be overriden
  to describe the generation procedure.

  Library supports multi-level hierarchy with Arrays and Dictionaries.

  Library also provides some dict operating methods.\
  `filter_dict`: allows to apply value/callable filter to dict by values\
  `merge_with_updates`: merges two dicts with either overriding or only adding
  values to the target dictionary.\
  `normalize`: sorts lists - both top level and embeded - to represent
  the desired order.



  Field object is used to describe data structures
  ```python
  from fild.sdk import Dictionary, Enum, Int, String, Uuid


  class Gender(Enum):
      Male = 'male'
      Femail = 'female'
      Other = 'other'


  class Customer(Dictionary):
      Id = Uuid(name='id')
      Name = String(name='name', max_len=100)
      Age = Int(name='age', min_val=18, max_val=120)
      Gender = Gender(name='gender', required=False)
      Email = String(name='email')
  ```

  Based on the description the data can be generated by calling constructor with
  or without parameters
  ```python
  generated_customer = Customer()
  generated_full_customer = Customer(is_full=True)
  ```


pkgId: 33a0d2eb2de0430b037ff728b23ba86525a74ff277cee8f5ca068b74473da08d
name: python-file-clerk-help
arch: noarch
version: 1.1.7
epoch: 0
release: 1
summary: Development documents and examples for file-clerk
url: https://github.com/HundredVisionsGuy/file-clerk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-file-clerk-1.1.7-1.src.rpm
location_href: Packages/python-file-clerk-help-1.1.7-1.noarch.rpm
checksum_type: sha256
description:
  A collection of functions for dealing with files and file content.
  This was a library I created for previous projects that deal with files
  and file paths in order to get code from files, lists of files in
  project folders, file extensions, and allows us to capture just files
  of a particular type. I also developed my projects on Windows OS, so
  these functions were designed to work with the file paths on Windows,
  Mac, and Linux (Windows is the one with backslashes - wacky, I know.).


pkgId: cb4f7ba7db3a277da4964ba79f35204b1988f70cb1c33c2709b73350da0e85de
name: python-file-process-help
arch: noarch
version: 1.4.4
epoch: 0
release: 1
summary: Development documents and examples for file-process
url: https://github.com/Superbio-ai/file-process
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-file-process-1.4.4-1.src.rpm
location_href: Packages/python-file-process-help-1.4.4-1.noarch.rpm
checksum_type: sha256
description:
  Superbio.ai

  Package that can validate and return preview for different files.

  Currenty supported extensions:

  - .h5ad
  - .csv
  - .tsv
  - .txt
  - .pdb
  - .fasta

  Usage:

  ```
  pip install file_process
  ```

  ```
  from file_process import preview_file
  try:
      processor = FileProcessFactory.get(file_data.filename, file_data.file)
  except WrongExtension as exc:
      raise CustomException from exc
  processor.validate(model_metadata_file)
  var_target_names, obs_target_names, obs_preview, var_preview, text_preview  = processor.get_preview()
  ```

  where:

  - file: an object of io.BytesIo or FileStorage which will be validated and previewed
  - filename: name of the validated file (only it's extention will be used)
  - model_metadata_file (optional parameter): file with metadata of a model that will be used for validation. If this file is provided, the code will check that this file has the same set of columns as the validated file. If this file is not provided, no validation will be applied.

  The code returns a list of var targets and obs targets (columns from the validated file), var preview and obs preview and text preview.
  If some is not applicable for the file, None will be returned).

  How to release:

  1. Make your changes
  2. Change the version in setup.py
  3. Merge changes into the main branch; it will be automatically released to [pypi](https://pypi.org/project/file-process/#history)


pkgId: 0ded0bcec89d104bb83047e633d0b03cea40affd873bcbd772276402d21061dd
name: python-file-tree-help
arch: noarch
version: 1.5.0
epoch: 0
release: 1
summary: Development documents and examples for file-tree
url: https://git.fmrib.ox.ac.uk/fsl/file-tree
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-file-tree-1.5.0-1.src.rpm
location_href: Packages/python-file-tree-help-1.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/file-tree)](https://pypi.org/project/file-tree/)
  [![Documentation](https://img.shields.io/badge/Documentation-file--tree-blue)](https://open.win.ox.ac.uk/pages/fsl/file-tree/)
  [![Documentation](https://img.shields.io/badge/Documentation-fsleyes-blue)](https://open.win.ox.ac.uk/pages/fsl/fsleyes/fsleyes/userdoc/filetree.html)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.6576809.svg)](https://doi.org/10.5281/zenodo.6576809)
  [![Pipeline status](https://git.fmrib.ox.ac.uk/fsl/file-tree/badges/master/pipeline.svg)](https://git.fmrib.ox.ac.uk/fsl/file-tree/-/pipelines)
  [![Coverage report](https://git.fmrib.ox.ac.uk/fsl/file-tree/badges/master/coverage.svg)](https://open.win.ox.ac.uk/pages/fsl/file-tree/htmlcov)

  Framework to represent structured directories in python as FileTree objects. FileTrees can be read in from simple text files describing the directory structure. This is particularly useful for pipelines with large number of input, output, and intermediate files. It can also be used to visualise the data in structured directories using FSLeyes or `file-tree` on the command line.

  - General documentation: https://open.win.ox.ac.uk/pages/fsl/file-tree/
  - FSLeyes documentation on using FileTrees: https://open.win.ox.ac.uk/pages/fsl/fsleyes/fsleyes/userdoc/filetree.html


  This package uses [uv](https://docs.astral.sh/uv/) for project management.
  You will need to install uv to develop this package.

  First clone the repository:
  ```shell
  git clone https://git.fmrib.ox.ac.uk/fsl/file-tree.git
  ```

  Then we can ask uv to set up the local envoriment.
  ```shell
  cd file-tree
  uv sync
  ```


  Tests are run using the [pytest](https://docs.pytest.org) framework.
  This will already be available in the `uv` virtual environment.
  ```shell
  uv run pytest src/tests
  ```


  The documentation is build using [sphinx](https://www.sphinx-doc.org/en/master/).
  ```shell
  cd doc
  uv run sphinx-build source build
  open build/index.html
  ```


  [Merge requests](https://git.fmrib.ox.ac.uk/fsl/file-tree/-/merge_requests) with any bug fixes or documentation updates are always welcome.

  For new features, please raise an [issue](https://git.fmrib.ox.ac.uk/fsl/file-tree/-/issues) to allow for discussion before you spend the time implementing them.


  - Ensure CHANGELOG.md is up to date.
      - All commits can be seen in gitlab by clicking the "Unreleased" link in "CHANGELOG.md"
      - Add new header just below "## [Unreleased]" with the new version
      - Update the footnotes for both the new version and [Unreleased]
  - Edit the version number on `pyproject.toml`
  - Create a new tag for the version number
  - Push to gitlab (including tags)
  - After the continuous integration (CI) succeeds, manually run the job to upload file-tree to pypi (see [here](https://git.fmrib.ox.ac.uk/fsl/file-tree/-/pipelines/latest))
  - Upload code on conda-forge using their automated release detection.


  Tests are run using the [pytest](https://docs.pytest.org) framework. After installation (`pip install pytest`) they can be run from the project root as:
  ```shell
  pytest src/tests
  ```

rpm_license:
  Copyright 2021 University of Oxford  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: 273cd8d9e93c9e30688a318e6c03fa6b611490e412133854fea76871cff49941
name: python-fileboxes-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for fileboxes
url: https://pypi.org/project/fileboxes/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fileboxes-0.1.4-1.src.rpm
location_href: Packages/python-fileboxes-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <img width="100" src="https://github.com/user-attachments/assets/08d8ef52-9c58-41a3-b9b8-ef53be0ee1b7" alt="ExpiraBot Logo" align="center">
  </div>
  <h1 align="center" style="margin-top: 20px;"> Fileboxes </h1>


  Have you ever wondered how is the internal structure of files like `.docx`, `.pptx` or `.xlsx`?
  It is actually just a ZIP with a bunch of `.xml` files inside it, following the Office Open XML file formats.

  I like the idea, but I do not like XML.

  This project is a way to write your custom file formats with zips and using a pythonic api.


pkgId: a6f1da6f0847e281a18ce812edad1f21947ff3dada04bf35473a8bff9a1b71c8
name: python-fimm-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for fimm
url: https://github.com/rapanti/fimm
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fimm-0.0.3-1.src.rpm
location_href: Packages/python-fimm-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Finetune PyTorch Image Models with TIMM

  This project provides a simple way to finetune PyTorch Image Models with TIMM.


  To install FIMM (`fimm`), you can simply use `pip`:

  ```bash
  pip install fimm
  ```


  To install from source, you can clone this repo and install with `pip`:

  ```bash
  git clone https://github.com/rapanti/fimm
  pip install -e fimm  # -e for editable mode
  ```


  To use FIMM, you can simply run the follwing command to train or finetune a model:
  ```bash
  train --data-dir /path/to/dataset --model resnet50 --experiment resnet50 # this trains a resnet50 model from scratch
  train --data-dir /path/to/dataset --model resnet50 --experiment resnet50 --pretrained  # this finetunes a resnet50 model
  ```

  To validate the performance of a model, you can simply run the following command:
  ```bash
  validate --data-dir /path/to/eval/dataset --model resnet50 --checkpoint output/train/resnet50/model_best.pth.tar # this tests the resnet50 model
  ```

rpm_license:
  MIT License  Copyright (c) 2024 rapanti  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: 8cae0e58bec24bc2aaa4b7b45bc09bd5f6e16eb418db271d5c3d826663afe3ba
name: python-fimserv-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for fimserv
url: https://github.com/sdmlua/OperationalOWPFIM
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fimserv-0.1.5-1.src.rpm
location_href: Packages/python-fimserv-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/github/v/release/sdmlua/OperationalOWPFIM)](https://github.com/sdmlua/OperationalOWPFIM/releases)
  [![Issues](https://img.shields.io/github/issues/sdmlua/OperationalOWPFIM)](https://github.com/sdmlua/OperationalOWPFIM/issues)
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://opensource.org/licenses/GPL-3.0)
  ![Views](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https://github.com/sdmlua/OperationalOWPFIM&count_bg=%2379C83D&title_bg=%23555555&icon=github.svg&icon_color=%23E7E7E7&title=Views&edge_flat=false)



  | | |
  | --- | --- |
  | <a href="https://sdml.ua.edu"><img src="https://sdml.ua.edu/wp-content/uploads/2023/01/SDML_logo_Sq_grey.png" alt="SDML Logo" width="300"></a> | This package presents a sophisticated and user friendly approach to generate Operational flood inundation map using NOAA_OWP Height Above Nearest Drainage (HAND) method-FIM model using National Water Model retrospective and forecasted streamflow data.It is developed under Surface Dynamics Modeling Lab (SDML). |



  NOAA-Office of Water Predictions (OWP) use HAND FIM model for operational flood forecasting across CONUS (https://github.com/NOAA-OWP/inundation-mapping). It is a terrain based model that uses the Discharge and reach avergaed synthetic rating curves (SRCs) to generate the inundation and depth rasters at HUC-8 scale (Hydrologic Unit Code-8). The model is capable to produce flood maps less than a minute for all order streams within the watershed. The HUC-8 watersheds have catchment area more than 1000 sqkm , that makes this framework scalable and computationaly efficient. It is a fluvial flood model and doesnot have urban flood compponant.The last released version of the model is 4.5and has gone through significant improvements.The present notebook is user freindly and able to run the HAND FIM model from cloud and capable of running mutiple HUC-8s simulteniously.This model can run at any temporal resolution(hourly, daily, monthly etc).It uses the NHDPlus unique river identifiers and assign the streamflow for each of the segment.



  ```bash
  OperationalOWPFIM/
  ├── docs/(contain the code code usage))
  ├── data/
  │   └── inputs/(NWM Discharge value will be saved here in a format of STH_HUC8code)
  ├── src/owphandfim/
  │           ├── streamflowdata/
                  ├── nwmretrospectivedata.py
                  └── forecasteddata.py
  │           ├── plots/ (Contains different plotting functionality)
              ├── FIMsubset/
                  ├── xycoord.py
                  └── shpsubset.py
              ├── datadownload.py (Includes all HUC8 raster things)
              ├── runFIM.py (OWPHAND model)
  └── tests/(includes test cases for each functionality)
  ```

  To use this code,

  ```bash

  pip install 'owphandfim @ git+https://github.com/supathdhitalGEO/owphandfim.git'


  poetry add git+https://github.com/supathdhitalGEO/owphandfim.git
  ```

  Once it installed, import it like
  ```bash
  import owphandfim as fm


  fm.DownloadHUC8(HUC)    #Like this it contains multiples functionality.
  ```
  Then there are a lot of different modules, call it to work. For reference to run, [Here (docs/code_usage.ipynb)](./docs/code_usage.ipynb) is the sample usuage of this code and different functionality.


  | | |
  | --- | --- |
  | ![alt text](https://ciroh.ua.edu/wp-content/uploads/2022/08/CIROHLogo_200x200.png) | Funding for this project was provided by the National Oceanic & Atmospheric Administration (NOAA), awarded to the Cooperative Institute for Research to Operations in Hydrology (CIROH) through the NOAA Cooperative Agreement with The University of Alabama (#Funding ID). |


pkgId: b6bd1864db472b90f941ab2910a8c8be59c29f78baec8b42b70c7f320c6d8e93
name: python-fimserve-help
arch: noarch
version: 0.1.51
epoch: 0
release: 1
summary: Development documents and examples for fimserve
url: https://github.com/sdmlua/OperationalOWPFIM
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fimserve-0.1.51-1.src.rpm
location_href: Packages/python-fimserve-help-0.1.51-1.noarch.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/github/v/release/sdmlua/OperationalOWPFIM)](https://github.com/sdmlua/OperationalOWPFIM/releases)
  [![Issues](https://img.shields.io/github/issues/sdmlua/OperationalOWPFIM)](https://github.com/sdmlua/OperationalOWPFIM/issues)
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://opensource.org/licenses/GPL-3.0)
  ![Views](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https://github.com/sdmlua/OperationalOWPFIM&count_bg=%2379C83D&title_bg=%23555555&icon=github.svg&icon_color=%23E7E7E7&title=Views&edge_flat=false)



  | | |
  | --- | --- |
  | <a href="https://sdml.ua.edu"><img src="https://sdml.ua.edu/wp-content/uploads/2023/01/SDML_logo_Sq_grey.png" alt="SDML Logo" width="300"></a> | This package presents a sophisticated and user friendly approach to generate Operational flood inundation map using NOAA_OWP Height Above Nearest Drainage (HAND) method-FIM model using National Water Model retrospective and forecasted streamflow data.It is developed under Surface Dynamics Modeling Lab (SDML). |



  NOAA-Office of Water Predictions (OWP) use HAND FIM model for operational flood forecasting across CONUS (https://github.com/NOAA-OWP/inundation-mapping). It is a terrain based model that uses the Discharge and reach avergaed synthetic rating curves (SRCs) to generate the inundation and depth rasters at HUC-8 scale (Hydrologic Unit Code-8). The model is capable to produce flood maps less than a minute for all order streams within the watershed. The HUC-8 watersheds have catchment area more than 1000 sqkm , that makes this framework scalable and computationaly efficient. It is a fluvial flood model and doesnot have urban flood compponant.The last released version of the model is 4.5and has gone through significant improvements.The present notebook is user freindly and able to run the HAND FIM model from cloud and capable of running mutiple HUC-8s simulteniously.This model can run at any temporal resolution(hourly, daily, monthly etc).It uses the NHDPlus unique river identifiers and assign the streamflow for each of the segment.



  ```bash
  OperationalOWPFIM/
  ├── docs/(contain the code code usage))
  ├── data/
  │   └── inputs/(NWM Discharge value will be saved here in a format of STH_HUC8code)
  ├── src/owphandfim/
  │           ├── streamflowdata/
                  ├── nwmretrospectivedata.py
                  └── forecasteddata.py
  │           ├── plots/ (Contains different plotting functionality)
              ├── FIMsubset/
                  ├── xycoord.py
                  └── shpsubset.py
              ├── datadownload.py (Includes all HUC8 raster things)
              ├── runFIM.py (OWPHAND model)
  └── tests/(includes test cases for each functionality)
  ```

  To use this code,

  ```bash

  pip install fimserve


  poetry add fimserve
  ```

  Once it installed, import it like
  ```bash
  import fimserve as fm


  fm.DownloadHUC8(HUC)    #Like this it contains multiples functionality.
  ```
  Then there are a lot of different modules, call it to work. For reference to run, [Here (docs/code_usage.ipynb)](./docs/code_usage.ipynb) is the sample usuage of this code and different functionality.


  | | |
  | --- | --- |
  | ![alt text](https://ciroh.ua.edu/wp-content/uploads/2022/08/CIROHLogo_200x200.png) | Funding for this project was provided by the National Oceanic & Atmospheric Administration (NOAA), awarded to the Cooperative Institute for Research to Operations in Hydrology (CIROH) through the NOAA Cooperative Agreement with The University of Alabama (#Funding ID). |


pkgId: e5abf1aae8600f920050f7fe7bed3e1511a312542f0e57ee68b5bc5e583bc503
name: python-final-test-srver-report002-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for final-test-srver-report002
url: https://pypi.org/project/final-test-srver-report002/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-final-test-srver-report002-0.1-1.src.rpm
location_href: Packages/python-final-test-srver-report002-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  This project provides a basic monitoring agent and a web server to display server metrics like memory usage.


pkgId: b5a4d4714489e28651a432ef943b3b3cc32a0605ef40cf5ffea8a3439425be71
name: python-finbourne-access-sdk-help
arch: noarch
version: 2.1.199
epoch: 0
release: 1
summary: Development documents and examples for finbourne-access-sdk
url: https://github.com/finbourne/finbourne-access-sdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-finbourne-access-sdk-2.1.199-1.src.rpm
location_href: Packages/python-finbourne-access-sdk-help-2.1.199-1.noarch.rpm
checksum_type: sha256
description:
  *ApplicationMetadataApi* | [**list_access_controlled_resources**](docs/ApplicationMetadataApi.md#list_access_controlled_resources) | **GET** /api/metadata/access/resources | ListAccessControlledResources: Get resources available for access control
  *PoliciesApi* | [**add_to_policy_collection**](docs/PoliciesApi.md#add_to_policy_collection) | **POST** /api/policycollections/{code}/add | AddToPolicyCollection: Add To PolicyCollection
  *PoliciesApi* | [**create_policy**](docs/PoliciesApi.md#create_policy) | **POST** /api/policies | CreatePolicy: Create Policy
  *PoliciesApi* | [**create_policy_collection**](docs/PoliciesApi.md#create_policy_collection) | **POST** /api/policycollections | CreatePolicyCollection: Create PolicyCollection
  *PoliciesApi* | [**delete_policy**](docs/PoliciesApi.md#delete_policy) | **DELETE** /api/policies/{code} | DeletePolicy: Delete Policy
  *PoliciesApi* | [**delete_policy_collection**](docs/PoliciesApi.md#delete_policy_collection) | **DELETE** /api/policycollections/{code} | DeletePolicyCollection: Delete PolicyCollection
  *PoliciesApi* | [**evaluate**](docs/PoliciesApi.md#evaluate) | **POST** /api/me | Evaluate: Run one or more evaluations
  *PoliciesApi* | [**get_own_policies**](docs/PoliciesApi.md#get_own_policies) | **GET** /api/me | GetOwnPolicies: Get policies of requesting user
  *PoliciesApi* | [**get_policy**](docs/PoliciesApi.md#get_policy) | **GET** /api/policies/{code} | GetPolicy: Get Policy
  *PoliciesApi* | [**get_policy_collection**](docs/PoliciesApi.md#get_policy_collection) | **GET** /api/policycollections/{code} | GetPolicyCollection: Get PolicyCollection
  *PoliciesApi* | [**list_policies**](docs/PoliciesApi.md#list_policies) | **GET** /api/policies | ListPolicies: List Policies
  *PoliciesApi* | [**list_policy_collections**](docs/PoliciesApi.md#list_policy_collections) | **GET** /api/policycollections | ListPolicyCollections: List PolicyCollections
  *PoliciesApi* | [**page_policies**](docs/PoliciesApi.md#page_policies) | **GET** /api/policies/page | PagePolicies: Page Policies
  *PoliciesApi* | [**page_policy_collections**](docs/PoliciesApi.md#page_policy_collections) | **GET** /api/policycollections/page | PagePolicyCollections: Page PolicyCollections
  *PoliciesApi* | [**remove_from_policy_collection**](docs/PoliciesApi.md#remove_from_policy_collection) | **POST** /api/policycollections/{code}/remove | RemoveFromPolicyCollection: Remove From PolicyCollection
  *PoliciesApi* | [**update_policy**](docs/PoliciesApi.md#update_policy) | **PUT** /api/policies/{code} | UpdatePolicy: Update Policy
  *PoliciesApi* | [**update_policy_collection**](docs/PoliciesApi.md#update_policy_collection) | **PUT** /api/policycollections/{code} | UpdatePolicyCollection: Update PolicyCollection
  *PolicyTemplatesApi* | [**create_policy_template**](docs/PolicyTemplatesApi.md#create_policy_template) | **POST** /api/policytemplates | [EXPERIMENTAL] CreatePolicyTemplate: Create a Policy Template
  *PolicyTemplatesApi* | [**delete_policy_template**](docs/PolicyTemplatesApi.md#delete_policy_template) | **DELETE** /api/policytemplates/{code} | [EXPERIMENTAL] DeletePolicyTemplate: Deleting a policy template
  *PolicyTemplatesApi* | [**generate_policy_from_template**](docs/PolicyTemplatesApi.md#generate_policy_from_template) | **POST** /api/policytemplates/$generatepolicy | [EXPERIMENTAL] GeneratePolicyFromTemplate: Generate policy from template
  *PolicyTemplatesApi* | [**get_policy_template**](docs/PolicyTemplatesApi.md#get_policy_template) | **GET** /api/policytemplates/{code} | [EXPERIMENTAL] GetPolicyTemplate: Retrieving one Policy Template
  *PolicyTemplatesApi* | [**list_policy_templates**](docs/PolicyTemplatesApi.md#list_policy_templates) | **GET** /api/policytemplates | [EXPERIMENTAL] ListPolicyTemplates: List Policy Templates
  *PolicyTemplatesApi* | [**update_policy_template**](docs/PolicyTemplatesApi.md#update_policy_template) | **PUT** /api/policytemplates/{code} | [EXPERIMENTAL] UpdatePolicyTemplate: Update a Policy Template
  *RolesApi* | [**add_policy_collection_to_role**](docs/RolesApi.md#add_policy_collection_to_role) | **POST** /api/roles/{scope}/{code}/policycollections | AddPolicyCollectionToRole: Add policy collections to a role
  *RolesApi* | [**create_role**](docs/RolesApi.md#create_role) | **POST** /api/roles | CreateRole: Create Role
  *RolesApi* | [**delete_role**](docs/RolesApi.md#delete_role) | **DELETE** /api/roles/{code} | DeleteRole: Delete Role
  *RolesApi* | [**get_role**](docs/RolesApi.md#get_role) | **GET** /api/roles/{code} | GetRole: Get Role
  *RolesApi* | [**list_roles**](docs/RolesApi.md#list_roles) | **GET** /api/roles | ListRoles: List Roles
  *RolesApi* | [**remove_policy_collection_from_role**](docs/RolesApi.md#remove_policy_collection_from_role) | **DELETE** /api/roles/{scope}/{code}/policycollections/{policycollectionscope}/{policycollectioncode} | RemovePolicyCollectionFromRole: Remove policy collection from role
  *RolesApi* | [**update_role**](docs/RolesApi.md#update_role) | **PUT** /api/roles/{code} | UpdateRole: Update Role
  *UserRolesApi* | [**add_policy_collection_to_user_role**](docs/UserRolesApi.md#add_policy_collection_to_user_role) | **POST** /api/userroles/{userid}/policycollections | AddPolicyCollectionToUserRole: Add a policy collection to a user-role
  *UserRolesApi* | [**add_policy_to_user_role**](docs/UserRolesApi.md#add_policy_to_user_role) | **POST** /api/userroles/{userid}/policies | AddPolicyToUserRole: Add a policy to a user-role
  *UserRolesApi* | [**create_user_role**](docs/UserRolesApi.md#create_user_role) | **POST** /api/userroles | CreateUserRole: Create a user-role
  *UserRolesApi* | [**delete_user_role**](docs/UserRolesApi.md#delete_user_role) | **DELETE** /api/userroles/{userid} | DeleteUserRole: Delete a user-role
  *UserRolesApi* | [**get_user_role**](docs/UserRolesApi.md#get_user_role) | **GET** /api/userroles/{userid} | GetUserRole: Get a user-role
  *UserRolesApi* | [**list_user_roles**](docs/UserRolesApi.md#list_user_roles) | **GET** /api/userroles | ListUserRoles: List user-roles
  *UserRolesApi* | [**remove_policy_collection_from_user_role**](docs/UserRolesApi.md#remove_policy_collection_from_user_role) | **DELETE** /api/userroles/{userid}/policycollections/{policyCollectionScope}/{policyCollectionCode} | RemovePolicyCollectionFromUserRole: Remove a policy collection from a user-role
  *UserRolesApi* | [**remove_policy_from_user_role**](docs/UserRolesApi.md#remove_policy_from_user_role) | **DELETE** /api/userroles/{userid}/policies/{policyScope}/{policyCode} | RemovePolicyFromUserRole: Remove a policy from a user-role
  *UserRolesApi* | [**update_user_role**](docs/UserRolesApi.md#update_user_role) | **POST** /api/userroles/{userid}/update | UpdateUserRole: Update a user-role
  <a id="documentation-for-models"></a>

   - [AccessControlledAction](docs/AccessControlledAction.md)
   - [AccessControlledResource](docs/AccessControlledResource.md)
   - [ActionId](docs/ActionId.md)
   - [AddPolicyCollectionToRoleRequest](docs/AddPolicyCollectionToRoleRequest.md)
   - [AddPolicyToRoleRequest](docs/AddPolicyToRoleRequest.md)
   - [AddToPolicyCollectionRequest](docs/AddToPolicyCollectionRequest.md)
   - [AsAtPredicateContract](docs/AsAtPredicateContract.md)
   - [AsAtRangeForSpec](docs/AsAtRangeForSpec.md)
   - [AsAtRelative](docs/AsAtRelative.md)
   - [AttachedPolicyDefinitionResponse](docs/AttachedPolicyDefinitionResponse.md)
   - [DateQuality](docs/DateQuality.md)
   - [DateUnit](docs/DateUnit.md)
   - [EffectiveDateHasQuality](docs/EffectiveDateHasQuality.md)
   - [EffectiveDateRelative](docs/EffectiveDateRelative.md)
   - [EffectiveRange](docs/EffectiveRange.md)
   - [EntitlementMetadata](docs/EntitlementMetadata.md)
   - [EvaluationRequest](docs/EvaluationRequest.md)
   - [EvaluationResponse](docs/EvaluationResponse.md)
   - [EvaluationResult](docs/EvaluationResult.md)
   - [ForSpec](docs/ForSpec.md)
   - [GeneratePolicyFromTemplateRequest](docs/GeneratePolicyFromTemplateRequest.md)
   - [GeneratedPolicyComponents](docs/GeneratedPolicyComponents.md)
   - [Grant](docs/Grant.md)
   - [HowSpec](docs/HowSpec.md)
   - [IdSelectorDefinition](docs/IdSelectorDefinition.md)
   - [IdentifierPartSchema](docs/IdentifierPartSchema.md)
   - [IfExpression](docs/IfExpression.md)
   - [IfFeatureChainExpression](docs/IfFeatureChainExpression.md)
   - [IfIdentityClaimExpression](docs/IfIdentityClaimExpression.md)
   - [IfIdentityScopeExpression](docs/IfIdentityScopeExpression.md)
   - [IfRequestHeaderExpression](docs/IfRequestHeaderExpression.md)
   - [KeyValuePairOfStringToString](docs/KeyValuePairOfStringToString.md)
   - [Link](docs/Link.md)
   - [LusidProblemDetails](docs/LusidProblemDetails.md)
   - [LusidValidationProblemDetails](docs/LusidValidationProblemDetails.md)
   - [MatchAllSelectorDefinition](docs/MatchAllSelectorDefinition.md)
   - [MetadataExpression](docs/MetadataExpression.md)
   - [MetadataSelectorDefinition](docs/MetadataSelectorDefinition.md)
   - [NonTransitiveSupervisorRoleResource](docs/NonTransitiveSupervisorRoleResource.md)
   - [Operator](docs/Operator.md)
   - [PointInTimeSpecification](docs/PointInTimeSpecification.md)
   - [PolicyCollectionCreationRequest](docs/PolicyCollectionCreationRequest.md)
   - [PolicyCollectionId](docs/PolicyCollectionId.md)
   - [PolicyCollectionResponse](docs/PolicyCollectionResponse.md)
   - [PolicyCollectionUpdateRequest](docs/PolicyCollectionUpdateRequest.md)
   - [PolicyCreationRequest](docs/PolicyCreationRequest.md)
   - [PolicyId](docs/PolicyId.md)
   - [PolicyIdRoleResource](docs/PolicyIdRoleResource.md)
   - [PolicyResponse](docs/PolicyResponse.md)
   - [PolicySelectorDefinition](docs/PolicySelectorDefinition.md)
   - [PolicyTemplateCreationRequest](docs/PolicyTemplateCreationRequest.md)
   - [PolicyTemplateResponse](docs/PolicyTemplateResponse.md)
   - [PolicyTemplateUpdateRequest](docs/PolicyTemplateUpdateRequest.md)
   - [PolicyTemplatedSelector](docs/PolicyTemplatedSelector.md)
   - [PolicyType](docs/PolicyType.md)
   - [PolicyUpdateRequest](docs/PolicyUpdateRequest.md)
   - [RelativeToDateTime](docs/RelativeToDateTime.md)
   - [RemoveFromPolicyCollectionRequest](docs/RemoveFromPolicyCollectionRequest.md)
   - [RequestDetails](docs/RequestDetails.md)
   - [RequestedActionKey](docs/RequestedActionKey.md)
   - [ResourceDetails](docs/ResourceDetails.md)
   - [ResourceListOfAccessControlledResource](docs/ResourceListOfAccessControlledResource.md)
   - [ResourceListOfPolicyCollectionResponse](docs/ResourceListOfPolicyCollectionResponse.md)
   - [ResourceListOfPolicyResponse](docs/ResourceListOfPolicyResponse.md)
   - [ResourceListOfPolicyTemplateResponse](docs/ResourceListOfPolicyTemplateResponse.md)
   - [ResourceListOfUserRoleResponse](docs/ResourceListOfUserRoleResponse.md)
   - [RoleCreationRequest](docs/RoleCreationRequest.md)
   - [RoleId](docs/RoleId.md)
   - [RoleResourceRequest](docs/RoleResourceRequest.md)
   - [RoleResponse](docs/RoleResponse.md)
   - [RoleUpdateRequest](docs/RoleUpdateRequest.md)
   - [SelectorDefinition](docs/SelectorDefinition.md)
   - [TemplateMetadata](docs/TemplateMetadata.md)
   - [TemplateSelection](docs/TemplateSelection.md)
   - [TextOperator](docs/TextOperator.md)
   - [UserRoleCreationRequest](docs/UserRoleCreationRequest.md)
   - [UserRoleResponse](docs/UserRoleResponse.md)
   - [UserRoleUpdateRequest](docs/UserRoleUpdateRequest.md)
   - [WhenSpec](docs/WhenSpec.md)


pkgId: 80702c39e00c47a91c493ec7948a8ecfef6a5aa0f0b38904478f8fb71042adee
name: python-finbourne-horizon-sdk-help
arch: noarch
version: 2.1.434
epoch: 0
release: 1
summary: Development documents and examples for finbourne-horizon-sdk
url: https://github.com/finbourne/horizon-sdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-finbourne-horizon-sdk-2.1.434-1.src.rpm
location_href: Packages/python-finbourne-horizon-sdk-help-2.1.434-1.noarch.rpm
checksum_type: sha256
description:
  *InstrumentApi* | [**create_instrument**](docs/InstrumentApi.md#create_instrument) | **POST** /api/instrument/onboarding/create | [EARLY ACCESS] CreateInstrument: Creates and masters instruments with third party vendors.
  *InstrumentApi* | [**enrich_instrument**](docs/InstrumentApi.md#enrich_instrument) | **POST** /api/instrument/onboarding/enrich | [EARLY ACCESS] EnrichInstrument: Enriches an existing LUSID instrument using vendor data. Enrichment included identifiers, properties and market data.
  *InstrumentApi* | [**get_open_figi_parameter_option**](docs/InstrumentApi.md#get_open_figi_parameter_option) | **GET** /api/instrument/onboarding/search/openfigi/parameterOptions | [EARLY ACCESS] GetOpenFigiParameterOption: Get all supported market sector values for OpenFigi search
  *InstrumentApi* | [**retrieve_perm_id_result**](docs/InstrumentApi.md#retrieve_perm_id_result) | **GET** /api/instrument/onboarding/search/permid/{id} | [EARLY ACCESS] RetrievePermIdResult: Retrieve PermId results from a previous query.
  *InstrumentApi* | [**search_open_figi**](docs/InstrumentApi.md#search_open_figi) | **GET** /api/instrument/onboarding/search/openfigi | [EARLY ACCESS] SearchOpenFigi: Search OpenFigi for instruments that match the specified terms.
  *InstrumentApi* | [**vendors**](docs/InstrumentApi.md#vendors) | **GET** /api/instrument/onboarding/vendors | [EARLY ACCESS] Vendors: Gets the VendorProducts of any supported and licenced integrations for a given market sector and security type.
  *IntegrationsApi* | [**create_instance**](docs/IntegrationsApi.md#create_instance) | **POST** /api/integrations/instances | [EXPERIMENTAL] CreateInstance: Create a single integration instance.
  *IntegrationsApi* | [**delete_instance**](docs/IntegrationsApi.md#delete_instance) | **DELETE** /api/integrations/instances/{instanceId} | [EXPERIMENTAL] DeleteInstance: Delete a single integration instance.
  *IntegrationsApi* | [**execute_instance**](docs/IntegrationsApi.md#execute_instance) | **POST** /api/integrations/instances/{instanceId}/execute | [EXPERIMENTAL] ExecuteInstance: Execute an integration instance.
  *IntegrationsApi* | [**get_execution_ids_for_instance**](docs/IntegrationsApi.md#get_execution_ids_for_instance) | **GET** /api/integrations/instances/{instanceId}/executions | [EXPERIMENTAL] GetExecutionIdsForInstance: Get integration instance execution ids.
  *IntegrationsApi* | [**get_instance_optional_property_mapping**](docs/IntegrationsApi.md#get_instance_optional_property_mapping) | **GET** /api/integrations/instances/configuration/{integration}/{instanceId} | [EXPERIMENTAL] GetInstanceOptionalPropertyMapping: Get the Optional Property Mapping for an Integration Instance
  *IntegrationsApi* | [**get_integration_configuration**](docs/IntegrationsApi.md#get_integration_configuration) | **GET** /api/integrations/configuration/{integration} | [EXPERIMENTAL] GetIntegrationConfiguration: Get the Field and Property Mapping configuration for a given integration
  *IntegrationsApi* | [**get_schema**](docs/IntegrationsApi.md#get_schema) | **GET** /api/integrations/schema/{integration} | [EXPERIMENTAL] GetSchema: Get the JSON schema for the details section of an integration instance.
  *IntegrationsApi* | [**list_instances**](docs/IntegrationsApi.md#list_instances) | **GET** /api/integrations/instances | [EXPERIMENTAL] ListInstances: List instances across all integrations.
  *IntegrationsApi* | [**list_integrations**](docs/IntegrationsApi.md#list_integrations) | **GET** /api/integrations | [EXPERIMENTAL] ListIntegrations: List available integrations.
  *IntegrationsApi* | [**set_instance_optional_property_mapping**](docs/IntegrationsApi.md#set_instance_optional_property_mapping) | **PUT** /api/integrations/instances/configuration/{integration}/{instanceId} | [EXPERIMENTAL] SetInstanceOptionalPropertyMapping: Set the Optional Property Mapping for an Integration Instance
  *IntegrationsApi* | [**update_instance**](docs/IntegrationsApi.md#update_instance) | **PUT** /api/integrations/instances/{instanceId} | [EXPERIMENTAL] UpdateInstance: Update a single integration instance.
  *LogsApi* | [**get_integration_log_results**](docs/LogsApi.md#get_integration_log_results) | **GET** /api/logs | [EXPERIMENTAL] GetIntegrationLogResults: Get integration log results
  *ProcessHistoryApi* | [**create_complete_event**](docs/ProcessHistoryApi.md#create_complete_event) | **POST** /api/process-history/event/complete | [EARLY ACCESS] CreateCompleteEvent: Write a completed event to the Horizon Dashboard
  *ProcessHistoryApi* | [**create_update_event**](docs/ProcessHistoryApi.md#create_update_event) | **POST** /api/process-history/event/update | [EARLY ACCESS] CreateUpdateEvent: Write an update event to the Horizon Dashboard
  *ProcessHistoryApi* | [**get_latest_runs**](docs/ProcessHistoryApi.md#get_latest_runs) | **GET** /api/process-history/$latestRuns | [EARLY ACCESS] GetLatestRuns: Get latest run for each process
  *ProcessHistoryApi* | [**process_entry_updates**](docs/ProcessHistoryApi.md#process_entry_updates) | **POST** /api/process-history/entries/$query | [EARLY ACCESS] ProcessEntryUpdates: Get process entry updates for a query
  *ProcessHistoryApi* | [**process_history_entries**](docs/ProcessHistoryApi.md#process_history_entries) | **POST** /api/process-history/$query | [EARLY ACCESS] ProcessHistoryEntries: Get process history entries
  *RunsApi* | [**cancel_instance**](docs/RunsApi.md#cancel_instance) | **PUT** /api/runs/{runId}/cancel | [EXPERIMENTAL] CancelInstance: Cancels a single instance execution.
  *RunsApi* | [**get_run_results**](docs/RunsApi.md#get_run_results) | **GET** /api/runs | [EXPERIMENTAL] GetRunResults: Get run results
  *RunsApi* | [**rerun_instance**](docs/RunsApi.md#rerun_instance) | **PUT** /api/runs/{runId}/rerun | [EXPERIMENTAL] RerunInstance: Reruns a single instance execution.
  *VendorApi* | [**get_core_field_mappings_for_product_entity**](docs/VendorApi.md#get_core_field_mappings_for_product_entity) | **GET** /api/vendor/mappings/fields | [EARLY ACCESS] GetCoreFieldMappingsForProductEntity: Get core field mappings for a given vendor product's entity.
  *VendorApi* | [**get_optional_mappings_for_product_entity**](docs/VendorApi.md#get_optional_mappings_for_product_entity) | **GET** /api/vendor/mappings/optional | [EARLY ACCESS] GetOptionalMappingsForProductEntity: Get a user defined LUSID property mappings for the specified vendor / LUSID entity.
  *VendorApi* | [**get_property_mappings_for_product_entity**](docs/VendorApi.md#get_property_mappings_for_product_entity) | **GET** /api/vendor/mappings/properties | [EARLY ACCESS] GetPropertyMappingsForProductEntity: Gets the property mappings for a given vendor product's entity
  *VendorApi* | [**query_vendors**](docs/VendorApi.md#query_vendors) | **POST** /api/vendor/$query | [EARLY ACCESS] QueryVendors: Query for vendors and their packages with entities and sub-entities.
  *VendorApi* | [**set_optional_mappings_for_product_entity**](docs/VendorApi.md#set_optional_mappings_for_product_entity) | **POST** /api/vendor/mappings/optional | [EARLY ACCESS] SetOptionalMappingsForProductEntity: Create a user defined LUSID property mappings for the specified vendor / LUSID entity.
  <a id="documentation-for-models"></a>

   - [AllowedParameterValue](docs/AllowedParameterValue.md)
   - [AuditCompleteRequest](docs/AuditCompleteRequest.md)
   - [AuditCompleteResponse](docs/AuditCompleteResponse.md)
   - [AuditCompleteStatus](docs/AuditCompleteStatus.md)
   - [AuditFileDetails](docs/AuditFileDetails.md)
   - [AuditFileType](docs/AuditFileType.md)
   - [AuditUpdateRequest](docs/AuditUpdateRequest.md)
   - [AuditUpdateResponse](docs/AuditUpdateResponse.md)
   - [CreateInstanceRequest](docs/CreateInstanceRequest.md)
   - [EnrichmentResponse](docs/EnrichmentResponse.md)
   - [ExecuteInstanceResponse](docs/ExecuteInstanceResponse.md)
   - [FieldMapping](docs/FieldMapping.md)
   - [FileDetails](docs/FileDetails.md)
   - [IIntegrationLogResponse](docs/IIntegrationLogResponse.md)
   - [Identifiers](docs/Identifiers.md)
   - [InstanceExecutionReferenceId](docs/InstanceExecutionReferenceId.md)
   - [InstanceIdentifier](docs/InstanceIdentifier.md)
   - [IntegrationDescription](docs/IntegrationDescription.md)
   - [IntegrationInstance](docs/IntegrationInstance.md)
   - [IntegrationPropertyConfiguration](docs/IntegrationPropertyConfiguration.md)
   - [IntegrationRerunResponse](docs/IntegrationRerunResponse.md)
   - [IntegrationRunIntegration](docs/IntegrationRunIntegration.md)
   - [IntegrationRunLog](docs/IntegrationRunLog.md)
   - [IntegrationRunLogLink](docs/IntegrationRunLogLink.md)
   - [IntegrationRunResponse](docs/IntegrationRunResponse.md)
   - [IntegrationRunVersion](docs/IntegrationRunVersion.md)
   - [JSchema](docs/JSchema.md)
   - [JSchemaType](docs/JSchemaType.md)
   - [Link](docs/Link.md)
   - [LusidEntity](docs/LusidEntity.md)
   - [LusidField](docs/LusidField.md)
   - [LusidProblemDetails](docs/LusidProblemDetails.md)
   - [LusidPropertyDefinition](docs/LusidPropertyDefinition.md)
   - [LusidPropertyDefinitionOverrides](docs/LusidPropertyDefinitionOverrides.md)
   - [LusidPropertyDefinitionOverridesByType](docs/LusidPropertyDefinitionOverridesByType.md)
   - [LusidPropertyDefinitionOverridesResponse](docs/LusidPropertyDefinitionOverridesResponse.md)
   - [LusidPropertyToVendorFieldMapping](docs/LusidPropertyToVendorFieldMapping.md)
   - [LusidValidationProblemDetails](docs/LusidValidationProblemDetails.md)
   - [OnboardInstrumentRequest](docs/OnboardInstrumentRequest.md)
   - [OnboardInstrumentResponse](docs/OnboardInstrumentResponse.md)
   - [OpenFigiData](docs/OpenFigiData.md)
   - [OpenFigiParameterOptionName](docs/OpenFigiParameterOptionName.md)
   - [OpenFigiPermIdResult](docs/OpenFigiPermIdResult.md)
   - [OpenFigiSearchResult](docs/OpenFigiSearchResult.md)
   - [Optionality](docs/Optionality.md)
   - [PagedResourceListOfIIntegrationLogResponse](docs/PagedResourceListOfIIntegrationLogResponse.md)
   - [PagedResourceListOfIntegrationRunResponse](docs/PagedResourceListOfIntegrationRunResponse.md)
   - [PagedResourceListOfProcessInformation](docs/PagedResourceListOfProcessInformation.md)
   - [PagedResourceListOfProcessUpdateResult](docs/PagedResourceListOfProcessUpdateResult.md)
   - [PagedResourceListOfVendorProduct](docs/PagedResourceListOfVendorProduct.md)
   - [PermIdData](docs/PermIdData.md)
   - [ProcessInformation](docs/ProcessInformation.md)
   - [ProcessSummary](docs/ProcessSummary.md)
   - [ProcessUpdateResult](docs/ProcessUpdateResult.md)
   - [PropertyMapping](docs/PropertyMapping.md)
   - [QueryRequest](docs/QueryRequest.md)
   - [QuerySpecification](docs/QuerySpecification.md)
   - [ResourceId](docs/ResourceId.md)
   - [RowDetails](docs/RowDetails.md)
   - [Trigger](docs/Trigger.md)
   - [UpdateInstanceRequest](docs/UpdateInstanceRequest.md)
   - [VendorField](docs/VendorField.md)
   - [VendorProduct](docs/VendorProduct.md)


pkgId: 15f43b355921b5006e88e80d88f4249aa94f767a6ed8fc68311fbd475bfee9b2
name: python-finbourne-insights-sdk-help
arch: noarch
version: 2.1.51
epoch: 0
release: 1
summary: Development documents and examples for finbourne-insights-sdk
url: https://github.com/finbourne/insights-sdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-finbourne-insights-sdk-2.1.51-1.src.rpm
location_href: Packages/python-finbourne-insights-sdk-help-2.1.51-1.noarch.rpm
checksum_type: sha256
description:
  *AccessEvaluationsApi* | [**get_access_evaluation_log**](docs/AccessEvaluationsApi.md#get_access_evaluation_log) | **GET** /api/access/{id} | [EARLY ACCESS] GetAccessEvaluationLog: Get the log for a specific access evaluation.  This endpoint will be deprecated in the near future.
  *AccessEvaluationsApi* | [**list_access_evaluation_logs**](docs/AccessEvaluationsApi.md#list_access_evaluation_logs) | **GET** /api/access | [EARLY ACCESS] ListAccessEvaluationLogs: List the logs for access evaluations.
  *ApplicationMetadataApi* | [**list_access_controlled_resources**](docs/ApplicationMetadataApi.md#list_access_controlled_resources) | **GET** /api/metadata/access/resources | ListAccessControlledResources: Get resources available for access control
  *AuditingApi* | [**create_entry**](docs/AuditingApi.md#create_entry) | **POST** /api/auditing/entries | [EARLY ACCESS] CreateEntry: Create (persist) and audit entry..
  *AuditingApi* | [**get_processes**](docs/AuditingApi.md#get_processes) | **GET** /api/auditing/processes | [EARLY ACCESS] GetProcesses: Get the latest audit entry for each process.
  *AuditingApi* | [**list_entries**](docs/AuditingApi.md#list_entries) | **GET** /api/auditing/entries | [EARLY ACCESS] ListEntries: Get the audit entries.
  *RequestsApi* | [**get_request**](docs/RequestsApi.md#get_request) | **GET** /api/requests/{id}/request | GetRequest: Get the request content for a specific API request.
  *RequestsApi* | [**get_request_log**](docs/RequestsApi.md#get_request_log) | **GET** /api/requests/{id} | GetRequestLog: Get the log for a specific API request.
  *RequestsApi* | [**get_response**](docs/RequestsApi.md#get_response) | **GET** /api/requests/{id}/response | GetResponse: Get the response for a specific API request.
  *RequestsApi* | [**list_request_logs**](docs/RequestsApi.md#list_request_logs) | **GET** /api/requests | ListRequestLogs: Get the logs for API requests.
  *VendorLogsApi* | [**get_vendor_log**](docs/VendorLogsApi.md#get_vendor_log) | **GET** /api/vendor/{id} | [EXPERIMENTAL] GetVendorLog: Get the log for a specific vendor request.
  *VendorLogsApi* | [**get_vendor_request**](docs/VendorLogsApi.md#get_vendor_request) | **GET** /api/vendor/{id}/request | [EXPERIMENTAL] GetVendorRequest: Get the request body for a vendor request.
  *VendorLogsApi* | [**get_vendor_response**](docs/VendorLogsApi.md#get_vendor_response) | **GET** /api/vendor/{id}/response | [EXPERIMENTAL] GetVendorResponse: Get the response from a vendor request.
  *VendorLogsApi* | [**list_vendor_logs**](docs/VendorLogsApi.md#list_vendor_logs) | **GET** /api/vendor | [EXPERIMENTAL] ListVendorLogs: List the logs for vendor requests.
  <a id="documentation-for-models"></a>

   - [AccessControlledAction](docs/AccessControlledAction.md)
   - [AccessControlledResource](docs/AccessControlledResource.md)
   - [AccessEvaluationLog](docs/AccessEvaluationLog.md)
   - [ActionId](docs/ActionId.md)
   - [AuditData](docs/AuditData.md)
   - [AuditDataSummary](docs/AuditDataSummary.md)
   - [AuditEntry](docs/AuditEntry.md)
   - [AuditEntryNote](docs/AuditEntryNote.md)
   - [AuditProcess](docs/AuditProcess.md)
   - [AuditProcessSummary](docs/AuditProcessSummary.md)
   - [Bucket](docs/Bucket.md)
   - [CreateAuditEntry](docs/CreateAuditEntry.md)
   - [Histogram](docs/Histogram.md)
   - [IdSelectorDefinition](docs/IdSelectorDefinition.md)
   - [IdentifierPartSchema](docs/IdentifierPartSchema.md)
   - [Link](docs/Link.md)
   - [LusidProblemDetails](docs/LusidProblemDetails.md)
   - [LusidValidationProblemDetails](docs/LusidValidationProblemDetails.md)
   - [ProblemDetails](docs/ProblemDetails.md)
   - [Request](docs/Request.md)
   - [RequestLog](docs/RequestLog.md)
   - [Resource](docs/Resource.md)
   - [ResourceListOfAccessControlledResource](docs/ResourceListOfAccessControlledResource.md)
   - [ResourceListOfAuditProcessSummary](docs/ResourceListOfAuditProcessSummary.md)
   - [ResourceListWithHistogramOfAccessEvaluationLog](docs/ResourceListWithHistogramOfAccessEvaluationLog.md)
   - [ResourceListWithHistogramOfRequestLog](docs/ResourceListWithHistogramOfRequestLog.md)
   - [ResourceListWithHistogramOfVendorLog](docs/ResourceListWithHistogramOfVendorLog.md)
   - [Response](docs/Response.md)
   - [ScrollableCollectionOfAuditEntry](docs/ScrollableCollectionOfAuditEntry.md)
   - [VendorLog](docs/VendorLog.md)
   - [VendorRequest](docs/VendorRequest.md)
   - [VendorResponse](docs/VendorResponse.md)


pkgId: 866674d74d43ddacf78cf0117662e6dda590f1c7fb86abf07aaf8a3596412cbf
name: python-finch-tensor-help
arch: noarch
version: 0.2.3
epoch: 0
release: 1
summary: Development documents and examples for finch-tensor
url: https://pypi.org/project/finch-tensor/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-finch-tensor-0.2.3-1.src.rpm
location_href: Packages/python-finch-tensor-help-0.2.3-1.noarch.rpm
checksum_type: sha256
description:
  This is the beginnings of a sparse tensor library for Python, backed by the
  [Finch.jl](https://github.com/finch-tensor/Finch.jl) tensor compiler.



  The source code for `finch-tensor` is available on GitHub at [https://github.com/finch-tensor/finch-tensor-python](https://github.com/FinchTensor/finch-tensor-python)



  `finch-tensor` is available on PyPi, and can be installed with pip:
  ```bash
  pip install finch-tensor
  ```





  Finch uses [poetry](https://python-poetry.org/) for packaging.

  To install for development, clone the repository and run:
  ```bash
  poetry install --with test
  ```
  to install the current project and dev dependencies.



  The "Publish" GitHub Action is a manual workflow for publishing Python packages to PyPI using Poetry. It handles the version management based on the `pyproject.toml` file and automates tagging and creating GitHub releases.



  Before initiating the "Publish" action, update the package's version number in `pyproject.toml`. Follow semantic versioning guidelines for this update.



  The action is triggered manually. Once the version in `pyproject.toml` is updated, manually start the "Publish" action from the GitHub repository's Actions tab.



  On successful execution, the action publishes the package to PyPI and tags the release in the GitHub repository. If the version number is not updated, the action fails to publish to PyPI, and no tagging or release is done. In case of failure, correct the version number and rerun the action.



  - Ensure the version number in `pyproject.toml` is updated before triggering the action.
  - Regularly check action logs for successful completion or to identify issues.



  To add pre-commit hooks, run:
  ```bash
  poetry run pre-commit install
  ```



  Finch uses [pytest](https://docs.pytest.org/en/latest/) for testing. To run the
  tests:

  ```bash
  poetry run pytest
  ```


pkgId: 40fef173e929e38246f638b4842d4a21e913ebf40d559664b7789c6a1590417c
name: python-find-delay-help
arch: noarch
version: 2.13
epoch: 0
release: 1
summary: Development documents and examples for find-delay
url: https://github.com/RomainPastureau/find_delay
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-find-delay-2.13-1.src.rpm
location_href: Packages/python-find-delay-help-2.13-1.noarch.rpm
checksum_type: sha256
description:
  * Corrected a bug that led to wrong behaviour when the parameters `window_size_res` and `window_size_env` are equal to
    `None`.
  * Separated the private functions from find_delay.py to their own file, `private_functions.py`.
  * When saving a figure, the function `_create_figure` now creates the subdirectories from `path_figure` that do not
    exist instead of returning an error.
  * Added two new parameters for `find_delay` and `find_delays` allowing to name the arrays on the figure.
  * Added one new test.
  [See version history](https://find-delay.readthedocs.io/en/latest/version_history.html)
  If you detect any bug, please [open an issue](https://github.com/RomainPastureau/find_delay/issues/new).
  Thanks! 🦆
  <a href="https://www.buymeacoffee.com/romainpastureau" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-green.png" alt="Buy Me A Coffee" height="41" width="174"></a>


pkgId: b1ad9b9df6e9da2d6cac61989996919e9bf7b0e235b6e9b183a7a973e293f868
name: python-findiff-help
arch: noarch
version: 0.11.3
epoch: 0
release: 1
summary: Development documents and examples for findiff
url: https://github.com/maroba/findiff
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-findiff-0.11.3-1.src.rpm
location_href: Packages/python-findiff-help-0.11.3-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/findiff.svg)](https://img.shields.io/pypi/v/findiff.png?style=flat-square&color=brightgreen)
  ![build](https://github.com/maroba/findiff/actions/workflows/check.yml/badge.svg)
  ![Coverage](https://img.shields.io/codecov/c/github/maroba/findiff/master.svg)
  [![Doc Status](https://readthedocs.org/projects/findiff/badge/?version=latest)](https://findiff.readthedocs.io/en/latest/index.html)
  [![PyPI downloads](https://img.shields.io/pypi/dm/findiff.svg)]()
  [![Downloads](https://static.pepy.tech/personalized-badge/findiff?period=total&units=international_system&left_color=black&right_color=blue&left_text=Downloads)](https://pepy.tech/project/findiff)

  A Python package for finite difference numerical derivatives and partial differential equations in
  any number of dimensions.



  * Differentiate arrays of any number of dimensions along any axis with any desired accuracy order
  * Accurate treatment of grid boundary
  * Can handle arbitrary linear combinations of derivatives with constant and variable coefficients
  * Fully vectorized for speed
  * Matrix representations of arbitrary linear differential operators
  * Solve partial differential equations with Dirichlet or Neumann boundary conditions
  * Symbolic representation of finite difference schemes
  * **New in version 0.11**: More comfortable API (keeping the old API available)



  ```
  pip install --upgrade findiff
  ```



  You can find the documentation of the code including examples of application at https://findiff.readthedocs.io/en/stable/.



  *findiff* allows to easily define derivative operators that you can apply to *numpy* arrays of
  any dimension.

  Consider the simple 1D case of a equidistant grid
  with a first derivative $\displaystyle \frac{\partial}{\partial x}$ along the only axis (0):

  ```python
  import numpy as np
  from findiff import Diff


  x = np.linspace(0, 1, 100)


  f = np.sin(x)  # as an example


  d_dx = Diff(0, x[1] - x[0])


  df_dx = d_dx(f)
  ```

  Similarly, you can define partial derivatives along other axes, for example, if $z$ is the 2-axis, we can write
  $\frac{\partial}{\partial z}$ as:

  ```python
  Diff(2, dz)
  ```

  `Diff` always creates a first derivative. For higher derivatives, you simply exponentiate them, for example for $\frac{\partial^2}{\partial_x^2}$

  ```
  d2_dx2 = Diff(0, dx)**2
  ```

  and apply it as before.

  You can also define more general differential operators intuitively, like

  $$
  2x \frac{\partial^3}{\partial x^2 \partial z} + 3 \sin(y)z^2 \frac{\partial^3}{\partial x \partial y^2}
  $$


  which can be written as

  ```python

  diff_op = 2 * X * Diff(0)**2 * Diff(2) + 3 * sin(Y) * Z**2 * Diff(0) * Diff(1)**2


  diff_op.set_grid({0: dx, 1: dy, 2: dz})


  result = diff_op(f)
  ```

  where `X, Y, Z` are *numpy* arrays with meshed grid points. Here you see that you can also define your grid
  lazily.

  Of course, standard operators from vector calculus like gradient, divergence and curl are also available
  as shortcuts.

  More examples can be found [here](https://findiff.readthedocs.io/en/latest/source/examples.html) and in [this blog](https://medium.com/p/7e54132a73a3).



  When constructing an instance of `Diff`, you can request the desired accuracy
  order by setting the keyword argument `acc`. For example:

  ```python
  d_dx = Diff(0, dy, acc=4)
  df_dx = d2_dx2(f)
  ```

  Alternatively, you can also split operator definition and configuration:

  ```python
  d_dx = Diff(0, dx)
  d_dx.set_accuracy(2)
  df_dx = d2_dx2(f)
  ```

  which comes in handy if you have a complicated expression of differential operators, because then you
  can specify it on the whole expression and it will be passed down to all basic operators.

  If not specified, second order accuracy will be taken by default.



  Sometimes you may want to have the raw finite difference coefficients.
  These can be obtained for __any__ derivative and accuracy order
  using `findiff.coefficients(deriv, acc)`. For instance,

  ```python
  import findiff
  coefs = findiff.coefficients(deriv=3, acc=4, symbolic=True)
  ```

  gives

  ```
  {'backward': {'coefficients': [15/8, -13, 307/8, -62, 461/8, -29, 49/8],
                'offsets': [-6, -5, -4, -3, -2, -1, 0]},
   'center': {'coefficients': [1/8, -1, 13/8, 0, -13/8, 1, -1/8],
              'offsets': [-3, -2, -1, 0, 1, 2, 3]},
   'forward': {'coefficients': [-49/8, 29, -461/8, 62, -307/8, 13, -15/8],
               'offsets': [0, 1, 2, 3, 4, 5, 6]}}
  ```

  If you want to specify the detailed offsets instead of the
  accuracy order, you can do this by setting the offset keyword
  argument:

  ```python
  import findiff
  coefs = findiff.coefficients(deriv=2, offsets=[-2, 1, 0, 2, 3, 4, 7], symbolic=True)
  ```

  The resulting accuracy order is computed and part of the output:

  ```
  {'coefficients': [187/1620, -122/27, 9/7, 103/20, -13/5, 31/54, -19/2835],
   'offsets': [-2, 1, 0, 2, 3, 4, 7],
   'accuracy': 5}
  ```



  For a given differential operator, you can get the matrix representation
  using the `matrix(shape)` method, e.g. for a small 1D grid of 10 points:

  ```python
  d2_dx2 = Diff(0, dx)**2
  mat = d2_dx2.matrix((10,))  # this method returns a scipy sparse matrix
  print(mat.toarray())
  ```

  has the output

  ```
  [[ 2. -5.  4. -1.  0.  0.  0.]
   [ 1. -2.  1.  0.  0.  0.  0.]
   [ 0.  1. -2.  1.  0.  0.  0.]
   [ 0.  0.  1. -2.  1.  0.  0.]
   [ 0.  0.  0.  1. -2.  1.  0.]
   [ 0.  0.  0.  0.  1. -2.  1.]
   [ 0.  0.  0. -1.  4. -5.  2.]]
  ```



  *findiff* uses standard stencils (patterns of grid points) to evaluate the derivative.
  However, you can design your own stencil. A picture says more than a thousand words, so
  look at the following example for a standard second order accurate stencil for the
  2D Laplacian $\displaystyle \frac{\partial^2}{\partial x^2} + \frac{\partial^2}{\partial y^2}$:

  <img src="docs/frontpage/laplace2d.png" width="400">

  This can be reproduced by *findiff* writing

  ```python
  offsets = [(0, 0), (1, 0), (-1, 0), (0, 1), (0, -1)]
  stencil = Stencil(offsets, partials={(2, 0): 1, (0, 2): 1}, spacings=(1, 1))
  ```

  The attribute `stencil.values` contains the coefficients

  ```
  {(0, 0): -4.0, (1, 0): 1.0, (-1, 0): 1.0, (0, 1): 1.0, (0, -1): 1.0}
  ```

  Now for a some more exotic stencil. Consider this one:

  <img src="docs/frontpage/laplace2d-x.png" width="400">

  With *findiff* you can get it easily:

  ```python
  offsets = [(0, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
  stencil = Stencil(offsets, partials={(2, 0): 1, (0, 2): 1}, spacings=(1, 1))
  stencil.values
  ```

  which returns

  ```
  {(0, 0): -2.0, (1, 1): 0.5, (-1, -1): 0.5, (1, -1): 0.5, (-1, 1): 0.5}
  ```



  As of version 0.10, findiff can also provide a symbolic representation of finite difference schemes suitable for using in conjunction with sympy. The main use case is to facilitate deriving your own iteration schemes.

  ```python
  from findiff import SymbolicMesh, SymbolicDiff

  mesh = SymbolicMesh("x, y")
  u = mesh.create_symbol("u")
  d2_dx2, d2_dy2 = [SymbolicDiff(mesh, axis=k, degree=2) for k in range(2)]

  (
      d2_dx2(u, at=(m, n), offsets=(-1, 0, 1)) +
      d2_dy2(u, at=(m, n), offsets=(-1, 0, 1))
  )
  ```

  Outputs:

  $$
  \frac{u_{m,n + 1} + u_{m,n - 1} - 2 u_{m,n}}{\Delta y^2}  + \frac{u_{m + 1,n} + u_{m - 1,n} - 2 u_{m,n}}{\Delta x^2}
  $$

  Also see the [example notebook](examples/symbolic.ipynb).



  _findiff_ can be used to easily formulate and solve partial differential equation problems

  $$
  \mathcal{L}u(\vec{x}) = f(\vec{x})
  $$

  where $\mathcal{L}$ is a general linear differential operator.

  In order to obtain a unique solution,  Dirichlet, Neumann or more general boundary conditions
  can be applied.





  Find the solution of

  $$
  \left( \frac{d^2}{dt^2} - \alpha \frac{d}{dt} + \omega^2 \right)u(t) = \sin{(2t)}
  $$

  subject to the (Dirichlet) boundary conditions

  $$
  u(0) = 0, \hspace{1em} u(10) = 1
  $$

  ```python
  from findiff import Diff, Id, PDE

  shape = (300, )
  t = numpy.linspace(0, 10, shape[0])
  dt = t[1]-t[0]

  L = Diff(0, dt)**2 - Diff(0, dt) + 5 * Id()
  f = numpy.cos(2*t)

  bc = BoundaryConditions(shape)
  bc[0] = 0
  bc[-1] = 1

  pde = PDE(L, f, bc)
  u = pde.solve()
  ```

  Result:

  <p align="center">
  <img src="docs/frontpage/ho_bvp.jpg" alt="ResultHOBVP" height="300"/>
  </p>



  A plate with temperature profile given on one edge and zero heat flux across the other
  edges, i.e.

  $$
  \left( \frac{\partial^2}{\partial x^2} + \frac{\partial^2}{\partial y^2} \right) u(x,y) = f(x,y)
  $$

  with Dirichlet boundary condition

  $$
  \begin{align*}
  u(x,0) &= 300 \\
  u(1,y) &= 300 - 200y
  \end{align*}
  $$

  and Neumann boundary conditions

  $$
  \begin{align*}
  \frac{\partial u}{\partial x} &= 0, & \text{ for } x = 0 \\
  \frac{\partial u}{\partial y} &= 0, & \text{ for } y = 0
  \end{align*}
  $$

  ```python
  shape = (100, 100)
  x, y = np.linspace(0, 1, shape[0]), np.linspace(0, 1, shape[1])
  dx, dy = x[1]-x[0], y[1]-y[0]
  X, Y = np.meshgrid(x, y, indexing='ij')

  L = FinDiff(0, dx, 2) + FinDiff(1, dy, 2)
  f = np.zeros(shape)

  bc = BoundaryConditions(shape)
  bc[1,:] = FinDiff(0, dx, 1), 0  # Neumann BC
  bc[-1,:] = 300. - 200*Y   # Dirichlet BC
  bc[:, 0] = 300.   # Dirichlet BC
  bc[1:-1, -1] = FinDiff(1, dy, 1), 0  # Neumann BC

  pde = PDE(L, f, bc)
  u = pde.solve()
  ```

  Result:

  <p align="center">
  <img src="docs/frontpage/heat.png"/>
  </p>



  You have used *findiff* in a publication? Here is how you can cite it:

  > M. Baer. *findiff* software package. URL: https://github.com/maroba/findiff. 2018

  BibTeX entry:

  ```
  @misc{findiff,
    title = {{findiff} Software Package},
    author = {M. Baer},
    url = {https://github.com/maroba/findiff},
    key = {findiff},
    note = {\url{https://github.com/maroba/findiff}},
    year = {2018}
  }
  ```





  - Fork the repository
  - Clone your fork to your machine
  - Install in development mode:

  ```
  pip install -e .
  ```



  From the console:

  ```
  pip install pytest
  pytest tests
  ```


pkgId: 5c0307fc0f816988227a0afeffec3afb74a0205fe005707452fe25fc8c8ecd57
name: python-findprob-help
arch: noarch
version: 0.2
epoch: 0
release: 1
summary: Development documents and examples for findprob
url: https://phrdang.github.io/findprob/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-findprob-0.2-1.src.rpm
location_href: Packages/python-findprob-help-0.2-1.noarch.rpm
checksum_type: sha256
description:
  A CLI to classify and search for problems using LLMs



  1. Install the package: `pip install findprob`
  2. (Optional) Install autocompletion: `findprob --install-completion`
  3. Create an [OpenAI](https://platform.openai.com/signup) account and generate a new API key.
  4. Create a [LangChain](https://smith.langchain.com/) account and generate a new API key and project.
  5. Export the environment variables in your terminal:
  ```sh
  LANGCHAIN_TRACING_V2=true
  LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"
  LANGCHAIN_API_KEY=<YOUR API KEY HERE>
  LANGCHAIN_PROJECT=<YOUR PROJECT NAME HERE>

  OPENAI_API_KEY=<YOUR API KEY HERE>
  ```



  See the [official docs](https://phrdang.github.io/findprob/) or run `findprob --help` for more information.



  A research project for CS 194-271 at UC Berkeley (Fall 2024) created by:

  - Rebecca Dang (rdang [at] berkeley [dot] edu)
  - Jessica Lin (linjessica [at] berkeley [dot] edu)
  - Samantha Huang (samanthahuang [at] berkeley [dot] edu)

  Advised by:

  - Professor Gireeja Ranade (ranade [at] eecs [dot] berkeley [dot] edu)
  - Professor Narges Norouzi (norouzi [at] berkeley [dot] edu)


pkgId: bfbd4e96004d29a9f80e2e52336aca23f19dfbda6571e84a86b85f2ea9c751aa
name: python-fink-utils-help
arch: noarch
version: 0.29.16
epoch: 0
release: 1
summary: Development documents and examples for fink-utils
url: https://github.com/astrolabsoftware/fink-utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: vm-2p8g.taishan200-2280-2s48p-256g--a62-1.compass-ci.net
rpm_sourcerpm: python-fink-utils-0.29.16-1.src.rpm
location_href: Packages/python-fink-utils-help-0.29.16-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/fink-utils.svg)](https://pypi.python.org/pypi/fink-utils)
  [![PEP8](https://github.com/astrolabsoftware/fink-utils/workflows/PEP8/badge.svg)](https://github.com/astrolabsoftware/fink-utils/actions?query=workflow%3APEP8)



  Collection of useful functionalities used across the Fink ecosystem:

  - [photometry](fink_utils/photometry): conversion routines between units
  - [data](fink_utils/data): data manipulation with Python
  - [spark](fink_utils/spark): data manipulation with Spark
  - [xmatch](fink_utils/xmatch): utilities for manipulating external databases and catalogs
  - [sso](fink_utils/sso): utilities for manipulating Solar System objects (HG, HG12, HG1G2, SHG1G2)
  - [HBase](fink_utils/hbase): utilities for manipulating data stored in HBase


pkgId: baa5b5b4da66cd19f9ab62b55ae6e075621c075255c8d5684352ab8ad424371d
name: python-firebolt-sdk-help
arch: noarch
version: 1.7.0
epoch: 0
release: 1
summary: Development documents and examples for firebolt-sdk
url: https://github.com/firebolt-db/firebolt-sdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-firebolt-sdk-1.7.0-1.src.rpm
location_href: Packages/python-firebolt-sdk-help-1.7.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Nightly code check](https://github.com/firebolt-db/firebolt-python-sdk/actions/workflows/nightly.yml/badge.svg)](https://github.com/firebolt-db/firebolt-python-sdk/actions/workflows/nightly.yml)
  [![Unit tests](https://github.com/firebolt-db/firebolt-python-sdk/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/firebolt-db/firebolt-python-sdk/actions/workflows/unit-tests.yml)
  [![Code quality checks](https://github.com/firebolt-db/firebolt-python-sdk/actions/workflows/code-check.yml/badge.svg)](https://github.com/firebolt-db/firebolt-python-sdk/actions/workflows/code-check.yml)
  [![Firebolt Security Scan](https://github.com/firebolt-db/firebolt-python-sdk/actions/workflows/security-scan.yml/badge.svg)](https://github.com/firebolt-db/firebolt-python-sdk/actions/workflows/security-scan.yml)
  [![Integration tests](https://github.com/firebolt-db/firebolt-python-sdk/actions/workflows/integration-tests.yml/badge.svg)](https://github.com/firebolt-db/firebolt-python-sdk/actions/workflows/integration-tests.yml)
  ![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/ptiurin/65d5a42849fd78f4c6e62fad18490d20/raw/firebolt-sdk-coverage.json)




  * Requires Python `>=3.8`
  * `pip install "firebolt-sdk>=1.0.0a1"`



  For reference and tutorials, see the [Firebolt Python SDK reference](https://old.docs.firebolt.io/firebolt-python-sdk/sdk_documenation/latest/).


  These parameters are used to connect to a Firebolt database:
  - **account_name** - name of firebolt account
  - **client_id** - credentials client id
  - **cliend_secret** - credentials client secret
  - **database [Optional]** - name of the database to connect to
  - **engine_name [Optional]** - name of the engine to connect to


  See [PEP-249](https://www.python.org/dev/peps/pep-0249) for the DB API reference and specifications. An example [jupyter notebook](https://github.com/firebolt-db/firebolt-sdk/tree/main/examples/dbapi.ipynb) is included to illustrate the use of the Firebolt API.



  Cursor is not thread-safe and should not be shared across threads. In a multi-threaded environment you can share a Connection, but each thread would need to keep its own Cursor. This corresponds to a thread safety 2 in the [DBApi specification](https://peps.python.org/pep-0249/#threadsafety).



  ```Python
  cursor.execute("SET parameter=value")
  ```
  This will error out if you try to set `account_id`, `output_format`, `database`, `engine`. These are special keywords that should not be set directly. To switch between databases and engines use `USE DATABASE/ENGINE`.



  By default, firebolt-sdk uses `datetime` module to parse date and datetime values, which might be slow for a large amount of operations. In order to speed up datetime operations, it's possible to use [ciso8601](https://pypi.org/project/ciso8601/) package. In order to install firebolt-sdk with `ciso8601` support, run `pip install "firebolt-sdk[ciso8601]"`



  See: [CONTRIBUTING.MD](https://github.com/firebolt-db/firebolt-sdk/tree/main/CONTRIBUTING.MD)


  The Firebolt DB API is licensed under the [Apache License Version 2.0](https://github.com/firebolt-db/firebolt-sdk/tree/main/LICENSE) software license.


pkgId: f631d21c2cf53e74a6d83e5669001416a9f67583d4c3611fc45ba7a7ab6a6693
name: python-firecrawl-help
arch: noarch
version: 1.6.8
epoch: 0
release: 1
summary: Development documents and examples for firecrawl
url: https://github.com/mendableai/firecrawl
rpm_license: GNU Affero General Public License v3 (AGPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-firecrawl-1.6.8-1.src.rpm
location_href: Packages/python-firecrawl-help-1.6.8-1.noarch.rpm
checksum_type: sha256
description:
  The Firecrawl Python SDK is a library that allows you to easily scrape and crawl websites, and output the data in a format ready for use with language models (LLMs). It provides a simple and intuitive interface for interacting with the Firecrawl API.



  To install the Firecrawl Python SDK, you can use pip:

  ```bash
  pip install firecrawl-py
  ```



  1. Get an API key from [firecrawl.dev](https://firecrawl.dev)
  2. Set the API key as an environment variable named `FIRECRAWL_API_KEY` or pass it as a parameter to the `FirecrawlApp` class.

  Here's an example of how to use the SDK:

  ```python
  from firecrawl.firecrawl import FirecrawlApp

  app = FirecrawlApp(api_key="fc-YOUR_API_KEY")


  scrape_status = app.scrape_url(
    'https://firecrawl.dev',
    params={'formats': ['markdown', 'html']}
  )
  print(scrape_status)


  crawl_status = app.crawl_url(
    'https://firecrawl.dev',
    params={
      'limit': 100,
      'scrapeOptions': {'formats': ['markdown', 'html']}
    },
    poll_interval=30
  )
  print(crawl_status)
  ```



  To scrape a single URL, use the `scrape_url` method. It takes the URL as a parameter and returns the scraped data as a dictionary.

  ```python
  url = 'https://example.com'
  scraped_data = app.scrape_url(url)
  ```



  With LLM extraction, you can easily extract structured data from any URL. We support pydantic schemas to make it easier for you too. Here is how you to use it:

  ```python
  class ArticleSchema(BaseModel):
      title: str
      points: int
      by: str
      commentsURL: str

  class TopArticlesSchema(BaseModel):
      top: List[ArticleSchema] = Field(..., max_items=5, description="Top 5 stories")

  data = app.scrape_url('https://news.ycombinator.com', {
      'extractorOptions': {
          'extractionSchema': TopArticlesSchema.model_json_schema(),
          'mode': 'llm-extraction'
      },
      'pageOptions':{
          'onlyMainContent': True
      }
  })
  print(data["llm_extraction"])
  ```



  To crawl a website, use the `crawl_url` method. It takes the starting URL and optional parameters as arguments. The `params` argument allows you to specify additional options for the crawl job, such as the maximum number of pages to crawl, allowed domains, and the output format.

  ```python
  idempotency_key = str(uuid.uuid4()) # optional idempotency key
  crawl_result = app.crawl_url('firecrawl.dev', {'excludePaths': ['blog/*']}, 2, idempotency_key)
  print(crawl_result)
  ```



  To crawl a website asynchronously, use the `async_crawl_url` method. It takes the starting URL and optional parameters as arguments. The `params` argument allows you to specify additional options for the crawl job, such as the maximum number of pages to crawl, allowed domains, and the output format.

  ```python
  crawl_result = app.async_crawl_url('firecrawl.dev', {'excludePaths': ['blog/*']}, "")
  print(crawl_result)
  ```



  To check the status of a crawl job, use the `check_crawl_status` method. It takes the job ID as a parameter and returns the current status of the crawl job.

  ```python
  id = crawl_result['id']
  status = app.check_crawl_status(id)
  ```



  Use `map_url` to generate a list of URLs from a website. The `params` argument let you customize the mapping process, including options to exclude subdomains or to utilize the sitemap.

  ```python

  map_result = app.map_url('https://example.com')
  print(map_result)
  ```



  To crawl a website with WebSockets, use the `crawl_url_and_watch` method. It takes the starting URL and optional parameters as arguments. The `params` argument allows you to specify additional options for the crawl job, such as the maximum number of pages to crawl, allowed domains, and the output format.

  ```python

  nest_asyncio.apply()


  def on_document(detail):
      print("DOC", detail)

  def on_error(detail):
      print("ERR", detail['error'])

  def on_done(detail):
      print("DONE", detail['status'])

      
  async def start_crawl_and_watch():
      
      watcher = app.crawl_url_and_watch('firecrawl.dev', { 'excludePaths': ['blog/*'], 'limit': 5 })

      
      watcher.add_event_listener("document", on_document)
      watcher.add_event_listener("error", on_error)
      watcher.add_event_listener("done", on_done)

      
      await watcher.connect()


  await start_crawl_and_watch()
  ```



  To batch scrape multiple URLs, use the `batch_scrape_urls` method. It takes the URLs and optional parameters as arguments. The `params` argument allows you to specify additional options for the scraper such as the output formats.

  ```python
  idempotency_key = str(uuid.uuid4()) # optional idempotency key
  batch_scrape_result = app.batch_scrape_urls(['firecrawl.dev', 'mendable.ai'], {'formats': ['markdown', 'html']}, 2, idempotency_key)
  print(batch_scrape_result)
  ```



  To run a batch scrape asynchronously, use the `async_batch_scrape_urls` method. It takes the starting URL and optional parameters as arguments. The `params` argument allows you to specify additional options for the scraper, such as the output formats.

  ```python
  batch_scrape_result = app.async_batch_scrape_urls(['firecrawl.dev', 'mendable.ai'], {'formats': ['markdown', 'html']})
  print(batch_scrape_result)
  ```



  To check the status of an asynchronous batch scrape job, use the `check_batch_scrape_status` method. It takes the job ID as a parameter and returns the current status of the batch scrape job.

  ```python
  id = batch_scrape_result['id']
  status = app.check_batch_scrape_status(id)
  ```



  To use batch scrape with WebSockets, use the `batch_scrape_urls_and_watch` method. It takes the starting URL and optional parameters as arguments. The `params` argument allows you to specify additional options for the scraper, such as the output formats.

  ```python

  nest_asyncio.apply()


  def on_document(detail):
      print("DOC", detail)

  def on_error(detail):
      print("ERR", detail['error'])

  def on_done(detail):
      print("DONE", detail['status'])


  async def start_crawl_and_watch():
      
      watcher = app.batch_scrape_urls_and_watch(['firecrawl.dev', 'mendable.ai'], {'formats': ['markdown', 'html']})

      
      watcher.add_event_listener("document", on_document)
      watcher.add_event_listener("error", on_error)
      watcher.add_event_listener("done", on_done)

      
      await watcher.connect()


  await start_crawl_and_watch()
  ```



  The SDK handles errors returned by the Firecrawl API and raises appropriate exceptions. If an error occurs during a request, an exception will be raised with a descriptive error message.



  To ensure the functionality of the Firecrawl Python SDK, we have included end-to-end tests using `pytest`. These tests cover various aspects of the SDK, including URL scraping, web searching, and website crawling.



  To run the tests, execute the following commands:

  Install pytest:

  ```bash
  pip install pytest
  ```

  Run:

  ```bash
  pytest firecrawl/__tests__/e2e_withAuth/test.py
  ```



  Contributions to the Firecrawl Python SDK are welcome! If you find any issues or have suggestions for improvements, please open an issue or submit a pull request on the GitHub repository.



  The Firecrawl Python SDK is licensed under the MIT License. This means you are free to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the SDK, 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.

  Please note that while this SDK is MIT licensed, it is part of a larger project which may be under different licensing terms. Always refer to the license information in the root directory of the main project for overall licensing details.


pkgId: 1d00b0cd461bc7375abd9298fe9561869f3dc16cdaa3de35d6be1d165d523d37
name: python-fireflies-assistant-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for fireflies-assistant
url: https://github.com/trilogy-group/pocs/tree/main/fireflies-assistant
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fireflies-assistant-0.1.3-1.src.rpm
location_href: Packages/python-fireflies-assistant-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  A command-line interface for Fireflies.ai to manage meeting transcripts and participants.



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



  First, set your Fireflies.ai API key:
  ```bash
  ff key YOUR_API_KEY
  ```



  - Join a meeting (120 minutes duration):
    ```bash
    ff join
    ```

  - List recent meetings:
    ```bash
    ff list
    ff list --limit 20  # Show more meetings
    ```

  - Get transcript ID for a meeting URL:
    ```bash
    ff id "https://meet.google.com/abc-def-ghi"
    ```

  - Get meeting participants:
    ```bash
    ff participants TRANSCRIPT_ID
    
    ff participants "https://meet.google.com/abc-def-ghi"
    ```

  - Get meeting transcript:
    ```bash
    ff transcript TRANSCRIPT_ID
    
    ff transcript "https://meet.google.com/abc-def-ghi"
    ```



  - API key is stored in `.env` file
  - Meeting URL to transcript ID mappings are stored in `~/.fireflies_meetings.json`



  This project uses:
  - Click for CLI interface
  - python-dotenv for environment management
  - requests for API communication


pkgId: c1db53356ef59f0cd96fb97bd415b0b5ad95e688b66b6793974716f97051eaaa
name: python-fireflies-cli-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for fireflies-cli
url: https://github.com/trilogy-group/pocs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fireflies-cli-0.1.0-1.src.rpm
location_href: Packages/python-fireflies-cli-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Command line interface for Fireflies.ai. This package provides a convenient way to interact with Fireflies.ai from the command line.



  ```bash
  pip install fireflies-cli
  ```



  ```bash

  ff config set-key YOUR_API_KEY


  ff join --url https://meet.google.com/xxx-yyyy-zzz


  ff video TRANSCRIPT_ID


  ff video -d TRANSCRIPT_ID


  ff list


  ff delete TRANSCRIPT_ID
  ```



  - Join meetings with optional duration and name
  - Get video URLs for transcripts
  - Download meeting recordings
  - List transcripts
  - Delete transcripts



  This CLI tool uses the `fireflies-sdk` package. If you need programmatic access to Fireflies.ai, consider using the SDK directly.


pkgId: c81a4381864153d75b92e466fec5fc2e41df358d305d59006463314605cab605
name: python-fireflies-sdk-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for fireflies-sdk
url: https://github.com/trilogy-group/pocs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fireflies-sdk-0.1.0-1.src.rpm
location_href: Packages/python-fireflies-sdk-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Python SDK for interacting with the Fireflies.ai API. This package provides a simple interface for accessing Fireflies.ai functionality programmatically.



  ```bash
  pip install fireflies-sdk
  ```



  ```python
  from fireflies_sdk import FirefliesAPI


  api = FirefliesAPI("your-api-key")


  result = api.join_meeting(url="https://meet.google.com/xxx-yyyy-zzz")


  video_info = api.get_video_url("transcript-id")
  print(video_info["title"])
  print(video_info["video_url"])
  ```



  - Join meetings
  - Get video URLs
  - Download meeting recordings
  - List transcripts
  - Delete transcripts



  This SDK is designed to be Lambda-friendly. Here's an example Lambda function:

  ```python
  from fireflies_sdk import FirefliesAPI
  import os

  def lambda_handler(event, context):
      api = FirefliesAPI(os.environ["FIREFLIES_API_KEY"])

      transcript_id = event.get("transcript_id")
      try:
          result = api.get_video_url(transcript_id)
          return {
              "statusCode": 200,
              "body": result
          }
      except Exception as e:
          return {
              "statusCode": 500,
              "body": str(e)
          }
  ```


pkgId: 67d4956d07051a8042b5216d25b6dd85efe46d262002d6e868739c37ca785c75
name: python-firefly-client-help
arch: noarch
version: 3.2.0
epoch: 0
release: 1
summary: Development documents and examples for firefly-client
url: https://github.com/Caltech-IPAC/firefly_client
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-firefly-client-3.2.0-1.src.rpm
location_href: Packages/python-firefly-client-help-3.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Python API for Firefly, IPAC's Advanced Astronomy Web UI Framework



  The client must be connected to a Firefly server. The Firefly
  repository is located at http://github.com/Caltech-IPAC/firefly.
  Standalone Firefly servers may be obtained from
  [this Dockerhub repository](https://hub.docker.com/r/ipac/firefly/).

  For detailed explanation on the usage, see [the online documentation](https://caltech-ipac.github.io/firefly_client). Following is a very simple example:

  ```
  from firefly_client import FireflyClient
  fc = FireflyClient.make_client()  # can also explictly pass url of a firefly server; default is http://localhost:8080/firefly
  ```

  A FITS image may be uploaded and displayed:

  ```
  fval = fc.upload_file('image.fits')
  fc.show_fits(fval, 'myimage')
  ```

  For more examples, check notebooks & python files in the [examples](examples/) and [test](test/) directories.

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


pkgId: d3f9727615ff1d9d0508542341dfbbd466ec136a56c0dc2a1bb78ee07484d529
name: python-firestarter-help
arch: noarch
version: 1.3.13
epoch: 0
release: 1
summary: Development documents and examples for firestarter
url: https://pypi.org/project/firestarter/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-firestarter-1.3.13-1.src.rpm
location_href: Packages/python-firestarter-help-1.3.13-1.noarch.rpm
checksum_type: sha256
description:
    A15 -|  1     28 |- VCC
    A12 -|  2     27 |- A14
    A7  -|  3     26 |- A13
    A6  -|  4     25 |- A8
    A5  -|  5     24 |- A9
    A4  -|  6     23 |- A11
    A3  -|  7     22 |- OE/Vpp
    A2  -|  8     21 |- A10
    A1  -|  9     20 |- CE
    A0  -| 10     19 |- D7
    D0  -| 11     18 |- D6
    D1  -| 12     17 |- D5
    D2  -| 13     16 |- D4


pkgId: 4e264c9a76e2f993d5487b45982b4886863ced91a3add809b1aecbc4ebf1fa49
name: python-firestoned-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for firestoned
url: https://github.com/firestoned/firestone
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-firestoned-0.7.0-1.src.rpm
location_href: Packages/python-firestoned-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Last PR Build 🐍](https://github.com/firestoned/firestone/actions/workflows/pr.yml/badge.svg)](https://github.com/firestoned/firestone/actions/workflows/pr.yml)
  <!-- Pytest Coverage Comment:Begin -->
  <a href="https://github.com/bradpenney/firestone/blob/main/README.md"><img alt="Coverage" src="https://img.shields.io/badge/Coverage-43%25-orange.svg" /></a>
  <!-- Pytest Coverage Comment:End -->





  `firestone` allows you to build OpenAPI, AsyncAPI and gRPC specs based off one or more resource JSON schema files. This allows you to focus on what really matters, the resource you are developing!

  Once you have generated the appropriate specification file for your project, you can then use the myriad of libraries and frameworks to generate stub code.

  **The primary premise of this project is not to introduce any new "language" to describe your resources(s), rather, use JSON Schema!**

  This makes it easy to come up to speed with little to no prior knowledge to get going.

  Having said that, the schema for a resource provides additional helpful functionality, see the [schema](#schema) section for further details.



  You can use `pip` or `poetry` to install and run `firestone`. We suggest using `pip` if you wish to install `firestone` globally, or for virtual environments, use `poetry`.



  It's a simple as running the following `pip` command:

  ```zsh
  sudo pip install firestoned
  ```

  > Yes, `firestone**d**`, not `firestone`! This is because there already is a, albeit emtpy, repository on [pypi.org](https://pypi.org/) with the same name ...



  [Poetry](https://python-poetry.org/) is a great build tool for Python that allows you to build and run all locally in a virtual environment. This is great for checking out the tool and playing around with `firestone` itself.

  If you're starting with a new project, declare `firestoned` in your dependencies during the `poetry install` process:

  ```zsh
  poetry install
  poetry build
  ```

  If you're adding `firestone` to a `poetry` project:

  ```zsh
  poetry add firestoned
  poetry build
  ```



  Now that you have a copy of `firestone`, let's try running it with the example resource provided, an addressbook!

  > If running within `poetry` build, simply prepend commands with `poetry run`.

  > For the remainder of this documentation, we will assume you have installed `firestone`.



  ```zsh
  firestone \
      generate \
      --title 'Addressbook resource' \
      --description 'A simple addressBook example' \
      --resources examples/addressBook/resource.yaml \
      openapi
      --security '{"name": "bearer_auth", "scheme": "bearer", "type": "http", "bearerFormat": "JWT"}' \
  ```

  Let's quickly dissect this command:

  - We are telling firestone to generate an `openapi` spec, given the `title`, `description`, and the two given resource files.
  - By default, this will output the specification file to `stdout`, alternatively, you can provide the `-O` option to output to a specific file.

  You can also add the command line `--ui-server` to the end, which will launch a small webserver and run the Swagger UI to view this specification file.

  ```zsh
  firestone --debug generate --title 'Example person and addressBook API' \
      --description 'An example API with more than one resource' \
      --resources examples/addressBook.yaml,examples/person.yaml \
      openapi \
      --security '{"name": "bearer_auth", "scheme": "bearer", "type": "http", "bearerFormat": "JWT"}' \
      --ui-server

  * Serving Quart app 'firestone.__main__'
  * Environment: production
  * Please use an ASGI server (e.g. Hypercorn) directly in production
  * Debug mode: False
  * Running on http://127.0.0.1:5000 (CTRL + C to quit)
  [2022-10-31 02:47:17 -0500] [87590] [INFO] Running on http://127.0.0.1:5000 (CTRL + C to quit)

  ```

  Now you can use your browser to navigate to `http://127.0.0.1:5000/apidocs` to view the Swagger UI.



  It all begins with your resource definition! This is done using JSON schema and we have provided an example in our `examples` directory, called addressBook. We will use this to describe how the schema is setup and how you can adapt to your own.

  Here is the full file:

  ```yaml

  name: addressbook
  description: An example of an addressbook resource
  version: 1.0
  version_in_path: false
  default_query_params:
    - name: limit
      description: Limit the number of responses back
      in: query
      schema:
        type: integer
    - name: offset
      description: The offset to start returning resources
      in: query
      schema:
        type: integer
  asyncapi:
    servers:
      dev:
        url: ws://localhost
        protocol: ws
        description: The development websocket server
    channels:
      resources: true
      instances: true
      instance_attrs: true

  methods:
    resource:
      - get
      - post
    instance:
      - delete
      - get
      - head
      - put
    instance_attrs:
      - delete
      - get
      - head
      - put
  descriptions:
    resource:
      get: List all addresses in this addressbook.
      head: Determine the existence and size of addresses in this addressbook.
      patch: Patch one or more addresses in this addressbook.
      post: Create a new address in this addressbook, a new address key will be created.
      delete: Delete all addresses from this addressbook.
    instance:
      get: Get a specific address from this addressbook.
      head: Determine the existence and size of this address.
      patch: Patch this address in the addressbook.
      put: Update an existing address in this addressbook, with the given address key.
      delete: Delete an address from this addressbook.

  schema:
    type: array
    key:
      name: address_key
      description: A unique identifier for an addressbook entry.
      schema:
        type: string
    
    
    
    query_params:
      - name: city
        description: Filter by city name
        required: false
        schema:
          type: string
        methods:
          - get
    items:
      type: object
      properties:
        
        person:
          description: This is a person object that lives at this address.
          schema:
            $ref: "person.yaml#/schema"
        addrtype:
          description: The address type, e.g. work or home
          type: string
          
          
          enum:
            - work
            - home
        street:
          description: The street and civic number of this address
          type: string
        city:
          description: The city of this address
          type: string
        state:
          description: The state of this address
          type: string
        country:
          description: The country of this address
          type: string
        people:
          description: A list of people's names living there
          type: array
          items:
            type: string
      required:
        - addrtype
        - street
        - city
        - state
        - country
  ```





  Name is used in various places, including as the root to API URLs, for example in OpenAPI, `/addressBook`



  The description of this resource is used in the generated specification files.



  The version of this resource definition, this can alternatively be used in the URL as well, see below `version_in_path`.



  This attribute defines whether to prepend the version defined above in the URL paths.  For example, for the
  above, you would get: `/v1.0/addressBook`.



  You can provide a list of default query parameters that will be added to all HTTP methods,
  or optionally you can provide a list of the HTTP methods, for which `firestone` will add.



  This is a map/dict of `resource`, and/or `instance`, and/or `instance_attrs` (the instance attributes to expose), and a list of methods to explicitly expose.



  This is a map/dict of either `resource` and/or `instance`, which itself is a map or methods to descriptions.



  Now, to generate your OpenAPI client, you will need the `openapi-generator` command ([installation instructions](https://openapi-generator.tech/docs/installation) to generate client code in many languages.

  > Please check out the [OpenAPI Project](https://openapi-generator.tech/) for more details.

  This client code can then be used as an SDK or used by our CLI generation, for example:

  ```zsh
  openapi-generator generate \
      -i examples/addressbook/openapi.yaml \
      -g python-nextgen \
      -o /tmp/addressbook-client \
      --skip-validate-spec \
      -c examples/addressbook/openapi-gen-config.json
  ```



  Now that you have generated the client code, you can also generate a CRUD, Python Click-based CLI around your code. This generator creates a standalone script or as a module to be used in your console scripts, as part of your project build.

  > Please checkout the [Click Project](https://click.palletsprojects.com) for more details.

  Here is an example command we use to generate the example Addressbook.

  ```
  firestone generate \
      --title 'Addressbook CLI' \
      --description 'This is the CLI for the example Addressbook' \
      --resources examples/addressbook/addressbook.yaml,examples/addressbook/person.yaml \
      --version 1.0 \
       cli \
       --pkg addressbook \
       --client-pkg addressbook.client > examples/addressbook/main.py
  ```



  `firestone` and the larger [**Firestone Project**](https://github.com/firestoned) are open-source projects and we welcome contributions.  Please follow standard GitHub practices, including forking the project, creating a branch, and submitting a PR.


pkgId: c798a2631862f4d11d0087f8d35052f6757d4b579483ac6d4d979f86335a80f1
name: python-firewheel-repo-ntp-help
arch: noarch
version: 2.7.0
epoch: 0
release: 1
summary: Development documents and examples for firewheel-repo-ntp
url: https://www.sandia.gov/emulytics
rpm_license: Apache License (2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-firewheel-repo-ntp-2.7.0-1.src.rpm
location_href: Packages/python-firewheel-repo-ntp-help-2.7.0-1.noarch.rpm
checksum_type: sha256
description:
  Due to licensing limitations, we are currently unable to provide the expected binary files (VM Resources nor Images) that are used within these model components.
  For the VM Resources, we have provided an `INSTALL <https://sandialabs.github.io/firewheel/tutorials/install_file.html>`__ script to reproducibly recreate them, when possible.


pkgId: 6103aca8b5cb11a3491e889a741656233bacca04b3703500eeeb0eb7a75132ba
name: python-firewheel-repo-vyos-help
arch: noarch
version: 2.7.0
epoch: 0
release: 1
summary: Development documents and examples for firewheel-repo-vyos
url: https://www.sandia.gov/emulytics
rpm_license: Apache License (2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-firewheel-repo-vyos-2.7.0-1.src.rpm
location_href: Packages/python-firewheel-repo-vyos-help-2.7.0-1.noarch.rpm
checksum_type: sha256
description:
  Due to licensing limitations, we are currently unable to provide the expected binary files (VM Resources nor Images) that are used within these model components.
  For the VM Resources, we have provided an `INSTALL <https://sandialabs.github.io/firewheel/tutorials/install_file.html>`__ script to reproducibly recreate them, when possible.
  However, for images, users will need to follow the `Image Creation Tutorial <https://sandialabs.github.io/firewheel/tutorials/image.html>`__ to create compatible images.
  The following images are referenced within this repository:


pkgId: 7ef5a1c64c6550d45224641ab493f3f958ada8bb14849e158d29abffedbc5fa7
name: python-fishpi-pyclient-help
arch: noarch
version: 2.1.7
epoch: 0
release: 1
summary: Development documents and examples for fishpi-pyclient
url: https://github.com/gakkiyomi/fishpi-pyclient
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fishpi-pyclient-2.1.7-1.src.rpm
location_href: Packages/python-fishpi-pyclient-help-2.1.7-1.noarch.rpm
checksum_type: sha256
description:
  ![摸鱼派cn.png](https://b3logfile.com/file/2023/05/摸鱼派-cn-owZQT8f.png)



  > 摸鱼派聊天室 python 命令行客户端

  基于摸鱼打工人社区——摸鱼派开放 API 开发的摸鱼派聊天室 python 客户端程序，可以在里面边写 Bug 边愉快地吹水摸鱼。



  [版本列表](https://github.com/gakkiyomi/fishpi-pyclient/releases)



  下载后，双击打开



  下载后，执行如下命令

  1. ```bash
     chmod a+x ./fishpi-pyclient
     ```

  2. ```bash
     ./fishpi-pyclient
     ```

  然后需要在偏好设置这里,如下图:
  ![WechatIMG482.jpg](https://file.fishpi.cn/2023/12/WechatIMG482-3c599a0e.jpg)



  环境: Python3.9 以上

  执行

  ```bash
  pip install fishpi-pyclient
  ```

  ```bash
  fishpi-pyclient -u username -p password -c <两步验证码>
  ```



  ```bash
  python core.py
  ```



  - 🥷 账号多开
    - 一键切换
    - 更多功能请期待
  - 💬 聊天模式
    - 💬 私聊
    - 💬 聊天吹水
    - 🌈 自定义字体颜色
    - 🤖️ 自动复读
    - 🤖️ 自动领取昨日奖励
    - 🌛 发送清风明月
    - 聊天室消息撤回
    - 小尾巴去除
    - 小冰天气解析
    - 🧠 自言自语
      - 自定义语句池
      - 定时发送
  - 📑 查看帖子
    - 发送评论
  - 命令模式
    - 命令/聊天模式切换
      - (聊天模式也可以执行命令)
    - 进入答题模式(前缀自动加上 鸽)
    - ⬆️ 社区快捷命令
      - 领取昨日活跃度奖励
      - 查看个人积分
      - 查看签到状态
      - 转账
      - 发送清风明月
      - 查看当前活跃度
      - 查看在线用户列表
      - 查询用户详细信息
      - 配置文件导出
      - 🈲️ 小黑屋功能
        - 拒绝接收黑名单在聊天室发送的信息 (红包除外 😂 )
        - 将某人从小黑屋中放出
      - 🈲️ 关键字屏蔽
      - 发红包 🧧
        - 拼手气红包
        - 普通红包
        - 专属红包
        - 心跳红包
        - 猜拳红包
        - 设置抢红包等待时间
        - 抢猜拳红包最大限制
        - 🧧 自动化抢红包（脚本哥）
          - 自定义抢红包延时
          - 心跳红包防止踩坑
          - 心跳红包风险预测



  ![fenshen.png](https://file.fishpi.cn/2023/12/账号分身-0a25be81.png)
  ![截屏2023-12-10-13.42.17.png](https://file.fishpi.cn/2023/12/截屏20231210134217-df6839af.png)
  ![image.png](https://file.fishpi.cn/2023/06/image-d4da9bf7.png)
  ![redpacket](https://file.fishpi.cn/2023/06/image-d0ad7756.png)
  ![image.png](https://pwl.stackoverflow.wiki/2022/01/image-f74aae7e.png)
  ![image.png](https://pwl.stackoverflow.wiki/2022/01/image-1b685256.png)



  `pwl-chat-ptyhon` had been being developed with `PyCharm IDE` under the free JetBrains Open Source license(s) granted by JetBrains s.r.o., hence I would like to express my thanks here.

  <a href="https://www.jetbrains.com/?from=pwl-chat-ptyhon" target="_blank"><img src="https://b3logfile.com/file/2021/05/jetbrains-variant-2-42d96aa4.png" width="250" align="middle"/></a>


pkgId: 1d7a72b96b33ad990457f85c20b8f12a0dcab407ff3e2ba6fa8e308afcd1b6d4
name: python-fittrackee-help
arch: noarch
version: 0.8.12
epoch: 0
release: 1
summary: Development documents and examples for fittrackee
url: https://github.com/SamR1/FitTrackee
rpm_license: AGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fittrackee-0.8.12-1.src.rpm
location_href: Packages/python-fittrackee-help-0.8.12-1.noarch.rpm
checksum_type: sha256
description:
  Web application allowing tracking of outdoor activities (workouts) from GPX files, \
  with data on your own server.
  Also works with other mobile apps to store workouts data locally, for export into a GPX file.
  Examples for Android (non-exhaustive list):
  * [Runner Up](https://github.com/jonasoreland/runnerup) (GPLv3)
  * [OpenTracks](https://github.com/OpenTracksApp/OpenTracks) (Apache License)
  * [FitoTrack](https://codeberg.org/jannis/FitoTrack) (GPLv3)
  It is also possible to add a workout without a GPX file.
  Map data from [OpenStreetMap](https://www.openstreetmap.org).

  - [List of features](https://samr1.github.io/FitTrackee/en/features.html)
  - [Installation instructions](https://samr1.github.io/FitTrackee/en/installation.html)
  - [Changelog](https://samr1.github.io/FitTrackee/en/changelog.html)
  **Under heavy development (some features may be unstable).**
  (see [issues](https://github.com/SamR1/FitTrackee/issues) and [documentation](https://samr1.github.io/FitTrackee) for more info.)
  ![FitTrackee Dashboard Screenshot](https://samr1.github.io/FitTrackee/en/_images/fittrackee_screenshot-01.png)

  FitTrackee uses [Weblate](https://hosted.weblate.org/engage/fittrackee/) for translation management.
  [![Translation status](https://hosted.weblate.org/widget/fittrackee/multi-auto.svg)](https://hosted.weblate.org/engage/fittrackee/)


pkgId: 8e5b16a4813b9f68ba8575d2ccea4794642a5bbc3bdcf9ed6d9e0ddbfe489d8b
name: python-fivetran-connector-sdk-help
arch: noarch
version: 0.12.17.1
epoch: 0
release: 1
summary: Development documents and examples for fivetran-connector-sdk
url: https://fivetran.com/docs/connectors/connector-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fivetran-connector-sdk-0.12.17.1-1.src.rpm
location_href: Packages/python-fivetran-connector-sdk-help-0.12.17.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/fivetran-connector-sdk)](https://pepy.tech/project/fivetran-connector-sdk)

  The *fivetran-connector-sdk* allows users to execute custom, self-written Python code within [Fivetran's](https://www.fivetran.com/) secure cloud environment. Fivetran automatically manages running the connectors on your scheduled frequency and manages the required compute resources.

  The Connector SDK service is the best fit for the following use cases:
  - Fivetran doesn't have a connector for your source and is unlikely to support it soon.
  - You are using private APIs, custom applications, unsupported file formats, or those that require pre-processing.
  - You have sensitive data that needs filtering or anonymizing before entering the destination.
  - You don't want to introduce a 3rd party into your pipeline (e.g., to host a custom function).

  To learn more, see our [Connector SDK documentation](https://fivetran.com/docs/connectors/connector-sdk)



      pip install fivetran-connector-sdk


  - Python ≥3.9 and ≤3.12
  - Operating System:
      - Windows 10 or later
      - MacOS 13 (Ventura) or later


  See [Quickstart guide](https://fivetran.com/docs/connectors/connector-sdk/quickstart-guide) to get started.


  Import required classes from fivetran_connector_sdk to begin writing your custom data connector

  ```python
    from fivetran_connector_sdk import Connector
    from fivetran_connector_sdk import Logging as log
    from fivetran_connector_sdk import Operations as op
  ```
  See our [Technical Reference](https://fivetran.com/docs/connectors/connector-sdk/technical-reference#update) and [Best Practices](https://fivetran.com/docs/connectors/connector-sdk/best-practices) documentation for more details.

  You can also refer to our [existing examples](https://github.com/fivetran/fivetran_connector_sdk) to better understand Fivetran's Connector SDK and start creating custom data connectors.


  This package is actively maintained by Fivetran Developers. Please reach out to our [Support team](https://support.fivetran.com/hc/en-us) for any inquiries.


pkgId: cf14588f6362a7b4ef73d1deee7f5d90450f85aab14d59f4edae3a7ee2ad6fb6
name: python-fivitech-mt5-connector-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for fivitech-mt5-connector
url: https://github.com/fivitech/mt5-connector
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fivitech-mt5-connector-0.1.3-1.src.rpm
location_href: Packages/python-fivitech-mt5-connector-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for connecting to and managing MetaTrader5 servers.



  ```bash
  pip install fivitech-mt5-connector
  ```



  For detailed documentation, see [DOCUMENTATION.md](DOCUMENTATION.md)



  For changelog, see [CHANGELOG.md](CHANGELOG.md)



  ```python
  from fivitech_mt5_connector import MT5Pool


  servers = [
      {
          "id": 1,
          "type": "demo",
          "name": "Demo Server",
          "username": "manager",
          "manager_password": "your_manager_password",
          "api_password": "your_api_password",
          "ips": ["127.0.0.1", "localhost"]
      }
  ]


  pool = MT5Pool(servers)


  connection_status = pool.connect_all()


  pool.connect_server(1)


  pool.add_server({
      "id": 2,
      "type": "live",
      "name": "Live Server",
      "username": "manager",
      "manager_password": "your_manager_password",
      "api_password": "your_api_password",
      "ips": ["server1.domain.com", "server2.domain.com"]
  })


  pool.connect_server(2)


  pool.update_server(2, {
      "name": "Updated Live Server",
      "ips": ["new.server.com"]
  })


  pool.disconnect_server(2)


  pool.remove_server(2)


  def my_deal_callback(deal, server_info):
      print(f"New deal on {server_info.name}: {deal.Deal}")

  pool.add_deal_callback('deal_add', my_deal_callback)


  demo_server = pool.get_server(1)
  live_server = pool.get_server(101)


  pool.disconnect_all()
  ```



  - Dynamic server management (add/remove/update servers)
  - Individual server connection control
  - Multiple server connections management
  - Account operations
  - Transaction handling
  - User management
  - Deal monitoring
  - Default and custom callbacks for deals and user events



  Each server in the configuration requires:
  - `id`: Unique integer identifier
  - `type`: Either 'demo' or 'live'
  - `name`: Server name
  - `username`: Manager username/login
  - `manager_password`: Manager password for server operations
  - `api_password`: API password for MT5 WebAPI access
  - `ips`: List of IP addresses for failover




  ```python
  pool.add_server({
      "id": 1,
      "type": "demo",
      "name": "Demo Server",
      "username": "manager",
      "manager_password": "password",
      "api_password": "api_password",
      "ips": ["127.0.0.1"]
  })
  ```


  ```python
  pool.update_server(1, {
      "name": "Updated Name",
      "ips": ["new.ip.address"]
  })
  ```


  ```python
  pool.remove_server(1)
  ```


  ```python

  pool.connect_server(1)


  pool.disconnect_server(1)


  pool.connect_all()


  pool.disconnect_all()
  ```



  - Python 3.7+
  - MT5Manager>=5.0.3906
  - pandas>=1.0.0
  - numpy>=1.19.0
  - pytz>=2021.1
  - requests>=2.26.0
  - python-dateutil>=2.8.2



  Proprietary - All rights reserved


pkgId: e6c0d97dad5e5d7e788a0b4c625ec0936c3ec0cc6c9e60d4c96da4b1a1270355
name: python-fjaraskupan-help
arch: noarch
version: 2.3.1
epoch: 0
release: 1
summary: Development documents and examples for fjaraskupan
url: https://github.com/elupus/fjaraskupan
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fjaraskupan-2.3.1-1.src.rpm
location_href: Packages/python-fjaraskupan-help-2.3.1-1.noarch.rpm
checksum_type: sha256
description:
  Code to set fan speed using library.
      async def run():
          async with Device("AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE") as device:
              await device.set_fan_speed(5)
      loop = asyncio.get_event_loop()
      loop.run_until_complete (run())


pkgId: 63ca6277e5995e326cf9db4239322e1906b6d904415712244d9c8d455ef7b806
name: python-flama-help
arch: noarch
version: 1.9.4
epoch: 0
release: 1
summary: Development documents and examples for flama
url: https://flama.dev
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-flama-1.9.4-1.src.rpm
location_href: Packages/python-flama-help-1.9.4-1.noarch.rpm
checksum_type: sha256
description:
  Flama is a python library which establishes a standard framework for
  development and deployment of APIs with special focus on machine learning (ML).
  The main aim of the framework is to make ridiculously simple the deployment of
  ML APIs, simplifying (when possible) the entire process to a single line of
  code.
  The library builds on Starlette, and provides an easy-to-learn
  philosophy to speed up the building of highly performant GraphQL, REST and ML APIs.
  Besides, it comprises an ideal solution for the development of asynchronous
  and production-ready services, offering automatic deployment for ML models.
  Some remarkable characteristics:
  * Generic classes for API resources with the convenience of standard CRUD methods over SQLAlchemy tables.
  * A schema system (based on Marshmallow or Typesystem) which allows the declaration of inputs and outputs of endpoints
    very easily, with the convenience of reliable and automatic data-type validation.
  * Dependency injection to make ease the process of managing parameters needed in endpoints via the use of `Component`s.
    Flama ASGI objects like `Request`, `Response`, `Session` and so on are defined as `Component`s ready to be injected in
    your endpoints.
  * `Component`s as the base of the plugin ecosystem, allowing you to create custom or use those already defined in your
    endpoints, injected as parameters.
  * Auto generated API schema using OpenAPI standard.
  * Auto generated `docs`, and provides a Swagger UI and ReDoc endpoints.
  * Automatic handling of pagination, with several methods at your disposal such as `limit-offset` and `page numbering`,
    to name a few.

  Flama is fully compatible with all [supported versions](https://devguide.python.org/versions/) of Python. We recommend
  you to use the latest version available.
  For a detailed explanation on how to install flama
  visit:  [https://flama.dev/docs/getting-started/installation](https://flama.dev/docs/getting-started/installation).

  Visit [https://flama.dev/docs/getting-started/quickstart](https://flama.dev/docs/getting-started/quickstart) to get
  started with Flama.

  Visit [https://flama.dev/docs/](https://flama.dev/docs/) to view the full documentation.

  ```python
  from flama import Flama
  app = Flama(
      title="Hello-🔥",
      version="1.0",
      description="My first API",
  )
  @app.route("/")
  def home():
      """
      tags:
          - Salute
      summary:
          Returns a warming message
      description:
          This is a more detailed description of the method itself.
          Here we can give all the details required and they will appear
          automatically in the auto-generated docs.
      responses:
          200:
              description: Warming hello message!
      """
      return {"message": "Hello 🔥"}
  ```
  This example will build and run a `Hello 🔥` API. To run it:
  ```commandline
  flama run examples.hello_flama:app
  ```

  * José Antonio Perdiguero López ([@perdy](https://github.com/perdy/))
  * Miguel Durán-Olivencia ([@migduroli](https://github.com/migduroli/))

  This project is absolutely open to contributions so if you have a nice idea, please read
  our [contributing docs](.github/CONTRIBUTING.md) **before submitting** a pull
  request.

  <a href="https://github.com/vortico/flama">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=vortico/flama&type=Date&theme=dark" />
      <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=vortico/flama&type=Date" />
      <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=vortico/flama&type=Date" />
    </picture>
  </a>


pkgId: 94ddae1fa5c0f87fb6bfaa21d8d9028a3640ed93ae4678681c90fc023d868003
name: python-flamo-help
arch: noarch
version: 0.0.17
epoch: 0
release: 1
summary: Development documents and examples for flamo
url: https://github.com/gdalsanto/flamo
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-flamo-0.0.17-1.src.rpm
location_href: Packages/python-flamo-help-0.0.17-1.noarch.rpm
checksum_type: sha256
description:
  Available differentiable audio signal processors - in `flamo.processor.dsp`:
  - **Gains** : Gains, Matrices, Householder Matrices
  - **Filters** : Biquads, State Variable Filters (SVF), Graphic Equalizers (GEQ), Parametric Equiliers (PEQ - not released yet)
  - **Delays** : Integer Delays, Fractional Delays
  Transforms  - in `flamo.processor.dsp`:
  - **Transform** : FFT, iFFT, time anti-aliasing enabled FFT and iFFT
  Utilities, system designers, and optimization - in `flamo.processor.system`:
  - **Series** : Serial chaining of differentiable systems
  - **Recursion** : Closed loop with assignable feedforward and feedback paths
  - **Shell**: Container class for safe interaction between system, dataset, and loss functions
  Optimization - in `flamo.optimize`:
  - **Trianer** : Handling of the training and validation steps

rpm_license:
  MIT License  Copyright (c) 2024 Gloria Dal Santo, Gian Marco De Bortoli, Sebastian Jiro Schlecht  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: a8e62713ac7907cc91b50c03fcb021f6b4f8cb0c5e4f5b64b5e1e306cbb74734
name: python-flashvideo-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for flashvideo
url: https://pypi.org/project/flashvideo/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-flashvideo-0.1.0-1.src.rpm
location_href: Packages/python-flashvideo-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src=assets/logo.jpg width="30%"/>
  </div>

  FastVideo is an open-source framework for accelerating large video diffusion model.
  <div align="center">
  <table style="margin-left: auto; margin-right: auto; border: none;">
    <tr>
      <td>
        <img src="assets/8steps/mochi-demo.gif" width="640" alt="Mochi Demo">
      </td>
    </tr>
    <tr>
      <td style="text-align:center;">
        Get 8X diffusion boost for Mochi with FastVideo
      </td>
    </tr>
  </table>
    </div>

  <p align="center">
      🤗 <a href="https://huggingface.co/FastVideo/FastMochi-diffuser" target="_blank">FastMochi</a> | 🤗 <a href="https://huggingface.co/FastVideo/FastHunyuan"  target="_blank">FastHunyuan</a>
  </p>

  FastVideo currently offers: (with more to come)

  - FastHunyuan and FastMochi: consistency distilled video diffusion models for 8x inference speedup.
  - First open video DiT distillation recipes based on [PCM](https://github.com/G-U-N/Phased-Consistency-Model).
  - Scalable training with FSDP, sequence parallelism, and selective activation checkpointing, with near linear scaling to 64 GPUs.
  - Memory efficient finetuning with LoRA, precomputed latents, and precomputed text embeddings.




  - ```2024/12/17```: `FastVideo` v0.1 is released.



  The code is tested on Python 3.10.0, CUDA 12.1 and H100.
  ```
  ./env_setup.sh fastvideo
  ```


  We recommend using a GPU with 80GB of memory. To run the inference, use the following command:

  ```bash

  python scripts/huggingface/download_hf.py --repo_id=FastVideo/FastHunyuan --local_dir=data/FastHunyuan --repo_type=model

  sh scripts/inference/inference_hunyuan.sh
  ```
  You can also inference FastHunyuan in the [official Hunyuan github](https://github.com/Tencent/HunyuanVideo).


  ```bash

  python scripts/huggingface/download_hf.py --repo_id=FastVideo/FastMochi-diffusers --local_dir=data/FastMochi-diffusers --repo_type=model

  bash scripts/inference/inference_mochi_sp.sh
  ```


  Please refer to the [distillation guide](docs/distillation.md).


  Please refer to the [finetuning guide](docs/finetuning.md).





  We learned and reused code from the following projects: [PCM](https://github.com/G-U-N/Phased-Consistency-Model), [diffusers](https://github.com/huggingface/diffusers), and [OpenSoraPlan](https://github.com/PKU-YuanGroup/Open-Sora-Plan).


pkgId: d9368f87a7c7b62b53827bd54ba06c80cc65d26e9d437816f761d5c6f0a3709c
name: python-flask-assets-pipeline-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for flask-assets-pipeline
url: https://github.com/hyperflask/flask-assets-pipeline
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-flask-assets-pipeline-0.4.0-1.src.rpm
location_href: Packages/python-flask-assets-pipeline-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Modern assets pipeline for Flask.

   - Asset bundling using [esbuild](https://esbuild.github.io/).
   - Live reloading
   - Support for [tailwind](https://tailwindcss.com/)
   - Compatible with #nobuild leveraging [import maps](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script/type/importmap)
   - Extract inline scripts and styles from templates and bundle them properly
   - CDN support



  Using pip:

      pip install flask-assets-pipeline

  You will need to install esbuild:

      npm install esbuild





  Initialize the AssetsPipeline extension and list your JS and CSS that need bundling, located in the app's static directory:

  ```python
  from flask import Flask
  from flask_assets_pipeline import AssetsPipeline

  app = Flask(__name__)
  assets = AssetsPipeline(app, bundles=['app.js'])
  ```

  > [!INFO]
  > Related stylesheets will be automatically included when their corresponding js is included.

  In your template, use the `asset_tags` directive to render the needed tags to include your assets.

  ```jinja
  <head>
      {% asset_tags %}
  </head>
  ```



  While in development, use the `flask assets dev` command to launch esbuild (and optionnaly tailwind). This will watch your files and expose a live reloading endpoint.
  Source maps are automatically enabled in development mode.



  Bundles are the files that will be used as inputs in the esbuild command.
  Filenames are relative to the assets folder unless it's an absolute path. Bundles can also contain URLs that will be ignored during the build process but that will be used in includes.

  Bundles can either be a list of files or a dict of named bundles:

  ```python
  assets = AssetsPipeline(app, bundles={
      "@default": ['base.js'],
      "@home": ['home.js', 'home.css']
  }, include=["@default"])

  @app.route("/")
  def home():
      assets.include("@home")
      return render_template("home.html")
  ```

  When using named bundles, its files are not concatanated together. It is simply a way to reference multiple files at once.
  Files from all named bundles will be provided as input in the esbuild command.

  > [!NOTE]
  > Named bundles do not need to start their name with @ but it's a good convention to follow.

  [Code splitting](https://esbuild.github.io/api/#splitting) is enabled by default.

  The `bundle()` and `blueprint_bundle()` methods allow you to register bundles with more options.



  By default, all bundled assets are included in your pages. You can change this behavior and manually select what asset to include on a given page.

  ```python
  assets = AssetsPipeline(app, bundles=[
      'base.js',
      'home.js'
  ], include=["base.js"])

  @app.route("/")
  def home():
      assets.include("home.js")
      return render_template("home.html")
  ```

  The `include_asset()` function is also available in templates. It does not return anything, only includes assets for `{% asset_tags %}` to take into account.

  In the include list, you can also add paths for any files in the static folder and urls.

  ```python
  assets = AssetsPipeline(app, bundles={
      'base.js',
      'home.js'
  }, include=[
      "base.js",
      "https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap"
  ])
  ```

  > [!WARNING]
  > By default, included assets that are not bundles won't be included as modules (`<script type="module">`). Change that by prefixing them with "import ".
  >
  > ```python
  > assets = AssetsPipeline(app, bundles={
  >     "base.js"
  > }, include=[
  >     "base.js",
  >     "import other.js"
  > ])
  > ```



  For assets other than scripts and stylesheets, use `asset_url(filename)` in your templates to get the url.

  ```jinja
  <img src="{{ asset_url('cat.jpg') }}">
  ```



  Use the following command to build assets for production:

      $ flask assets build

  This will:

   - build your bundles using esbuild
   - build your css with tailwind if enabled
   - minify files and not produce source maps
   - generate a mapping file (default: assets.json)

  Files built using esbuild and tailwind will be generated in a dist folder in the static directory.

  > [!IMPORTANT]
  > Make sure to ship all generated files and the mapping file to production

  > [!TIP]
  > It is not recommended to build in production. You should build in a separate environment (eg: CI),
  > then generate a tarball (or any other deliverable, eg: docker image) that you ship to production.



  Flask-Assets-Pipeline can launch tailwind in the background at the same time as esbuild and build your css file.
  The output css file will be automatically included.

  ```python
  assets = AssetsPipeline(app, bundles=[
      'base.js'
  ], tailwind='main.css')
  ```

  If the tailwind config or the input file is missing, they will be automatically generated.
  Make sure your tailwind config includes all the needed content paths to watch for.

  Example config:

  ```js
  /** @type {import('tailwindcss').Config} */
  module.exports = {
    content: [
      "./templates/**/*.html",
      "./static/**/*.js"
    ],
    theme: {
      extend: {},
    },
    plugins: [],
  }
  ```



  You can use a separate assets folder than your app static folder. This folder won't be exposed in production so raw assets are safe.

  When using a separate assets folder:

   - Always use `asset_url()` for your assets' urls
   - In development, the assets folder will be exposed and assets served directly from it
   - For production, you must call the build command
   - During the build, assets will be copied to the static folder with a hash in their filename (for cache busting)

  ```python
  assets = AssetsPipeline(app, bundles=['app.js'], assets_folder='assets')
  ```



  Flask-Assets-Pipeline allows to define scripts and styles directly in your templates. Their content will be extracted and bundled using the previously mentionned process.

  To enable inline assets, set the inline option to true.

  ```python
  assets = AssetsPipeline(app, ..., inline=True)
  ```

  Add the `bundle` attribute to your script and style tags to extract and bundle them.

  Example *datatable.html* template:

  ```jinja
  <table class="datatable">
      <!-- ... -->
  </table>

  <script bundle>
  document.addEventListener("DOMContentLoaded", () => {
      document.querySelectorAll(".datatable").forEach(table => {
          // ...
      });
  });
  </script>

  <style bundle>
  .datatable {
      /* ... */
  }
  </style>
  ```

  When this template is used as part of your request, its associated assets will be automatically included.

  > [!IMPORTANT]
  > No jinja directives can be used inside the bundled script and style tags

  > [!NOTE]
  > Extracted assets will be stored in your assets folder.
  > You can customize the name of the extracted files using a value for the bundle attribute: `<script bundle="filename.js">`



  If your are building a Single Page App (SPA), you will use a frontend router. To make sure these routes exist on the backend,
  you can register them:

  ```python
  assets.add_route("login", "/login")
  assets.add_route("account", "/account", decorators=[login_required]) # apply decorators

  assets.add_catch_all_route() # catch all unknown paths
  ```

  These routes simply return a rendered template defined using `ASSETS_ROUTE_TEMPLATE` (default is *frontend_route.html*)



  If you're not planning to use any feature that require preprocessing (eg. typescript) or are using an externel build system, you can skip defining bundles.

  ```python
  assets = AssetsPipeline(app, include=['app.js', 'app.css'])
  ```

  > [!WARNING]
  > Script mentionned in include are not included as module by default. If you wish to do so, prefix them with "import ":
  >
  > ```
  > assets = AssetsPipeline(app, include=['import app.js', 'app.css'])
  > ```

  > [!WARNING]
  > If you are using a separate assets folder, you will still need to build for production as assets need to
  > be copied to the static folder

  When using no build, it may be needed to edit the [import map](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script/type/importmap):

  ```python
  assets = AssetsPipeline(app, ..., import_map={"mypkg": "https://..."})
  assets.map_import("myotherpkg", "https://...")
  ```

  The import map will be rendered as part of `{% asset_tags %}`.

  You may want to expose some package from your node_modules directory to import them in your scripts.
  Exposed packages will be bundled using esbuild and added to the import map.

  ```python
  assets = AssetsPipeline(app, ..., expose_node_packages=["mypkg"])
  assets.expose_node_package("myotherpkg")
  ```

  You can then import them as usual in your scripts.



  You can include assets and urls for [preloading](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel/preload) and/or [prefetching](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel/prefetch).

  Similarly to how "import" can be specified, use "preload" in front of your included asset. The preload content type will be determined based on the file extension. You can specify it manually using `preload as TYPE URL`.

  For prefetching, use "prefetch" as the prefix.

  ```python
  assets = AssetsPipeline(app, include=["preload dependency.js", "preload as image cat.jpg", "prefetch page.js"])
  ```



  Any URLs can be used in the include list.

  It is possible to provide additionnal metadata like crossorigin and integrity hash.

  ```python
  assets = AssetsPipeline(app, include=["http://example.com/external.js#integrity=sha384-XXXX"])
  ```

  Any parameter in the fragment part will be transformed to attributes of the html element used to include the asset.

  By default, `crossorigin="anonymous"` is automatically applied to any url used.



  Set the cdn host in your configuration to use a CDN when debug mode is not enabled.

  ```python
  assets = AssetsPipeline(app, ..., cdn_host="https://xxx.cloudfront.net")
  ```

  You can control when the cdn is used or not using the ASSETS_CDN_ENABLED config option (it will override the default behavior).



  A [service worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers) to cache assets files locally can be automatically generated. It will include all bundled assets. This is particularly useful for [PWAs](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps).

  ```python
  assets = AssetsPipeline(app, ..., cache_worker=True)
  ```

  The worker will be automatically registered on page load when using `{% asset_tags %}`.



  To customize esbuild, you can use a custom script. When the script is ran, it will be provided environment variables that can help with configuration.

  ```python
  assets = AssetsPipeline(app, ..., esbuild_script="esbuild.mjs")
  ```

  Use the command `flask assets generate-esbuild-script` to generate a base script that shows you the env vars available.



  | Config key | Extension argument | Description | Default |
  | --- | --- | --- | --- |
  | ASSETS_BUNDLES | bundles | List of assets to build | |
  | ASSETS_INCLUDE | include | List of assets to include in your page | All assets in bundles |
  | ASSETS_ROUTE_TEMPLATE | route_template | The template to use for frontend routes | frontend_route.html |
  | ASSETS_INLINE | inline | Whether to extract assets from templates | False |
  | ASSETS_INCLUDE_INLINE_ON_DEMAND | include_inline_on_demand | Whether to only include inline assets when the template is used | False |
  | ASSETS_INLINE_TEMPLATE_EXTS | inline_template_exts | File extensions to process when looking for templates | .html .jinja |
  | ASSETS_IMPORT_MAP | import_map | ES Modules import map | {} |
  | ASSETS_EXPOSE_NODE_PACKAGES | expose_node_packages | Node packages to expose to the frontend via the import map | [] |
  | ASSETS_FOLDER | assets_folder | Search path for asset files | The app static_folder |
  | ASSETS_URL_PATH | assets_url_path | Base URL for the assets endpoint when in debug mode | /static/assets |
  | ASSETS_STAMP | stamp_assets | Whether to stamp filenames with the file's hash when copying files from the assets folder to the static folder | True |
  | ASSETS_OUTPUT_FOLDER | output_folder | The output folder for bundled files relative to the static folder | dist |
  | ASSETS_OUTPUT_URL | output_url | Base url for outputted file | /static/dist |
  | ASSETS_MAPPING_FILE | mapping_file | Location of the mapping file to resolve assets filename to their built equivalent | assets.json |
  | ASSETS_ESBUILD_SCRIPT | esbuild_script | Use a custom script calling esbuild insteaf of esbuild's cli | |
  | ASSETS_ESBUILD_ARGS | esbuild_args | Additional esbuild arguments | [] |
  | ASSETS_ESBUILD_BIN | esbuild_bin | esbuild binary location | npx esbuild |
  | ASSETS_ESBUILD_SPLITTING | esbuild_splitting | Use the --splitting option | True |
  | ASSETS_ESBUILD_TARGET | esbuild_target | Set the target option for esbuild (use a list) | [] |
  | ASSETS_ESBUILD_ALIASES | esbuild_aliases | Esbuild aliases | {} |
  | ASSETS_ESBUILD_EXTERNAL | esbuild_external | Esbuild external imports | [] |
  | ASSETS_LIVERELOAD_PORT | livereload_port | Port onto which to start the livereloading server | 8000 |
  | ASSETS_TAILWIND | tailwind | Tailwind input css file | |
  | ASSETS_TAILWIND_ARGS | tailwind_args | Additional tailwind arguments | [] |
  | ASSETS_TAILWIND_BIN | tailwind_bin | tailwindcss binary location | npx tailwindcss |
  | ASSETS_TAILWIND_SUGGESTED_CONTENT | tailwind_suggested_content | Additional paths that Tailwind should process | [] |
  | ASSETS_NODE_MODULES_PATH | node_modules_path | Path to the node_modules directory | node_modules |
  | ASSETS_COPY_FILES_FROM_NODE_MODULES | copy_files_from_node_modules | Mapping of src/dest files to copy from node modules | {} |
  | ASSETS_CDN_HOST | cdn_host | CDN hostname |  |
  | ASSETS_CDN_ENABLED | cdn_enabled | Whether to use the cdn | True in prod if cdn_host is set |
  | ASSETS_CACHE_WORKER | cache_worker | Whether to generate and register a cache service worker (useful for PWAs) | False |
  | ASSETS_CACHE_WORKER_NAME | cache_worker_name | Name of the cache | Random |
  | ASSETS_CACHE_WORKER_URLS | cache_worker_urls | Additional urls to cache | [] |
  | ASSETS_CACHE_WORKER_FILENAME | cache_worker_filename | Filename of the service worker | cache-worker.js |
  | ASSETS_CACHE_WORKER_REGISTER | cache_worker_register | Whether to register the service worker | True if cache_worker is true |



  | Command | Description |
  | --- | --- |
  | assets dev | Start the build process in development |
  | assets build | Build your assets for production |
  | assets extract | Extract assets from templates |
  | assets init-tailwind | Create the tailwind config |
  | assets generate-esbuild-script | Generate a script to run esbuild allowing you to customize the build |
  | assets esbuild-script | Run the esbuild script |


pkgId: de0c5039086d9d75b5ae96907e630e8ae22d4968e2267fda23ba3eadb94c336e
name: python-flask-lac-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for flask-lac
url: https://github.com/botsarefuture/flask_lac
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-flask-lac-0.1.0-1.src.rpm
location_href: Packages/python-flask-lac-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A simple authentication package for Flask applications.



  To install the package, use pip:

  ```sh
  pip install git+https://github.com/botsarefuture/flask_lac
  ```





  First, initialize the `AuthPackage` with your Flask app:

  ```python
  from flask import Flask
  from flask_lac import AuthPackage

  app = Flask(__name__)
  auth = AuthPackage(app, auth_service_url="https://auth.luova.club", app_id="your_app_id")
  ```

  > [!IMPORTANT] To get your `app_id`, register as a user on the authentication service and create a new application.



  The package provides several routes for authentication:

  - `/login`: Redirects to the external authentication service.
  - `/auth_callback`: Handles the authentication callback.
  - `/secured_route`: A secured route that requires user authentication.



  Here is an example of how to use the package in your Flask application:

  ```python
  from flask import Flask, render_template
  from flask_lac import AuthPackage, login_required

  app = Flask(__name__)
  auth = AuthPackage(app, auth_service_url="https://auth.luova.club", app_id="your_app_id")

  @app.route('/')
  def index():
      return "Welcome to the Flask LAC example!"

  @app.route('/secured')
  @login_required
  def secured():
      return render_template('secured.html', username=auth._user._info.username)

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



  The `User` class handles user authentication and information retrieval:

  ```python
  from flask_lac.user import User

  user = User()
  if user.is_authenticated():
      print("User is authenticated")
  else:
      print("User is not authenticated")
  ```



  This project is licensed under the MIT License.


