# packages

pkgId: 360f309cc03f93fd4f12509ea6aff2545c3f82a6232c41cc7a83adb14e405350
name: python-arcor2-arserver-data
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: ARCOR2 ARServer data
url: https://pypi.org/project/arcor2-arserver-data/
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcor2-arserver-data-1.1.0-1.src.rpm
checksum_type: sha256
description:
  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),





  - Updated dependencies, switched to Python 3.11.





  - Marked as a stable version.





  - Optional property `end_effector_id` added to `AddActionPointJointsUsingRobot`.





  - Switched to Python 3.10, updated dependencies.





  - New RPC definitions `GetScene` and `GetProject`.





  - Breaking change of WebSockets API (`ActionStateBefore` event).
  - Switched to Python 3.9, updated dependencies.





  - New RPCs `UpdateObjectModel` and `ObjectTypeUsage`.
  - `ListScenes` and `ListProjects` updated.
  - `DeleteObjectType` replaced with `DeleteObjectTypes`.
  - `TemporaryPackage` now has (optional) debugging-related args.





  - Flag for linear movement for added to some RPCs.






  - Support for multi arm robots.
    - `arm_id` parameter added into relevant RPCs.
  - Change constants to project parameters.
  - Object aiming RPCs updated.
    - RPCs were renamed and all of them now have `dry_run`.
    - There is a new method to cancel the process.





  - Updated to work with Project service 0.8.0.
    - `ProjectConstant` renamed to `ProjectParameter`.





  - Return value of `GetCameraPose` RPC updated.
  - Locking-related RPCs and events.
  - New RPC `AddApUsingRobot`.


  - ObjectType which source code contained Windows line endings was always evaluated as modified.





  - New RPC `SetEefPerpendicularToWorld`.
  - New RPC `StepRobotEef`.




  - `CopyActionPoint` RPC added.
  - `HandTeachingMode` RPC and event added.
  - `safe` added to `MoveToPose`, `MoveToJoints`, `MoveToActionPoint`.




  - `Calibration` RPC renamed to `GetCameraPose`.
  - New `MarkersCorners` RPC.




  - `ActionResult` event changed to match with `ActionState` (support for actions that may return more than one result).
  - `ProcessState` event for signalling state of long-running processes.
  - RPCs for camera/robot calibration.


  - RPC for IK/FK.




  - RPC for IK/FK.





  - ARCOR2 dependency updated




  - WS API for updates of scene objects parameters and management of project-defined overrides.
  - `UpdateObjectPose` and `UpdateActionPointPosition` now has dry_run.
  - Box/Cylinder/Sphere models now have some constraints on their dimensions (checked in `__post_init__`).



  - The first release of the separated package.


pkgId: 0c7b95c113aef1e86c1882b5acb200921d5e7601d1ede050f3a5690d574876f9
name: python-arcor2-calibration
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: ARCOR2 Calibration
url: https://pypi.org/project/arcor2-calibration/
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcor2-calibration-1.2.0-1.src.rpm
checksum_type: sha256
description:
  ```yaml
  id: Arbitrary text
  marker_size: 0.1
  markers:
    10:
      pose:
        position:
          x: 0
          y: 0
          z: 0
        orientation:
          x: 0
          y: 0
          z: 0
          w: 1
  ```



  - `ARCOR2_CALIBRATION_URL=http://0.0.0.0:5014` - by default, the service listens on port 5014.
  - `ARCOR2_CALIBRATION_DEBUG=1` - switches logger to the `DEBUG` level.
  - `ARCOR2_CALIBRATION_MOCK=1` - the service will start in a mock (simulator) mode.
  - `ARCOR2_REST_API_DEBUG=1` - turns on Flask debugging (logs each endpoint call).


  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),





  - Updated dependencies, switched to Python 3.11.





  - Markers used to be from 7x7 dictionary, which is unnecessarily large, now a 4x4 dictionary of size 50 is used (use marker IDs 0..49).





  - Marked as a stable version.
  - Health check end-point changed to `/healthz/ready`.





  - Switched to Python 3.10, updated dependencies.





  - **BREAKING**: Implement new error handling flow. Error codes of **every** endpoint were replaced with error
    types as described in swagger documentation.
  - Updated to reflect changes in `cv2.aruco`.






  - New environment variables:
    - `ARCOR2_CALIBRATION_DEBUG` to turn on debugging.
    - `ARCOR2_CALIBRATION_MOCK` to start in mock mode.





  - Handle invalid input parameters (camera matrix).
  - Scale down images to a common resolution before computing blur score.




  - Improved quality estimation (take orientation into account).
  - Reject blurry images.



  - `PUT /calibrate/camera` now returns `EstimatedPose` (pose + quality).


  - Command line arguments fixed.
    - It is mandatory to provide `-c` (path to a configuration file) or one of `-s` (prints OpenAPI) or `-m` (start as mock).



  - The service now requires YAML configuration file where placement of markers is specified.
  - There might be 1-n markers in an arbitrary pose.
  - At least one of the configured markers should be visible.
  - Un-configured markers are ignored.
  - Estimated poses of the camera from multiple detected markers are so far simply averaged.
  - The average is weighted according to the camera-marker distance.



  - `PUT /calibrate/camera` now has `inverse` parameter.



  - Part of the code refactored into `arcor2/flask.py`.
  - API for getting pixel coordinates of markers corners.
    - Approx. three times faster than camera calibration.



  - Bump version to allow reupload to pypi



  - Initial release of the package.
  - Support for camera calibration.
  - Support for robot calibration.
    - URDF model of the robot needed.
    - Requires depth camera (e.g. Kinect).
  - `--mock` argument to start the service in a simulation mode.


pkgId: 8cdea651095e1c3bdb86ecd9cd8efeca73a6723e07a1696f76ecf28f0b0aa6db
name: python-arcor2-dobot
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: ARCOR2 Dobot service
url: https://pypi.org/project/arcor2-dobot/
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcor2-dobot-1.3.0-1.src.rpm
checksum_type: sha256
description:
  - `ARCOR2_DOBOT_URL=http://0.0.0.0:5018` - by default, the service listens on port 5018.
  - `ARCOR2_DOBOT_MODEL=magician` - can be set to `magician` or `m1`.
  - `ARCOR2_DOBOT_BIAS_X` (as well as `_Y` and `_Z`) - sets EEF parameters (offset), default value is 0.
  - `ARCOR2_DOBOT_MOCK=1` - the service will start in a mock (simulator) mode.
    - Please note that the mock mode is fully functional only for `magician`. The `m1` does not have IK/FK implemented yet.
   `ARCOR2_DOBOT_DEBUG=1` - turns on debug logging.


  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),





  - Updated dependencies, switched to Python 3.11.





  - Setting belt distance is now blocking operation.





  - Biases are now converted to millimeters when sent to robot.





  - Added `ARCOR2_DOBOT_BIAS_X`, `ARCOR2_DOBOT_BIAS_Y`, `ARCOR2_DOBOT_BIAS_Z` env. variables to set EEF parameters - offset, which is different for different tools.





  - Marked as a stable version.
  - Health check end-point changed to `/healthz/ready`.





  - Switched to Python 3.10, updated dependencies.





  - `DobotGeneral` had wrong ancestor.
  - `moveType` default value.




  - **BREAKING**: Implement new error handling flow. Error codes of **every** endpoint were replaced with error
    types as described in swagger documentation.
  - Updated API description.
  - Model and port are now set using environment variables.


  - New exception classes





  - Support for safe movements.
    - Connection to Scene Service Mock needed.
    - New parameter `safe` for `PUT /eef/pose`.
    - For JOINT and JUMP movements: add intermediate points with higher z, if there might be a collision.
    - For LINEAR: raise an exception if there might be collision.
  - Debug logging can be turned on by adding `-d` or setting `ARCOR2_DOBOT_DEBUG`.



  - In mock-mode, `cleanup` was throwing `AttributeError`.





  - Support for conveyor belt.



  - Suction is switched off during `stop`.




   - New environment variable `ARCOR2_DOBOT_MOCK` to start the service in a mock mode.
   - Classes updated to match `Robot` (new argument `include_gripper`).
   - Handle `DobotApi` exceptions to produce nice error messages.
   - Use HTTP code 204 instead of 200 where it makes sense.




   - EEF orientation.
   - State controller paths.




   - Suction offset for M1 adjusted




   - Dobot axis Z is in mm
   - Added fixed offset for suction




  - Integration of `pydobot` library (own modified fork).
  - API for hand teaching mode.




  - Initial release of the Dobot service.


pkgId: dce1adbfebca0f4246cd81b14d3a8f2799a4a3a60b72a6862326071133e209b8
name: python-arcor2-execution-data
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: ARCOR2 Execution service data
url: https://pypi.org/project/arcor2-execution-data/
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcor2-execution-data-1.2.0-1.src.rpm
checksum_type: sha256
description:
  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),





  - Updated dependencies, switched to Python 3.11.





  - Dependency on `arcor2_runtime~=1.1.0`.





  - Marked as a stable version.





  - Switched to Python 3.10, updated dependencies.





  - Breaking change of WebSockets API (`ActionStateBefore` event).
  - Switched to Python 3.9, updated dependencies.





  - Fixed mutual dependency between `arcor2_execution_data` and `arcor2_runtime` (`package.py` moved to `arcor2_runtime`).





  - Stuff needed by the main script moved to `arcor2_runtime`.
  - New RPC `StepAction`, debugging-related arguments added to `RunPackage`.





  - `Resources` can now handle `CollisionObject`.






  - Property `description` added to `ProjectMeta`.




  - Modules `package` and `resources` moved here from `arcor2` package.
  - `Resources` class now do not have any parameters (it used to have `project_id`).


  - In `Resources/__exit__`, collision models were deleted before calling `cleanup` for each object.




  - `PackageState` RPC removed.




  - `PackageSummary` now contains optional `project_meta` property which may hold basic information about the project embedded in the execution package.




  - ARCOR2 dependency updated



  - The first release of the separated package.


pkgId: f7e47bb72676f53735b86f411ef3d0fa81155eb543af8fcea29101238d135ab3
name: python-arcor2-execution-rest-proxy
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: REST Proxy for ARCOR2 Execution service.
url: https://pypi.org/project/arcor2-execution-rest-proxy/
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcor2-execution-rest-proxy-1.2.0-1.src.rpm
checksum_type: sha256
description:
  - `ARCOR2_EXECUTION_PROXY_PORT=5009` - by default, the service listens on port 5009.
  - `ARCOR2_EXECUTION_PROXY_DB_PATH=/tmp` - by default, the service stores its files in the `/tmp` folder.
  - `ARCOR2_REST_API_DEBUG=1` - turns on Flask debugging (logs each endpoint call).


  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),





  - `ExecutionInfo` contains action point IDs from all threads.



  - It was not possible to clear breakpoints (send empty array) using Swagger.





  - Updated dependencies, switched to Python 3.11.





  - Marked as a stable version.



  - Health check end-point `/healthz/ready`.





  - Switched to Python 3.10, updated dependencies.





  - Update of swagger definition for selected endpoints.





  - **BREAKING**: Implement new error handling flow. Error codes of **every** endpoint were replaced with error
    types as described in swagger documentation.
  - **BREAKING**: `/packages/executioninfo` endpoint changed to `/packages/state`. Tests updated.
  - Update of API description.
  - Change of service name.



  - New API exceptions added.
  - `SummaryProject`, `SummaryPackage`, `ExecutionInfo`, `Token` fields description.





  - `ExecutionInfo` was extended with an optional property `actionPointIds`.



  - Switched to Python 3.9, updated dependencies.





  - Fixed mutual dependency between `arcor2_execution_data` and `arcor2_runtime` (`package.py` moved to `arcor2_runtime`).





  - Added API for setting and getting breakpoints.
    - Breakpoints are cleared when package is normally started or deleted.
    - Breakpoints can be only set when there is no running package.
  - API version changed to 0.8.0.





  - Support for debugging.
    - New methods `PUT /packages/{packageId}/debug` and `PUT /packages/step`.
    - The script can now be started in paused state.
    - Breakpoints can be set on action points.
    - The paused script can be stepped to the following action.




  - Added EXPOSE to dockerfile




  - API version was not updated.




  - Property `description` added to `SummaryProject`.
  - If more exceptions happen, they are combined into `exceptionMessage`.





  - OpenAPI definition updated.




  - Update of dependencies.




  - Implements Execution API 0.5.0.
    - Execution state `Pending` was added, which is reported when long-running operation takes place (e.g. pause a package).




  - Part of the code refactored into `arcor2/flask.py`.
  - Update of 3rd party dependencies.




  - Error code and message when attempting to delete a non-existent execution package.




  - Implements Execution API 0.4.0.
    - `ProjectName` property added to `SummaryPackage` model.




  - ARCOR2 dependency updated



  - The first release of the separated package.
  - API version is now hardcoded (0.3.0 at the moment).
  - Tokens controller added.
    - Tokens as saved in DB in directory specified by ```ARCOR2_EXECUTION_PROXY_DB_PATH```.
  - Added wait until the Execution service is up.


pkgId: eec40eceb56467203b35a80339ca2136231902f7a7434401a513ba36fb5b1361
name: python-arcor2-fit-demo
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: ARCOR2 FIT Demo
url: https://pypi.org/project/arcor2-fit-demo/
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcor2-fit-demo-1.5.0-1.src.rpm
checksum_type: sha256
description:
  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),





  - Updated dependencies, switched to Python 3.11.





  - Minor changes to ObjectTypes.





  - New ObjectTypes for simulated operations.





  - `KinectAzure` ObjectType is now imported from `src/python/arcor2_kinect_azure_data/object_types/kinect_azure.py`.





  - Compatibility with `arcor2_kinect_azure:0.6.0`.
  - Default url for Kinect.





  - Marked as a stable version.





  - Switched to Python 3.10, updated dependencies.





  - Default url was missing for `ConveyorBelt`.





  - No need to enter the Dobot model/port - both are now set when starting the service.





  - Fixed upload of URDF files (`arcor2`).






  - `pick` and `place` actions now have `safe_approach`, `safe_pick`/`safe_place` and `velocity` parameters.





  - Support for Dobot conveyor belt.
    - There is a new Object Type `ConveyorBelt`.
    - The `url` in settings should point to the Dobot service (same url as for `DobotMagician`).





  - Changes regarding updated signatures of `Robot` methods (`__init__`, `move_to_pose`, `robot_joints`).
  - Kinect mesh fixed (some empty geometries removed).
  - Dobot Magician materials removed from URDF.





  - Default values for url fields of object parameters.
  - Added docstrings to some actions.
  - Added mesh for KinectAzure.





  - Object types now use a mixin to share the common code.



  - State controller paths are now consistent.




  - Dobot M1 does not have IK/FK so far




  - Signatures of some robot methods.
  - Added temporal workaround to `AbstractDobot/pick`.




  - `pick`/`place` actions.
  - Hand teaching mode.
  - During initialization, stop the Dobot service if already started.
  - Raise exception on `safe=True` (not supported).




  - ObjectTypes are now just proxies to the Dobot service.
  - Added the mandatory `an` parameter to all actions.


  - Dobot M1 model (rotation of parts).




  - Various fixes regarding `DobotMagician` and `DobotM1`.
  - `KinectAzure` ObjectType was added.




  - ARCOR2 dependency updated



  - Package is now part of the arcor2 monorepo.
  - Support for Dobot M1.
  - Improved handling of exceptions.


pkgId: 7c35ee6aef17b66c53164d73fba2fe366d9162c3532d3b2344de54e50886e86c
name: python-arcor2-mocks
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Mocks for services developed by Kinali.
url: https://pypi.org/project/arcor2-mocks/
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcor2-mocks-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Mocks for services developed by Kinali.



  - `ARCOR2_PROJECT_SERVICE_MOCK_PORT=5012` - by default, the Project mock listens on port 5012.
  - `ARCOR2_REST_API_DEBUG=1` - turns on Flask debugging (logs each endpoint call).


  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),





  - Updated dependencies, switched to Python 3.11.





  - Marked as a stable version.
  - REST API updated to match Project 1.0.0-rc.1.



  - Health check end-point `/healthz/ready` to match Project 0.23.0 and Asset 0.6.0.





  - Switched to Python 3.10, updated dependencies.





  - **BREAKING**: Scene service was moved into `arcor2_scene`.





  - **BREAKING**: Implement new error handling flow. Error codes of **every** endpoint were replaced with error
    types as described in swagger documentation.
  - **BREAKING**: Update API to match new convention.



  - New exception classes





  - Simple collision checking on Scene Service Mock using Open3D ray-casting.
    - Checks whether there is collision between two points.
    - So far works only for primitive models.
    - Amount of (safety) inflation (in meters) can be controlled by `-i` argument or by `ARCOR2_SCENE_INFLATION`. Default value is 0.01.
  - Debug logging can be turned on by adding `-d` or setting `ARCOR2_SCENE_DEBUG`.





  - Dependency on `arcor2==0.21.0`.



  - Handling of `created` property.





  - Compatibility with Project service 0.10.0.
  - Compatibility with Scene service 0.5.0.




  - Updated to match API of Project service 0.8.0.




  - Updated to match API of Project service 0.7.0.




  - Methods from System controller missed OpenAPI definition.


  - Configurable delay on start/stop.
    - Scene mock can simulate that start and stop take some time.
    - Mean time can be set using `ARCOR2_MOCK_SCENE_DELAY_MEAN`.
    - `ARCOR2_MOCK_SCENE_DELAY_SIGMA` sets the sigma of normal distribution.




  - Methods to store/get mesh files were added to the mock Project.




  - Part of the code refactored into `arcor2/flask.py`.
  - Update of 3rd party dependencies.




  - Scene service mock updated to match Scene 0.4.0.




  - ARCOR2 dependency updated


  - Scene Service Mock updated to match Scene Service version 0.3.0.



  - Mocks updated to match Project 0.4.0 and Scene 0.2.0.


pkgId: b4d8d3daee6b10f87a118ba5304890f6de13aa5ddb197dfd8e66beb08c6a268c
name: python-arcos4py
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: A python package to detect collective spatio-temporal phenomena.
url: https://github.com/bgraedel/arcos4py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcos4py-0.2.5-1.src.rpm
checksum_type: sha256
description:
  The time series should be arranged in a long table format where each row defines the object's location, time, and optionally the measurement value.
  ARCOS defines an ARCOS object on which several class methods can be used to prepare the data and calculate collective events.
  Optionally the objects used in the ARCOS class can be used individually by importing them from arcos.tools


pkgId: 7377ff6c21e2a3efc17a78c2f63626e7f203f9553fd2ad637ab9120199f09d87
name: python-arcospy
arch: src
version: 1.3.7
epoch: 0
release: 1
summary: Python version of the R arcos package
url: https://github.com/jeffcsauer/arcospy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcospy-1.3.7-1.src.rpm
checksum_type: sha256
description:
  **Disclaimer: please note that the author of this package, Jeff Sauer, is not affiliated with _The Washington Post_ in any official capacity.**


pkgId: 6174c8f3d644a2aa5ff387324be418450e8b1d39ba8fa02909f57d7b871e5e82
name: python-arcsecond
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: CLI for arcsecond.io
url: https://github.com/arcsecond-io/cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcsecond-3.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Deploy Docs](https://github.com/arcsecond-io/cli/actions/workflows/docsdeploy.yml/badge.svg)](https://github.com/arcsecond-io/cli/actions/workflows/docsdeploy.yml) [![Downloads](http://pepy.tech/badge/arcsecond)](http://pepy.tech/project/arcsecond)



  The Command-line interface (CLI) for Arcsecond. It can be used as Python
  module too. The CLI makes it easy to login/register and access Arcsecond resources,
  public and private ones.

  [Read the docs](https://docs.arcsecond.io/cli)



  To start developing the arcsecond CLI, fork the project, `git clone` it,
  then, in the arcsecond-cli folder, do
  (assuming [virtualenv](https://virtualenv.pypa.io/en/stable/) is installed):

  ```bash
  $ cd ~/arcsecond-cli
  $ virtualenv --python=pythonX.Y env
  $ source env/bin/activate
  $ pip install -e .
  ```

  The last line ensure you can call the "locally installed" version of the
  code of that folder. Once done one first time, only the `source
  env/bin/activate` is needed when you restart a debugging session.


pkgId: 4ad611dac66fe2d097265aee2dd5fb3642a1168d88579086e27f0dcfc56aae60
name: python-arcsecond
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: CLI for arcsecond.io
url: https://github.com/arcsecond-io/cli
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcsecond-3.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Deploy Docs](https://github.com/arcsecond-io/cli/actions/workflows/docsdeploy.yml/badge.svg)](https://github.com/arcsecond-io/cli/actions/workflows/docsdeploy.yml) [![Downloads](http://pepy.tech/badge/arcsecond)](http://pepy.tech/project/arcsecond)



  The Command-line interface (CLI) for Arcsecond. It can be used as Python
  module too. The CLI makes it easy to login/register and access Arcsecond resources,
  public and private ones.

  [Read the docs](https://docs.arcsecond.io/cli)



  To start developing the arcsecond CLI, fork the project, `git clone` it,
  then, in the arcsecond-cli folder, do
  (assuming [virtualenv](https://virtualenv.pypa.io/en/stable/) is installed):

  ```bash
  $ cd ~/arcsecond-cli
  $ virtualenv --python=pythonX.Y env
  $ source env/bin/activate
  $ pip install -e .
  ```

  The last line ensure you can call the "locally installed" version of the
  code of that folder. Once done one first time, only the `source
  env/bin/activate` is needed when you restart a debugging session.

rpm_license:
  MIT License  Copyright (c) 2016 Cédric Foellmi  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: 98275dbd76a43273668681cdbeeb957cf28e6b47056fb5da5bbc88f0a2dafdbe
name: python-arcsolver
arch: src
version: 0.0.4
epoch: 0
release: 1
url: https://github.com/agemoai/arcsolver
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcsolver-0.0.4-1.src.rpm
checksum_type: sha256
summary:
  A Python library for automatically solving Abstraction and Reasoning Corpus (ARC) challenges using Claude and object-centric modeling.

description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

  This library contains tools for visualizing, analyzing and solving tasks
  from the Abstraction and Reasoning Corpus (ARC) challenge dataset.

  Interaction with Claude



  Install latest from the GitHub
  [repository](https://github.com/agemoai/arcsolver):

  ``` sh
  $ pip install git+https://github.com/agemoai/arcsolver.git
  ```

  or from [pypi](https://pypi.org/project/arcsolver/)

  ``` sh
  $ pip install arcsolver
  ```



  - **Task Management:** Load and visualize ARC tasks with the
    [`ArcTask`](https://agemoai.github.io/arcsolver/task.html#arctask)
    class
  - **Object-Centric Modelling:** A set of primitive classes for
    representing grid objects and transformations
  - **LLM Integration:** Designed to use Claude Sonnet 3.5 for automated
    task analysis and solution generation
  - **Extensible Architecture:** Easy to add new primitives and helper
    functions to enhance solving capabilities





  The `task` module provides classes for working with ARC tasks

  ``` python
  from arcsolver.task import ArcGrid, ArcPair, ArcTask

  task = ArcTask('1e0a9b12'); task.plot()
  ```

  ![](index_files/figure-commonmark/cell-2-output-1.png)

  An [`ArcTask`](https://agemoai.github.io/arcsolver/task.html#arctask)
  comprises a list of input-output example
  [`ArcPair`](https://agemoai.github.io/arcsolver/task.html#arcpair)s,
  each of which holds two
  [`ArcGrid`](https://agemoai.github.io/arcsolver/task.html#arcgrid)s.
  Each class has convenient `plot` methods for visualization or directly
  outputting to base64-encoded strings that can be passed to Claude

  ``` python
  print(f"Input grid 1 plot: {task.train[0].input.plot(to_base64=True)[:20]}...")
  ```

      Input grid 1 plot: b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x01H'...



  The `ocm` module provides a set of primitive classes for constructing
  object-centric models of ARC grids

  ``` python
  from arcsolver.ocm import Vector, Rectangle, Line, Grid, Color, Direction

  grid = Grid(
      size=Vector(8,8),
      background_color=Color('grey'),
      objects=[
          Rectangle(position=Vector(1,1), size=Vector(2,2), color=Color('red')),
          Line(position=Vector(6,1), direction=Direction.NE, length=6, color=Color('pink'))
      ]
  )
  ArcGrid(grid.to_array()).plot()
  ```

  ![](index_files/figure-commonmark/cell-4-output-1.png)



  Use Claude to analyze and describe ARC tasks

  ``` python
  model = 'claude-3-5-sonnet-20241022-v2:0'
  ```

  ``` python
  from arcsolver.describe import DescriptionGenerator

  describer = DescriptionGenerator(model, client_type='bedrock')
  d = await describer.describe_task(task, 1); print(d[0].d)
  ```

      The input grids contain various colored squares arranged in different patterns against a black background. The transformation applies a "gravity" effect where all colored squares fall to the bottom row while maintaining their relative left-to-right ordering. Vertical sequences of the same color in the same column compress into a single square in the bottom row. All rows above the bottom row become black except where vertical sequences of the same color maintain connectivity.



  Use Claude to construct a solution to an ARC task, automatically
  refining its attempts based on execution and prediction error feedback.

  ``` python
  from arcsolver.solve import ArcSolver

  solver = ArcSolver(model, 'bedrock')
  solutions = await solver.solve(task, )
  ```


      Solving task: 1e0a9b12
      Generating descriptions... | Attempts: 0/30 | Best Score: 0.000 | Cost: $0.000
      Starting solution attempts... | Attempts: 0/30 | Best Score: 0.000 | Cost: $0.142
      Generating initial solutions... | Attempts: 0/30 | Best Score: 0.000 | Cost: $0.142
      Testing solutions... | Attempts: 0/30 | Best Score: 0.000 | Cost: $0.231
      Continuing refinement... | Attempts: 2/30 | Best Score: 0.866 | Cost: $0.231
      Refining previous solutions... | Attempts: 2/30 | Best Score: 0.866 | Cost: $0.231
      Testing solutions... | Attempts: 2/30 | Best Score: 0.866 | Cost: $0.332
      Continuing refinement... | Attempts: 4/30 | Best Score: 0.904 | Cost: $0.332
      Refining previous solutions... | Attempts: 4/30 | Best Score: 0.904 | Cost: $0.332
      Testing solutions... | Attempts: 4/30 | Best Score: 0.904 | Cost: $0.424
      Continuing refinement... | Attempts: 6/30 | Best Score: 0.951 | Cost: $0.424
      Refining previous solutions... | Attempts: 6/30 | Best Score: 0.951 | Cost: $0.424
      Testing solutions... | Attempts: 6/30 | Best Score: 0.951 | Cost: $0.528
      Continuing refinement... | Attempts: 8/30 | Best Score: 0.951 | Cost: $0.528
      Refining previous solutions... | Attempts: 8/30 | Best Score: 0.951 | Cost: $0.528
      Testing solutions... | Attempts: 8/30 | Best Score: 0.951 | Cost: $0.633
      Continuing refinement... | Attempts: 10/30 | Best Score: 0.958 | Cost: $0.633
      Refining previous solutions... | Attempts: 10/30 | Best Score: 0.958 | Cost: $0.633
      Testing solutions... | Attempts: 10/30 | Best Score: 0.958 | Cost: $0.732
      Continuing refinement... | Attempts: 12/30 | Best Score: 0.965 | Cost: $0.732
      Refining previous solutions... | Attempts: 12/30 | Best Score: 0.965 | Cost: $0.732
      Testing solutions... | Attempts: 12/30 | Best Score: 0.965 | Cost: $0.835
      Found potential solution, validating... | Attempts: 12/30 | Best Score: 1.000 | Cost: $0.835
      Solution found! | Attempts: 14/30 | Best Score: 1.000 | Cost: $0.835
      Solution found! 🎉 | Attempts: 14/30 | Best Score: 1.000 | Cost: $0.835



  Contributions are welcome! Refined prompts, new OCM primitives, expanded
  tool-use, alternative retry strategy…

  Feel free to raise an issue or submit a PR.



  To read about the motivation for building this tool, check out our
  [blog](https://agemo.ai/resources/summer-of-arc-agi) and watch out for
  future posts


pkgId: 18bf217be95ee4412d37a6f4cf9ec104e060432967b61d6c9cafa4e8ff992c9f
name: python-arctic
arch: src
version: 1.82.2
epoch: 0
release: 1
summary: AHL Research Versioned TimeSeries and Tick store
url: https://github.com/man-group/arctic
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arctic-1.82.2-1.src.rpm
checksum_type: sha256
description:
  Information on how to set up, install and use Arctic has been moved to [README-arctic.md](README-arctic.md).


   * Release: #1022 Prepare release 1.82.2
   * Perf: #1021 Improve performance of Tickstore read
   * Bugfix: #1019 Remove failing requirements.txt versions
   * Docs: #1019 Updated links to ArcticDB website and docs
   * Docs: #1017 Fix doc for chunkstore's list_symbols

   * Release: #1014 Prepare release 1.82.1
   * Bugfix: #1013 Fix serialized tz name for index timezones of dateutil.timezone.tzutc()
   * Bugfix: #1013 Fix serialized tz name for single-level index timezones of dateutil.timezone.gettz("UTC")

   * Release: #1012 version 1.82.0
   * Compatibility: update pinning from pandas<1.1, to pandas<2
   * Compatibility: update pinning from numpy<1.19 to numpy<2
   * Build: specify which version of python/numpy/pandas to test
   * Bugfix: #887 #928 resolve import error on pandas.Panel, Panel was removed in pandas 1.0
   * Bugfix: fix pandas get_timezone() argument cannot be None
   * Bugfix: fix np.float/np.int/np.book depreciations
   * Bugfix: fix numpy tostring() is deprecated. Use tobytes() instead.
   * Bugfix: numpy.testing.utils is deprecated
   * Bugfix: pandas.util.testing is deprecated
   * Cleanup: remove async_benchmark

    * Feature: #1000, #1001, #1002, #1003, #1007, #1008 ArcticDB docs, links etc
    * Bugfix:  #1009 force CircleCI to install tzlocal==4.2

    * Feature: #996 release wheel to pypi as well as tar.gz, egg.

    * Bugfix:  #979 fix circleci mongo install
    * Feature: #980 get testpack running with mongod 4.4.18
    * Bugfix:  #985 suppress FutureWarning for Panel import
    * Bugfix:  #989 VersionStore slow snapshot delete add new index
    * Bugfix:  #806, #990 DateTimeIndex tz serialization

    * Feature: #950 remove all traces of python 2.7 and six package
    * Feature: #959 add python 3.8 support
    * Feature: #962 pin pandas<1.1.0, numpy<1.19.0

    * Bugfix:  #940 fix rows per chunk causing divide by zero
    * Feature: #943 check markdown rendering of README.md and CHANGES.md in build
    * Bugfix:  #946 move test dependencies to tests_require

    * Feature: #941 use named index for VersionStore to avoid 127 max fully qualified index name
    * Bugfix:  #935, #936 fixed README.md rendering which was preventing pypi upload

    * Bugfix: #932 revert serialization-optimization (#909, #910)

    * Bugfix: #855 use IXSCAN for list\_symbols which speeds up snapshotting (actually #856)
    * Bugfix: #926 avoid pathologically slow count_documents() call with pymongo > 3.6.0

    * Feature: #919 Add CircleCI badge to README.md
    * Feature: #917 Add CircleCI build
    * Bugfix:  #910 Fix column subsetting bug
    * Bugfix:  #909 Speedup FrameToArray serialiser for ChunkStore by removing intermediate DataFrame construction
    * Bugfix:  #902 Chunkstore-read-speedup
    * Bugfix:  #872 Do not spam if not permissioned on cache db
    * Bugfix:  #874 Pickle protocol 5 not supported in 3.7 and below
    * Bugfix:       Handle uninitialized cache object
    * Feature: #897 Pin numpy 1.18.4
    * Feature: #897 Pin pandas 1.0.3
    * Bugfix:  #881 Fix for issue #815
    * Bugfix:  #875 Fix flake8 errors

    * Bugfix: Update code to work with latest version of pandas
    * Bugfix: Fix missing column handling in numpy serializer

    * Bugfix: #832 Bytes to unicode for pd.Series
    * Feature: #825 Max BSON size configurable
    * Bugfix: #823 Don't retry bulk write errors
    * Feature: #802 kwargs passed through to iterators in chunkstore

    * Feature: Allow list_library caching to be tunable via a settings collection.
    * Bugfix: #777: Handle empty columns in dataframes

    * Bugfix: Pandas convert multiindexes to unicode if flag set.

    * Bugfix: #765 Pandas data columns require encoding to convert to unicode.

    * Bugfix: Use the default encoding (ascii) instead of bytes for unpickling.

    * Bugfix: pypandoc not rendering README correctly for PYPI
    * Bugfix: #744 get_info on an empty dataframe raises an exception
    * Bugfix: #751 Handle unpickling py2 datetime and other object types with latin1
    * Bugfix: #598 Add an option to convert py2 str to py3 str (unicode type) on read.

    * Bugfix: #712 Pandas deprecation warning in chunkstore serializer
    * BugFix: #670 Lots of pycodestyle fixes
    * BugFix: #691 Fix arrays_to_mgr for pandas 0.23.4+
    * BugFix: #698 Fix no handler in logging warning
    * BugFix: #705 Use sort_index instead of sortlevel\_
    * BugFix: #710: Initialize SEGMENT_SHA in versions for writes and appends
    * Feature: #669 Experimental initial implementation of async arctic
    * Feature: #704 Do not enable sharding by default in BSONStore.
    * Feature: #688 Remove Chunkstore check for issue #422
    * Feature: #717 Add a best effort cache for list_libraries
    * Bugfix: #722 Exception while reading a column from chunkstore with a column missing in the chunk

    * Bugfix: #658 Write/append errors for Panel objects from older pandas versions
    * Feature: #653 Add version meta-info in arctic module
    * Feature: #663 Include arctic numerical version in the metadata of the version document
    * Feature: #650 Implemented forward pointers for chunks in VersionStore (modes: enabled/disabled/hybrid)

    * Feature: #577 Added implementation for incremental serializer for numpy records
    * Bugfix: #648 Fix issue with Timezone aware Pandas types, which don't contain hasobject attribute

    * Bugfix: #645 Fix write errors for Pandas DataFrame that has mixed object/string types in multi-index column

    * Bugfix: #157 Assure that serialized dataframes remain value-equivalent (e.g. avoid NaN --> 'nan' in mixed string columns)
    * Bugfix: #608 Ensure Arctic performs well with MongoDB 3.6 (sorting)
    * Bugfix: #629 Column kwarg no longer modified
    * Bugfix: #641 DateRange.intersection open/closed range fix
    * Feature: #493 Can pass kwargs when calling MongoClient, e.g. for ssl
    * Feature: #590 Faster write handler selection for DataFrames with objects
    * Feature: #604 Improved handling handling for pickling serialization decidions

    * Docs: VersionStore documentation
    * Bugfix: Issue #612 ThreadPool should be created by process using it
    * Feature: Upsert option on appends in ChunkStore

    * Feature: #553 Compatibility with both the new and old LZ4 API
    * Feature: #571 Removed the Cython LZ4 code, use the latest python-lz4
    * Feature: #557 Threadpool based compression. Speed imrpovement and tuning benchmarks.
    * Bugfix: fix tickstore unicode handling, support both unicode and utf-8 arrays
    * Bugfix: #591 Fix tickstore reads not returning index with localized timezone
    * Feature: #595 add host attribute to VersionedItem.
    * Bugfix: #594 Enable sharding on chunkstore

    * Bugfix: #579 Fix symbol corruption due to restore_version and append
    * Bugfix: #584 Fix list_versions for a snapshot after deleting symbols in later versions

    * Bugfix: #561 Fix PickleStore read corruption after write_metadata

    * Bugfix: #168 Do not allow empty string as a column name
    * Bugfix: #483 Remove potential floating point error from datetime_to_ms
    * Bugfix: #271 Log when library doesnt exist on delete
    * Feature: MetaDataStore: added list_symbols with regexp, as_of and metadata fields matching filters
    * Feature: Support for serialization of DataFrames in Pandas 0.23.x

    * Bugfix: #534 VersionStore: overwriting a symbol with different dtype (but same data format) does not
                   raise exceptions anymore
    * Bugfix: #531 arctic_prune_versions: clean broken snapshot references before pruning
    * Bugfix: setup.py develop in a conda environment on Mac
    * Feature: #490 add support to numpy 1.14

    * Bugfix: #521 Clang 6.0 compiler support on macOS
    * Feature: #510 VersionStore: support multi column in pandas DataFrames

    * Bugfix: #517 VersionStore: append does not duplicate data in certain corner cases
    * Bugfix: #519 VersionStore: list_symbols speed improvement and fix for memory limit exceed

    * Feature: #288 Mapping reads and writes over chunks in chunkstore
    * Bugfix: #508 VersionStore: list_symbols and read now always returns latest version
    * Bugfix: #512 Improved performance for list_versions
    * Bugfix: #515 VersionStore: _prune_previous_versions now retries the cleanup operation

    * Bugfix: #503 ChunkStore: speedup check for -1 segments
    * Feature: #504 Increasing number of libraries in Arctic to 5000.

    * Bugfix: Increase performance of invalid segment check in chunkstore
    * Bugfix: #501 Fix the spurious data integrity exceptions at write path, due to moving chunks form the balancer

    * Bugfix: #491 roll back the use of frombuffer to fromstring, fixes the read-only ndarray issue

    * Feature: #206 String support for tickstore
    * Bugfix: #486 improve mongo_retry robustness with failures for version store write/append

    * Bugfix: #468 Re-adding compatibility for pandas 0.20.x
    * Bugfix: #476 Ensure we re-auth when a new MongoClient is created after fork

    * Bugfix:  #439 fix cursor timeouts in chunkstore iterator
    * Bugfix:  #450 fix error in chunkstore delete when chunk range produces empty df
    * Bugfix:  #442 fix incorrect segment values in multi segment chunks in chunkstore
    * Feature: #457 enchances fix for #442 via segment_id_repair tool
    * Bugfix:  #385 exceptions during quota statistics no longer kill a write
    * Feature: PR#161 TickStore.max_date now returns a datetime in the 'local' timezone
    * Feature: #425 user defined metadata for tickstore
    * Feature: #464 performance improvement by avoiding unnecessary re-authentication
    * Bugfix:  #250 Added multiprocessing safety, check for initialized MongoClient after fork.
    * Feature: #465 Added fast operations for write only metadata and restore symbol to a version

    * Bugfix:  #440 Fix read empty MultiIndex+tz Series

    * Perf:    #408 Improve memory performance of version store's serializer
    * Bugfix   #394 Multi symbol read in chunkstore
    * Bugfix:  #407 Fix segment issue on appends in chunkstore
    * Bugfix:  Inconsistent returns on MetadataStore.append
    * Bugfix:  #412 pandas deprecation and #289 improve exception report in numpy record serializer
    * Bugfix:  #420 chunkstore ignoring open interval date ranges
    * Bugfix:  #427 chunkstore metadata not being correctly replaced during symbol overwrite
    * Bugfix:  #431 chunkstore iterators do not handle multi segment chunks correctly

    * Bugfix:  #397 Remove calls to deprecated methods in pymongo
    * Bugfix:  #402 Append to empty DF fails in VersionStore

    * Feature: #396 MetadataStore.read now supports as_of argument
    * Bugfix:  #397 Pin pymongo==3.4.0

    * Feature: #392 MetadataStore
    * Bugfix:  #384 sentinels missing time data on chunk start/ends in ChunkStore
    * Bugfix:  #382 Remove dependency on cython being pre-installed
    * Bugfix:  #343 Renaming libraries/collections within a namespace/database

    * BugFix: Rollback #363, as it breaks multi-index dataframe
    * Bugfix:  #372 OSX build improvements

    * Feature: Re-introduce #363 `concat` flag, essentially undo-ing 1.45
    * BugFix: #377 Fix broken `replace_one` on BSONStore and add `bulk_write`

    * Feature: #374 Shard BSONStore on `_id` rather than `symbol`

    * BugFix: Rollback #363, which can cause ordering issues on append

    * Feature: #364 Expose compressHC from internal arctic LZ4 and remove external LZ4 dependency
    * Feature: #363 Appending older data (compare to what's exist in library) will raise. Use `concat=True` to append only the
               new bits
    * Feature: #371 Expose more functionality in BSONStore

    * Bugfix:  #350 remove deprecated pandas calls
    * Bugfix:  #360 version incorrect in empty append in VersionStore
    * Feature: #365 add generic BSON store

    * Bugfix: #346 fixed daterange subsetting error on very large dateframes in version store
    * Bugfix: #351 $size queries can't use indexes, use alternative queries

    * Bugfix: #334 Chunk range param with pandas object fails in chunkstore.get_chunk_ranges
    * Bugfix: #339 Depending on lz4<=0.8.2 to fix build errors
    * Bugfix: #342 fixed compilation errors on Mac OSX
    * Bugfix: #344 fixed data corruption problem with concurrent appends

    * BugFix: #330 Make Arctic._lock reentrant

    * Feature:  #329 Add reset() method to Arctic

    * Bugfix:  #324 Datetime indexes must be sorted in chunkstore
    * Feature: #290 improve performance of tickstore column reads

    * Bugfix:  #300 to_datetime deprecated in pandas, use to_pydatetime instead
    * Bugfix:  #309 formatting change for DateRange ```__str__```
    * Feature: #313 set and read user specified metadata in chunkstore
    * Feature: #319 Audit log support in ChunkStor
    * Bugfix:  #216 Tickstore write fails with named index column

    * Feature: Default to hashed based sharding
    * Bugfix: retry socket errors during VersionStore snapshot operations

    * Bugfix:  #296 Cannot compress/decompress empty string

    * Feature: #294 Move per-chunk metadata for chunkstore to a separate collection
    * Bugfix:  #292 Account for metadata size during size chunking in ChunkStore
    * Feature: #283 Support for all pandas frequency strings in ChunkStore DateChunker
    * Feature: #286 Add has_symbol to ChunkStore and support for partial symbol matching in list_symbols

    * Feature:    #275 Tuple range object support in DateChunker
    * Bugfix:     #273 Duplicate columns breaking serializer
    * Feature:    #267 Tickstore.delete returns deleted data
    * Dependency: #266 Remove pytest-dbfixtures in favor of pytest-server-fixtures

    * Feature: #260 quota support on Chunkstore
    * Bugfix: #259 prevent write of unnamed columns/indexes
    * Bugfix: #252 pandas 0.19.0 compatibility fixes
    * Bugfix: #249 open ended range reads on data without index fail
    * Bugfix: #262 VersionStore.append must check data is written correctly during repack
    * Bugfix: #263 Quota: Improve the error message when near soft-quota limit
    * Perf:   #265 VersionStore.write / append don't aggressively add indexes on each write

    * Bugfix: #247 segmentation read fix in chunkstore
    * Feature: #243 add get_library_type method
    * Bugfix: more cython changes to handle LZ4 errors properly
    * Feature: #239 improve chunkstore's get_info method

    * Feature: #235 method to return chunk ranges on a symbol in ChunkStore
    * Feature: #234 Iterator access to ChunkStore
    * Bugfix: #236 Cython not handling errors from LZ4 function calls

    * Bugfix: #228 Mongo fail-over during append can leave a Version in an inconsistent state
    * Feature: #193 Support for different Chunkers and Serializers by symbol in ChunkStore
    * Feature: #220 Raise exception if older version of arctic attempts to read unsupported pickled data
    * Feature: #219 and #220 Support for pickling large data (>2GB)
    * Feature: #204 Add support for library renaming
    * Feature: #209 Upsert capability in ChunkStore's update method
    * Feature: #207 Support DatetimeIndexes in DateRange chunker
    * Bugfix:  #232 Don't raise during VersionStore #append(...) if the previous append failed

    * Bugfix: #195 Top level tickstore write with list of dicts now works with timezone aware datetimes

    * Bugfix: #187 Compatibility with latest version of pytest-dbfixtures
    * Feature: #182 Improve ChunkStore read/write performance
    * Feature: #162 Rename API for ChunkStore
    * Feature: #186 chunk_range on update
    * Bugfix: #189 range delete does not update symbol metadata

    * Bugfix: Faster TickStore querying for multiple symbols simultaneously
    * Bugfix: TickStore.read now respects `allow_secondary=True`
    * Bugfix: #147 Add get_info method to ChunkStore
    * Bugfix: Periodically re-cache the library.quota to pick up any changes
    * Bugfix: #166 Add index on SHA for ChunkStore
    * Bugfix: #169 Dtype mismatch in chunkstore updates
    * Feature: #171 allow deleting of values within a date range in ChunkStore
    * Bugfix: #172 Fix date range bug when querying dates in the middle of chunks
    * Bugfix: #176 Fix overwrite failures in Chunkstore
    * Bugfix: #178 - Change how start/end dates are populated in the DB, also fix append so it works as expected.
    * Bugfix: #43 - Remove dependency on hardcoded Linux timezone files

    * Bugfix: Ensure that Tickstore.write doesn't allow out of order messages
    * Bugfix: VersionStore.write now allows writing 'None' as a value

    * Bugfix: Backwards compatibility reading/writing documents with previous versions of Arctic

    * Bugfix: #109 Ensure stable sort during Arctic read
    * Feature: New benchmark suite using ASV
    * Bugfix: #129 Fixed an issue where some chunks could get skipped during a multiple-symbol TickStore read
    * Bugfix: #135 Fix issue with different datatype returned from pymongo in python3
    * Feature: #130 New Chunkstore storage type

    * Bugfix: #106 Fix Pandas Panel storage for panels with different dimensions

    * Feature: #98 Add initial_image as optional parameter on tickstore write()
    * Bugfix: #100 Write error on end field when writing with pandas dataframes

    * Feature: Add python 3.3/3.4 support
    * Bugfix: #95 Fix raising NoDataFoundException across multiple low level libraries

    * Bugfix: #81 Fix broken read of multi-index DataFrame written by old version of Arctic
    * Bugfix: #49 Fix strifying tickstore

    * Feature: Add timezone suppport to store multi-index dataframes
    * Bugfix:  Fixed broken sdist releases

    * Feature: ArticTransaction now supports non-audited 'transactions': `audit=False`
  ```
  with ArcticTransaction(Arctic('hostname')['some_library'], 'symbol', audit=False) as at:
  ```
       This is useful for batch jobs which read-modify-write and don't want to clash with
       concurrent writers, and which don't require keeping all versions of a symbol.

    * Feature: get_info API added to version_store.


    * Bugfix: correct version detection for Pandas >= 0.18.
    * Bugfix: retrying connection initialisation in case of an AutoReconnect failure.

    * Bugfix: Improve performance of saving multi-index Pandas DataFrames
      by 9x
    * Bugfix: authenticate should propagate non-OperationFailure exceptions
      (e.g. ConnectionFailure) as this might be indicative of socket failures
    * Bugfix: return 'deleted' state in VersionStore.list_versions() so that
      callers can pick up on the head version being the delete-sentinel.

    * Bugfix: VersionStore.read(date_range=...) could do the wrong thing with
      TimeZones (which aren't yet supported for date_range slicing.).

    * Bugfix: fix authentication race condition when sharing an Arctic
      instance between multiple threads.

    * Bugfix: compatibility with both 3.0 and pre-3.0 MongoDB for
      querying current authentications

    * Feature: Add support for reading a subset of a pandas DataFrame
      in VersionStore.read by passing in an arctic.date.DateRange
    * Bugfix: Reauth against admin if not auth'd against a library a
      specific library's DB.  Sometimes we appear to miss admin DB auths.
      This is to workaround that until we work out what the issue is.

    * Feature: Add support for multi-index Bitemporal DataFrame storage.
      This allows persisting data and changes within the DataFrame making it
      easier to see how old data has been revised over time.
    * Bugfix: Ensure we call the error logging hook when exceptions occur

    * Always use the primary cluster node for 'has_symbol()', it's safer

    * Bugfixes for timezone handling, now ensures use of non-naive datetimes
    * Bugfix for tickstore read missing images

    * Improvements to command-line control scripts for users and libraries
    * Bugfix for pickling top-level Arctic object

    * Allow snapshotting a range of versions in the VersionStore, and
      snapshot all versions by default.

    * Bugfix for backwards-compatible unpickling of bson-encoded data
    * Added switch for enabling parallel lz4 compression

    *  Initial public release


pkgId: 853edc2b1bedf4e343c801c2c7d42a0aeb4ccf467d1a8298c477cbd4dbcccc2a
name: python-arctix
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/durandtibo/arctix
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arctix-0.0.7-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://github.com/durandtibo/arctix/actions">
          <img alt="CI" src="https://github.com/durandtibo/arctix/workflows/CI/badge.svg">
      </a>
      <a href="https://github.com/durandtibo/arctix/actions">
          <img alt="Nightly Tests" src="https://github.com/durandtibo/arctix/workflows/Nightly%20Tests/badge.svg">
      </a>
      <a href="https://github.com/durandtibo/arctix/actions">
          <img alt="Nightly Package Tests" src="https://github.com/durandtibo/arctix/workflows/Nightly%20Package%20Tests/badge.svg">
      </a>
      <br/>
      <a href="https://durandtibo.github.io/arctix/">
          <img alt="Documentation" src="https://github.com/durandtibo/arctix/workflows/Documentation%20(stable)/badge.svg">
      </a>
      <a href="https://durandtibo.github.io/arctix/">
          <img alt="Documentation" src="https://github.com/durandtibo/arctix/workflows/Documentation%20(unstable)/badge.svg">
      </a>
      <br/>
      <a href="https://codecov.io/gh/durandtibo/arctix">
          <img alt="Codecov" src="https://codecov.io/gh/durandtibo/arctix/branch/main/graph/badge.svg">
      </a>
      <a href="https://codeclimate.com/github/durandtibo/arctix/maintainability">
          <img src="https://api.codeclimate.com/v1/badges/61b8574ea18ecf106dce/maintainability" />
      </a>
      <a href="https://codeclimate.com/github/durandtibo/arctix/test_coverage">
          <img src="https://api.codeclimate.com/v1/badges/61b8574ea18ecf106dce/test_coverage" />
      </a>
      <br/>
      <a href="https://github.com/psf/black">
          <img  alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg">
      </a>
      <a href="https://google.github.io/styleguide/pyguide.html#s3.8-comments-and-docstrings">
          <img  alt="Doc style: google" src="https://img.shields.io/badge/%20style-google-3666d6.svg">
      </a>
      <a href="https://github.com/astral-sh/ruff">
          <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;">
      </a>
      <a href="https://github.com/guilatrova/tryceratops">
          <img  alt="Doc style: google" src="https://img.shields.io/badge/try%2Fexcept%20style-tryceratops%20%F0%9F%A6%96%E2%9C%A8-black">
      </a>
      <br/>
      <a href="https://pypi.org/project/arctix/">
          <img alt="PYPI version" src="https://img.shields.io/pypi/v/arctix">
      </a>
      <a href="https://pypi.org/project/arctix/">
          <img alt="Python" src="https://img.shields.io/pypi/pyversions/arctix.svg">
      </a>
      <a href="https://opensource.org/licenses/BSD-3-Clause">
          <img alt="BSD-3-Clause" src="https://img.shields.io/pypi/l/arctix">
      </a>
      <br/>
      <a href="https://pepy.tech/project/arctix">
          <img  alt="Downloads" src="https://static.pepy.tech/badge/arctix">
      </a>
      <a href="https://pepy.tech/project/arctix">
          <img  alt="Monthly downloads" src="https://static.pepy.tech/badge/arctix/month">
      </a>
      <br/>
  </p>



  The `arctix` package consists of functionalities to prepare dataset of asynchronous time series.
  It is design to make dataset preparation reusable and reproducible.
  For each dataset, `arctix` provides 3 main functions:

  - `fetch_data` to load the raw data are loaded in
    a [`polars.DataFrame`](https://docs.pola.rs/py-polars/html/reference/dataframe/index.html). When
    possible, it downloads automatically the data.
  - `prepare_data` to prepare the data. It outputs the prepared data
    in [`polars.DataFrame`](https://docs.pola.rs/py-polars/html/reference/dataframe/index.html), and
    the metadata.
  - `to_array` to convert the prepared data to a dictionary of numpy arrays.

  For example, it is possible to use the following lines to download and prepare the MultiTHUMOS data.

  ```pycon

  >>> from pathlib import Path
  >>> from arctix.dataset.multithumos import fetch_data, prepare_data, to_array
  >>> dataset_path = Path("/path/to/dataset/multithumos")
  >>> data_raw = fetch_data(dataset_path)  # doctest: +SKIP
  >>> data, metadata = prepare_data(data_raw)  # doctest: +SKIP
  >>> arrays = to_array(data)  # doctest: +SKIP

  ```

  - [Documentation](https://durandtibo.github.io/arctix/)
  - [Installation](#installation)
  - [Contributing](#contributing)
  - [API stability](#api-stability)
  - [License](#license)



  - [latest (stable)](https://durandtibo.github.io/arctix/): documentation from the latest stable
    release.
  - [main (unstable)](https://durandtibo.github.io/arctix/main/): documentation associated to the
    main branch of the repo. This documentation may contain a lot of work-in-progress/outdated/missing
    parts.



  We highly recommend installing
  a [virtual environment](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).
  `arctix` can be installed from pip using the following command:

  ```shell
  pip install arctix
  ```

  To make the package as slim as possible, only the minimal packages required to use `arctix` are
  installed.
  To include all the packages, you can use the following command:

  ```shell
  pip install arctix[all]
  ```

  Please check the [get started page](https://durandtibo.github.io/arctix/get_started) to see how to
  install only some specific packages or other alternatives to install the library.
  The following is the corresponding `karbonn` versions and dependencies.

  | `batcharray` | `batcharray`   | `coola`      | `iden`           | `numpy`       | `polars`        | `python`      |
  |--------------|----------------|--------------|------------------|---------------|-----------------|---------------|
  | `main`       | `>=0.0.2,<1.0` | `>=0.3,<1.0` | `">=0.0.3,<1.0"` | `>=1.22,<3.0` | `>=1.0,<2.0`    | `>=3.9,<3.13` |
  | `0.0.7`      | `>=0.0.2,<1.0` | `>=0.3,<1.0` | `">=0.0.3,<1.0"` | `>=1.22,<3.0` | `>=1.0,<2.0`    | `>=3.9,<3.13` |
  | `0.0.6`      | `>=0.0.2,<0.1` | `>=0.3,<1.0` | `">=0.0.3,<1.0"` | `>=1.22,<2.0` | `>=0.20.0,<1.0` | `>=3.9,<3.13` |
  | `0.0.5`      | `>=0.0.2,<0.1` | `>=0.3,<1.0` | `">=0.0.3,<1.0"` | `>=1.22,<2.0` | `>=0.20.0,<1.0` | `>=3.9,<3.13` |
  | `0.0.4`      | `>=0.0.2,<0.1` | `>=0.3,<1.0` | `">=0.0.3,<1.0"` | `>=1.22,<2.0` | `>=0.20.0,<1.0` | `>=3.9,<3.13` |
  | `0.0.3`      | `>=0.0.2,<0.1` | `>=0.3,<1.0` | `">=0.0.3,<1.0"` | `>=1.22,<2.0` | `>=0.20.0,<1.0` | `>=3.9,<3.13` |



  Please check the instructions in [CONTRIBUTING.md](.github/CONTRIBUTING.md).



  :warning: While `arctix` is in development stage, no API is guaranteed to be stable from one
  release to the next.
  In fact, it is very likely that the API will change multiple times before a stable 1.0.0 release.
  In practice, this means that upgrading `arctix` to a new version will possibly break any code that
  was using the old version of `arctix`.



  `arctix` is licensed under BSD 3-Clause "New" or "Revised" license available in [LICENSE](LICENSE)
  file.


pkgId: 2cf8fcbaf758f4400e99e0ac7984cdfc5be7ff1ba9551e06fc9d683e10349325
name: python-arctix
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/durandtibo/arctix
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arctix-0.0.8-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://github.com/durandtibo/arctix/actions">
          <img alt="CI" src="https://github.com/durandtibo/arctix/workflows/CI/badge.svg">
      </a>
      <a href="https://github.com/durandtibo/arctix/actions">
          <img alt="Nightly Tests" src="https://github.com/durandtibo/arctix/workflows/Nightly%20Tests/badge.svg">
      </a>
      <a href="https://github.com/durandtibo/arctix/actions">
          <img alt="Nightly Package Tests" src="https://github.com/durandtibo/arctix/workflows/Nightly%20Package%20Tests/badge.svg">
      </a>
      <br/>
      <a href="https://durandtibo.github.io/arctix/">
          <img alt="Documentation" src="https://github.com/durandtibo/arctix/workflows/Documentation%20(stable)/badge.svg">
      </a>
      <a href="https://durandtibo.github.io/arctix/">
          <img alt="Documentation" src="https://github.com/durandtibo/arctix/workflows/Documentation%20(unstable)/badge.svg">
      </a>
      <br/>
      <a href="https://codecov.io/gh/durandtibo/arctix">
          <img alt="Codecov" src="https://codecov.io/gh/durandtibo/arctix/branch/main/graph/badge.svg">
      </a>
      <a href="https://codeclimate.com/github/durandtibo/arctix/maintainability">
          <img src="https://api.codeclimate.com/v1/badges/61b8574ea18ecf106dce/maintainability" />
      </a>
      <a href="https://codeclimate.com/github/durandtibo/arctix/test_coverage">
          <img src="https://api.codeclimate.com/v1/badges/61b8574ea18ecf106dce/test_coverage" />
      </a>
      <br/>
      <a href="https://github.com/psf/black">
          <img  alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg">
      </a>
      <a href="https://google.github.io/styleguide/pyguide.html#s3.8-comments-and-docstrings">
          <img  alt="Doc style: google" src="https://img.shields.io/badge/%20style-google-3666d6.svg">
      </a>
      <a href="https://github.com/astral-sh/ruff">
          <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;">
      </a>
      <a href="https://github.com/guilatrova/tryceratops">
          <img  alt="Doc style: google" src="https://img.shields.io/badge/try%2Fexcept%20style-tryceratops%20%F0%9F%A6%96%E2%9C%A8-black">
      </a>
      <br/>
      <a href="https://pypi.org/project/arctix/">
          <img alt="PYPI version" src="https://img.shields.io/pypi/v/arctix">
      </a>
      <a href="https://pypi.org/project/arctix/">
          <img alt="Python" src="https://img.shields.io/pypi/pyversions/arctix.svg">
      </a>
      <a href="https://opensource.org/licenses/BSD-3-Clause">
          <img alt="BSD-3-Clause" src="https://img.shields.io/pypi/l/arctix">
      </a>
      <br/>
      <a href="https://pepy.tech/project/arctix">
          <img  alt="Downloads" src="https://static.pepy.tech/badge/arctix">
      </a>
      <a href="https://pepy.tech/project/arctix">
          <img  alt="Monthly downloads" src="https://static.pepy.tech/badge/arctix/month">
      </a>
      <br/>
  </p>



  The `arctix` package consists of functionalities to prepare dataset of asynchronous time series.
  It is design to make dataset preparation reusable and reproducible.
  For each dataset, `arctix` provides 3 main functions:

  - `fetch_data` to load the raw data are loaded in
    a [`polars.DataFrame`](https://docs.pola.rs/py-polars/html/reference/dataframe/index.html). When
    possible, it downloads automatically the data.
  - `prepare_data` to prepare the data. It outputs the prepared data
    in [`polars.DataFrame`](https://docs.pola.rs/py-polars/html/reference/dataframe/index.html), and
    the metadata.
  - `to_array` to convert the prepared data to a dictionary of numpy arrays.

  For example, it is possible to use the following lines to download and prepare the MultiTHUMOS data.

  ```pycon

  >>> from pathlib import Path
  >>> from arctix.dataset.multithumos import fetch_data, prepare_data, to_array
  >>> dataset_path = Path("/path/to/dataset/multithumos")
  >>> data_raw = fetch_data(dataset_path)  # doctest: +SKIP
  >>> data, metadata = prepare_data(data_raw)  # doctest: +SKIP
  >>> arrays = to_array(data)  # doctest: +SKIP

  ```

  - [Documentation](https://durandtibo.github.io/arctix/)
  - [Installation](#installation)
  - [Contributing](#contributing)
  - [API stability](#api-stability)
  - [License](#license)



  - [latest (stable)](https://durandtibo.github.io/arctix/): documentation from the latest stable
    release.
  - [main (unstable)](https://durandtibo.github.io/arctix/main/): documentation associated to the
    main branch of the repo. This documentation may contain a lot of work-in-progress/outdated/missing
    parts.



  We highly recommend installing
  a [virtual environment](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).
  `arctix` can be installed from pip using the following command:

  ```shell
  pip install arctix
  ```

  To make the package as slim as possible, only the minimal packages required to use `arctix` are
  installed.
  To include all the packages, you can use the following command:

  ```shell
  pip install arctix[all]
  ```

  Please check the [get started page](https://durandtibo.github.io/arctix/get_started) to see how to
  install only some specific packages or other alternatives to install the library.
  The following is the corresponding `karbonn` versions and dependencies.

  | `batcharray` | `batcharray`   | `coola`        | `iden`           | `numpy`       | `polars`        | `python`      |
  |--------------|----------------|----------------|------------------|---------------|-----------------|---------------|
  | `main`       | `>=0.1,<1.0`   | `>=0.8.4,<1.0` | `">=0.1,<1.0"`   | `>=1.22,<3.0` | `>=1.0,<2.0`    | `>=3.9,<3.14` |
  | `0.0.8`      | `>=0.1,<1.0`   | `>=0.8.4,<1.0` | `">=0.1,<1.0"`   | `>=1.22,<3.0` | `>=1.0,<2.0`    | `>=3.9,<3.14` |
  | `0.0.7`      | `>=0.0.2,<1.0` | `>=0.3,<1.0`   | `">=0.0.3,<1.0"` | `>=1.22,<3.0` | `>=1.0,<2.0`    | `>=3.9,<3.13` |
  | `0.0.6`      | `>=0.0.2,<0.1` | `>=0.3,<1.0`   | `">=0.0.3,<1.0"` | `>=1.22,<2.0` | `>=0.20.0,<1.0` | `>=3.9,<3.13` |
  | `0.0.5`      | `>=0.0.2,<0.1` | `>=0.3,<1.0`   | `">=0.0.3,<1.0"` | `>=1.22,<2.0` | `>=0.20.0,<1.0` | `>=3.9,<3.13` |
  | `0.0.4`      | `>=0.0.2,<0.1` | `>=0.3,<1.0`   | `">=0.0.3,<1.0"` | `>=1.22,<2.0` | `>=0.20.0,<1.0` | `>=3.9,<3.13` |
  | `0.0.3`      | `>=0.0.2,<0.1` | `>=0.3,<1.0`   | `">=0.0.3,<1.0"` | `>=1.22,<2.0` | `>=0.20.0,<1.0` | `>=3.9,<3.13` |



  Please check the instructions in [CONTRIBUTING.md](.github/CONTRIBUTING.md).



  :warning: While `arctix` is in development stage, no API is guaranteed to be stable from one
  release to the next.
  In fact, it is very likely that the API will change multiple times before a stable 1.0.0 release.
  In practice, this means that upgrading `arctix` to a new version will possibly break any code that
  was using the old version of `arctix`.



  `arctix` is licensed under BSD 3-Clause "New" or "Revised" license available in [LICENSE](LICENSE)
  file.


pkgId: caf18a608d8531cfc9d79d10257a52982d9b46bb63a8785af09f2470d38e1a01
name: python-arcusapi
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Arcus Data Platform Client SDK.
url: https://www.arcus.co
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arcusapi-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Install with PyPI (`pip`):

  ```
  pip install arcusapi
  ```

  You can verify your installation by running `import arcus` in Python:

  ```
  $ python
  Python 3.9.16 (main, Feb 28 2023, 06:13:28)
  [Clang 12.0.5 (clang-1205.0.22.9)] on darwin
  Type "help", "copyright", "credits" or "license" for more information.
  >>> import arcus
  ```

  Refer to the Arcus [documentation](https://app.arcus.co/docs/) for more
  information.


pkgId: afb00f9da81a303a3a38dbfcdfb9f115d00bf6f5434ba70babd9850fd4ab6080
name: python-arduino-iot-cloud
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Arduino IoT Cloud Python client
url: https://github.com/arduino/arduino-iot-cloud-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arduino-iot-cloud-1.4.0-1.src.rpm
checksum_type: sha256
description:
  This is a Python client for the Arduino IoT Cloud, which runs on both CPython and MicroPython. The client supports basic and advanced authentication methods, synchronous and asynchronous modes and provides a user-friendly API that allows users to connect to the cloud and create and link local objects to cloud objects with just a few lines of code.


  The following basic example shows how to connect to the Arduino IoT cloud using basic username and password authentication, and control an LED from a dashboard's switch widget.
  ```python
  from secrets import DEVICE_ID
  from secrets import SECRET_KEY


  def on_switch_changed(client, value):
      
      
      
      client["led"] = value




  client = ArduinoCloudClient(device_id=DEVICE_ID, username=DEVICE_ID, password=SECRET_KEY)





  client.register("sw1", value=None, on_write=on_switch_changed)


  client.register("led", value=None)


  client.start()
  ```

  Your `secrets.py` file should look like this:

  ```python
  WIFI_SSID  = ""  # WiFi network SSID (for MicroPython)
  WIFI_PASS  = ""  # WiFi network key  (for MicroPython)
  DEVICE_ID  = "" # Provided by Arduino cloud when creating a device.
  SECRET_KEY = "" # Provided by Arduino cloud when creating a device.
  ```

  Note that by default, the client runs in asynchronous mode. In this mode, the client runs an asyncio loop that updates tasks and records, polls networking events, etc. The client also supports a synchronous mode, which requires periodic client polling. To run the client in synchronous mode, pass `sync_mode=True` when creating a client object and call `client.update()` periodically after connecting. For example:

  ```Python

  client = ArduinoCloudClient(device_id=DEVICE_ID, ..., sync_mode=True)
  ....
  client.register("led", value=None)
  ....

  client.start()


  while True:
      client.update()
      time.sleep(0.100)
  ```

  For more detailed examples and advanced API features, please see the [examples](https://github.com/arduino/arduino-iot-cloud-py/tree/main/examples).


  The client supports basic authentication using a username and password, and the more advanced key/cert pair stored on filesystem or in a crypto device. To test this functionality, the following steps can be used to emulate a crypto device (if one is not available) using SoftHSM on Linux.


  Using the first available slot, in this case 0
  ```bash
  softhsm2-util --init-token --slot 0 --label "arduino" --pin 1234 --so-pin 1234
  ```


  ```bash
  p11tool --provider=/usr/lib/softhsm/libsofthsm2.so --login --set-pin=1234 --write "pkcs11:token=arduino" --load-privkey key.pem --label "Mykey"
  p11tool --provider=/usr/lib/softhsm/libsofthsm2.so --login --set-pin=1234 --write "pkcs11:token=arduino" --load-certificate cert.pem --label "Mykey"
  ```


  This should print the key and certificate
  ```bash
  p11tool --provider=/usr/lib/softhsm/libsofthsm2.so --login --set-pin=1234 --list-all pkcs11:token=arduino

  Object 0:
  	URL: pkcs11:model=SoftHSM%20v2;manufacturer=SoftHSM%20project;serial=841b431f98150134;token=arduino;id=%67%A2%AD%13%53%B1%CE%4F%0E%CB%74%34%B8%C6%1C%F3%33%EA%67%31;object=mykey;type=private
  	Type: Private key (EC/ECDSA)
  	Label: mykey
  	Flags: CKA_WRAP/UNWRAP; CKA_PRIVATE; CKA_SENSITIVE;
  	ID: 67:a2:ad:13:53:b1:ce:4f:0e:cb:74:34:b8:c6:1c:f3:33:ea:67:31

  Object 1:
  	URL: pkcs11:model=SoftHSM%20v2;manufacturer=SoftHSM%20project;serial=841b431f98150134;token=arduino;id=%67%A2%AD%13%53%B1%CE%4F%0E%CB%74%34%B8%C6%1C%F3%33%EA%67%31;object=Mykey;type=cert
  	Type: X.509 Certificate (EC/ECDSA-SECP256R1)
  	Expires: Sat May 31 12:00:00 2053
  	Label: Mykey
  	ID: 67:a2:ad:13:53:b1:ce:4f:0e:cb:74:34:b8:c6:1c:f3:33:ea:67:31
  ```


  When done with the token it can be deleted with the following command:
  ```bash
  softhsm2-util --delete-token --token "arduino"
  ```


  * Set `KEY_PATH`, `CERT_PATH` and `DEVICE_ID` in `examples/example.py`.
  * Provide a CA certificate in a `ca-root.pem` file or set `CA_PATH` to `None` if it's not used.
  * Override the default `pin` and provide `ENGINE_PATH` and `MODULE_PATH` in `ssl_params` if needed.
  * Run the example:
  ```bash
  python examples/example.py
  ```


  MicroPython supports both modes of authentication: basic mode, using a username and password, and mTLS with the key and certificate stored on the filesystem or a secure element (for provisioned boards). To use key and certificate files stored on the filesystem, they must first be converted to DER format. The following commands can be used to convert from PEM to DER:
  ```bash
  openssl ec -in key.pem -out key.der -outform DER
  openssl x509 -in cert.pem -out cert.der -outform DER
  ```

  In this case `KEY_PATH`, `CERT_PATH`, can be set to the key and certificate DER paths, respectively:
  ```Python
  KEY_PATH = "path/to/key.der"
  CERT_PATH = "path/to/cert.der"
  ```

  Alternatively, if the key and certificate are stored on the SE, their URIs can be specified in the following format:
  ```Python
  KEY_PATH = "se05x:token=0x00000064"
  CERT_PATH = "se05x:token=0x00000065"
  ```

  With the key and certificate set, the example can be run with the following command `examples/micropython_advanced.py`



  * [micropython-senml library](https://github.com/micropython/micropython-lib/tree/master/micropython/senml)
  * [micropython-cbor2 library](https://github.com/micropython/micropython-lib/tree/master/python-ecosys/cbor2)
  * [m2crypto](https://github.com/m2crypto/m2crypto)
  * [umqtt.simple](https://github.com/micropython/micropython-lib/tree/master/micropython/umqtt.simple)
  * [openssl docs/man](https://www.openssl.org/docs/man1.0.2/man3/)


pkgId: a2cc9f9320cb6fecdcba8234104f493d3110438af6d4dacfb1691293d0b0ed58
name: python-area
arch: src
version: 1.1.1
epoch: 0
release: 1
url: https://github.com/scisco/area
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-area-1.1.1-1.src.rpm
checksum_type: sha256
summary:
  Calculate the area inside of any GeoJSON geometry. This is a port of Mapbox'sgeojson-area for Python

description:
  Calculate the area inside of any `GeoJSON <http://geojson.org/>`_ geometry. This is a port of Mapbox's `geojson-area <https://github.com/mapbox/geojson-area>`_ for Python.


pkgId: 88d8403be4ed95816ad477ffea693a6d9d7cc234cc570de1332fbcc6271ee26d
name: python-area-under-curve
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: Calculate area under curve
url: https://github.com/smycynek/area_under_curve
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-area-under-curve-1.0.6-1.src.rpm
checksum_type: sha256
description:
  -  Version 1.0.6
  -  Python 3.7+ module to calculate riemann sum area under a curve
  -  Copyright 2019 Steven Mycynek
  -  Supports
     -  simpson, trapezoid, and midpoint algorithms,
     -  n-degree single variable polynomials, including fractional exponents,
     -  variable step size
  -  https://pypi.python.org/pypi/area-under-curve
  ``USAGE = """ -p|--poly {DegreeN1:CoefficientM1, DegreeN2:CoefficientM2, ...}...``
  ``-l|--lower <lower_bound> -u|--upper <upper_bound> -s|--step <step>``
  ``-a|--algorithm <simpson | trapezoid | midpoint>``
  -  | This was just a fun experiment I did on a couple airplane rides and might not be suitable for
       production use.
  -  Try a simple function you can integrate by hand easily, like ``f(x) = x^3`` from ``[0-10]``, and
     compare that to how accurate the midpoint, trapezoid, and simpson approximations are with various
     steps sizes.
  -  Why not use numpy? You probably should, but I wanted to do everything from scratch for fun.


pkgId: 3689ef9e1bd27f909c502c108349d09d6b1cbb0898584c17de1b0585649bae7d
name: python-area4
arch: src
version: 3.11.0
epoch: 0
release: 1
summary: Dividers in Python, the easy way!
url: https://github.com/area4lib/area4
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-area4-3.11.0-1.src.rpm
checksum_type: sha256
description:
  Dividers in Python, the easy way! Many different types. [(As seen on PyPI!)](https://pypi.org/project/area4)

  [![MIT License Badge](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/area4lib/area4/blob/master/LICENSE)
  [![PyPI Project Version](https://badge.fury.io/py/area4.svg)](https://pypi.org/project/area4)
  [![Documentation Status](https://readthedocs.org/projects/area4/badge/?version=latest)](https://area4.readthedocs.io/en/latest/?badge=latest)
  [![Project Status: Active](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
  [![Build Status](https://api.cirrus-ci.com/github/area4lib/area4.svg)](https://cirrus-ci.com/github/area4lib/area4)

  <hr>

  area4 is a flexible Python divider library which doubles as a working emoji database. It makes dividers in console output easy. Don't want to type out `---------` every time you need to use it? We've got you covered.

  <hr>



  For help/troubleshooting see our [support information](https://github.com/area4lib/area4/blob/master/.github/SUPPORT.md).


pkgId: 2406724f04e6b8dcd264254220f2459c8446c3405eb8193a15b774671c31adcd
name: python-areas
arch: src
version: 0.1.9.3
epoch: 0
release: 1
summary: ARM64 and RISC-V (extensible) assessment system
url: https://github.com/luist18/areasear
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-areas-0.1.9.3-1.src.rpm
checksum_type: sha256
description:
  - [1. Installation](#1-installation)
  - [2. Developing](#2-developing)
  - [3. Running](#3-running)
  - [4. Usage](#4-usage)
  - [5. File syntax and structure](#5-file-syntax-and-structure)
    - [5.1. Available data types](#51-available-data-types)
      - [5.1.1. Primitive data types](#511-primitive-data-types)
      - [5.1.2. Array data types](#512-array-data-types)
    - [5.2. subroutines.yaml](#52-subroutinesyaml)
    - [5.3. tests.yaml](#53-testsyaml)
    - [5.4. submission.zip](#54-submissionzip)
  - [6. Results](#6-results)

  Using Docker:
  ```bash
  docker pull luist188/areas
  ```

  To develop the tool you must setup a Docker development environment to ease the dependencies installation and setup an isolated environment.
  1. Build the Docker development image:
     ```bash
     docker build -f Dockerfile.dev -t areas .
     ```
  2. Run the image with the shared folder:
     ```bash
     docker run -it -v $(pwd):/usr/app areas
     ```
  Note: if you are running MacOS with the M1 (or superior) chip you must add `--platform linux/x86_64` to `docker build` and `docker run`.

  1. Place the input files inside any directory.
  2. Run the image with a shared volume pointing to the input directory: `docker run -v input:destination -it luist188/areas` (you can learn more about `docker run` usage [here](https://docs.docker.com/engine/reference/run/))
  3. Run the alias command (assure you are using `/bin/bash`) `areas` or run `python main.py` in the tool's source.

  ```console
  $ areas [-h] -sr SR -t T -sm SM [SM ...] [-gfd GFD] [-ffd FFD] [-grf GRF] [-tout TOUT] [-fpre FPRE]
  $ areas [args]
  Options:
    --help, -h                Show help                                         [boolean]
    -sr <subroutines.yaml>    .yaml file containing subroutine declaration      [required] [string]
    -t <tests.yaml>           .yaml file containing the test cases              [required] [string]
    -sm <submission.zip...>   .zip files containing user submission             [required] [string array]
    -gfd <directory>          path to the directory to store temporary files
      (e.g., compiled binaries)                                                 [default:grading] [string]
    -ffd <directory>          path to the directory to store the grading for
      each submission                                                           [default:feedback] [string]
    -tout <timeout>           float timeout value                               [default:2.0] [float]
    -fpre <precision>         floating point threshold for comparing floating
      points in test cases                                                      [default:1e-6] [float]
  ```



  - `int`
  - `long`
  - `float`
  - `double`
  - `char`
  - `chari` (char represented as an unsgined intenger - similar to char but has to be used when printed characters are not ASCII characters)

  - `char*/string`
  - `array int`
  - `array long`
  - `array float`
  - `array double`
  - `array char`
  - `array chari`

  The input file for the subroutine declaration has to follow a specific structure and syntax described as follows:
  ```yaml
  foo:
    params:
      - int
      - array char
      - array int
      - array int
    return:
      - int
      - array int
  bar:
    params:
      - long
    return:
      - long
  ```
  Each subroutine has an optional parameter to define the subroutine architecture, the syntax is as follows:
  ```yaml
  foo:
    architecture: arm
    params:
      - int
      - array char
      - array int
      - array int
    return:
      - int
      - array int
  ```
  By default, if the architecture parameter is omitted, the system will assume ARM64 as the subroutine architecture. The available architectures are the following:
  - `arm` - ARM64 architecture
  - `riscv` - RISC-V architecture
  The subroutine name has to match the `.s` to test and is case insensitive. Thus, the subroutine `foo` or `bar` is going to check any `.s` file that matches its name case insensitive. All subroutines must contain an array of parameters, `params`, and an array of returns, `return`.

  The input file for the test cases declaration has to follow a specific structure and syntax described as follows:
  ```yaml
  bar:
    - inputs:
      - 6
      outputs:
      - 36
      weight: 0.5
    - inputs:
      - 5
      outputs:
      - 25
      weight: 0.5
  ```
  The root declaration of a test case must match the name declared in the `subroutines.yaml` file. Test cases have an array of inputs that has a list of outputs and a test weight. The sum of the test weights must be 1.0.

  The submission `zip` file must contain a `.s` file in its root. For example, for the subroutine `foo` and `bar` the `zip` structure should be as follows:
  ```tree
  submission.zip
  ├── foo.s
  └── bar.s
  ```

  For each submission file a `.json` file is created in the feedback directory with the same name of the `.zip` file. The file contains all information about compilation status and test cases. In addition, a simplified version of the result of all submissions is created in a `result.json`. The content of the files look as follows:
  File **submission.json**
  ```json
  [
      {
          "name": "foo",
          "compiled": true,
          "ok": true,
          "passed_count": 2,
          "test_count": 2,
          "score": 1,
          "tests": [
              {
                  "weight": 1,
                  "run": true,
                  "input": [
                      6,
                      ["-", "+", "+", "-", "-", "+"],
                      [1, 2, 3, 0, 1, -25],
                      [13, 2, 8, 4, 5, 25]
                  ],
                  "output": [
                      "0",
                      ["12", "4", "11", "4", "4", "0"]
                  ],
                  "passed": true
              }
          ]
      },
      {
          "name": "bar",
          "compiled": true,
          "ok": true,
          "passed_count": 2,
          "test_count": 2,
          "score": 1,
          "tests": [
              {
                  "weight": 0.5,
                  "run": true,
                  "input": [
                      6
                  ],
                  "output": [
                      "36"
                  ],
                  "passed": true
              },
              {
                  "weight": 0.5,
                  "run": true,
                  "input": [
                      5
                  ],
                  "output": [
                      "25"
                  ],
                  "passed": true
              }
          ]
      }
  ]
  ```
  File **result.json**
  ```json
  [
      {
          "submission_name": "submission",
          "subroutines": [
              {
                  "name": "foo",
                  "score": 0
              },
              {
                  "name": "bar",
                  "score": 0.5
              }
          ]
      },
      {
          "submission_name": "submission2",
          "subroutines": [
              {
                  "name": "foo",
                  "score": 1
              },
              {
                  "name": "bar",
                  "score": 1
              }
          ]
      }
  ]
  ```

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


pkgId: 4e005ab670e85947184c282003b218273bdbd7ff0ff1c85163e674a8ea1cc29d
name: python-areixlib
arch: src
version: 0.1.28
epoch: 0
release: 1
summary: Areix Utils Library
url: https://alphagen.areix-ai.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-areixlib-0.1.28-1.src.rpm
checksum_type: sha256
description:
  Create a virtual environment
  ```
  virtualenv venv --python=python3
  ```
  Activate the virtual environment
  ```python

  source venv/bin/activate


  venv/Scripts/activate
  ```
  Deactivate
  ```
  deactivate
  ```
  Install areixlib package
  ```
  pip install areixlib
  ```


pkgId: 9a775682f30bd7fe5a7204e493916878b8fd0267463f8f708051b72243614575
name: python-arel
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Browser hot reload for Python ASGI web apps
url: https://github.com/florimondmanca/arel
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arel-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://dev.azure.com/florimondmanca/public/_apis/build/status/florimondmanca.arel?branchName=master)](https://dev.azure.com/florimondmanca/public/_build/latest?definitionId=6&branchName=master)
  [![Coverage](https://codecov.io/gh/florimondmanca/arel/branch/master/graph/badge.svg)](https://codecov.io/gh/florimondmanca/arel)
  ![Python versions](https://img.shields.io/pypi/pyversions/arel.svg)
  [![Package version](https://badge.fury.io/py/arel.svg)](https://pypi.org/project/arel)

  Browser hot reload for Python ASGI web apps.

  ![](https://media.githubusercontent.com/media/florimondmanca/arel/master/docs/demo.gif)



  **What is this for?**

  `arel` can be used to implement development-only hot-reload for non-Python files that are not read from disk on each request. This may include HTML templates, GraphQL schemas, cached rendered Markdown content, etc.

  **How does it work?**

  `arel` watches changes over a set of files. When a file changes, `arel` notifies the browser (using WebSocket), and an injected client script triggers a page reload. You can register your own reload hooks for any extra server-side operations, such as reloading cached content or re-initializing other server-side resources.



  ```bash
  pip install 'arel==0.3.*'
  ```



  _For a working example using Starlette, see the [Example](#example) section._

  Although the exact instructions to set up hot reload with `arel` depend on the specifics of your ASGI framework, there are three general steps to follow:

  1. Create an `HotReload` instance, passing one or more directories of files to watch, and optionally a list of callbacks to call before a reload is triggered:

     ```python
     import arel

     async def reload_data():
         print("Reloading server data...")

     hotreload = arel.HotReload(
         paths=[
             arel.Path("./server/data", on_reload=[reload_data]),
             arel.Path("./server/static"),
         ],
     )
     ```

  2. Mount the hot reload endpoint, and register its startup and shutdown event handlers. If using Starlette, this can be done like this:

     ```python
     from starlette.applications import Starlette
     from starlette.routing import WebSocketRoute

     app = Starlette(
         routes=[WebSocketRoute("/hot-reload", hotreload, name="hot-reload")],
         on_startup=[hotreload.startup],
         on_shutdown=[hotreload.shutdown],
     )
     ```

  3. Add the JavaScript code to your website HTML. If using [Starlette with Jinja templates](https://www.starlette.io/templates/), you can do this by updating the global environment, then injecting the script into your base template:

     ```python
     templates.env.globals["DEBUG"] = os.getenv("DEBUG")  # Development flag.
     templates.env.globals["hotreload"] = hotreload
     ```

     ```jinja
     <body>
       <!-- Page content... -->

       <!-- Hot reload script -->
       {% if DEBUG %}
         {{ hotreload.script(url_for('hot-reload')) | safe }}
       {% endif %}
     </body>
     ```



  The [`example` directory](https://github.com/florimondmanca/arel/tree/master/example) contains an example Markdown-powered website that uses `arel` to refresh the browser when Markdown content or HTML templates change.



  MIT



  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).





  - Use `watchfiles` instead of `watchgod`. This unlocks Python 3.12 support. (Pull #34)



  - Add support for Python 3.12. (Pull #35)





  - Add support for watching multiple directories, each with its own reload callbacks. (Pull #15)



  - `arel.HotReload("./directory", on_reload=[...])` should now be written as `arel.HotReload(paths=[arel.Path("./directory", on_reload=[...])])`. (Pull #15)



  _Initial release._



  - Add `HotReload` ASGI application class. (Pull #1)


pkgId: ed910a89f5c93d60b37d4aa84b7439fcbd70a10d03bbcc2476d576bbae93432f
name: python-arelle-release
arch: src
version: 2.35.7
epoch: 0
release: 1
summary: An open source XBRL platform.
url: https://arelle.org/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arelle-release-2.35.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/arelle-release)](https://pypi.org/project/arelle-release/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/arelle-release)](https://pypi.org/project/arelle-release/)
  [![Read the Docs](https://img.shields.io/readthedocs/arelle)](https://arelle.readthedocs.io/)

  [![Arelle Banner](https://arelle.org/arelle/wp-content/themes/platform/images/logo-platform.png)](https://arelle.org/)



  - [Arelle](#arelle)
    - [Table of Contents](#table-of-contents)
    - [Description](#description)
    - [Documentation](#documentation)
    - [Features](#features)
    - [Need Support?](#need-support)
      - [Arelle Within Other Products](#arelle-within-other-products)
      - [EDGAR or EFM Validations](#edgar-or-efm-validations)
      - [Installing or Running Arelle](#installing-or-running-arelle)
      - [Bug Report or Feature Request](#bug-report-or-feature-request)
      - [Security Vulnerabilities](#security-vulnerabilities)
      - [How-To and General XBRL Questions](#how-to-and-general-xbrl-questions)
      - [Email](#email)
    - [How To Contribute](#how-to-contribute)
    - [👥 Contributors](#-contributors)
    - [License](#license)



  Arelle is an end-to-end open source XBRL platform, which provides the XBRL community
  with an easy to use set of tools. It supports XBRL and its extension features in
  an extensible manner. It does this in a compact yet robust framework that can be
  used as a desktop application and can be integrated with other applications and
  languages utilizing its web service, command line interface, and Python API.



  Need help with Arelle? Go check out [our documentation][read-the-docs].

  [read-the-docs]: https://arelle.readthedocs.io/



  - Fully-featured XBRL processor with GUI, CLI, Python API and Web Service API.
  - Support for the XBRL Standard, including:
    - XBRL v2.1 and XBRL Dimensions v1.0
    - XBRL Formula v1.0
    - Taxonomy Packages v1.0
    - xBRL-JSON v1.0 and xBRL-CSV v1.0
    - Inline XBRL v1.1
    - Units Registry v1.0
  - Certified by XBRL International as a [Validating Processor][certification].
  - Support for filing programme validation rules:
    - Edgar Filer Manual validation (US SEC)
    - ESEF Reporting Manual (EU)
    - HMRC (UK)
    - CIPC (South Africa)
    - FERC (US Federal Energy Regulatory Commission)
  - Integrated support for [Arelle Inline XBRL Viewer][viewer].
  - Extensible plugin architecture.
  - Support for XF text-based Formula and XULE validation rules.
  - The Web Service API allows XBRL integration with applications, such as those in
    Excel, Java or Oracle.
  - Instance creation is supported using forms defined by the table linkbase.
  - Support for reading/monitoring US SEC XBRL RSS feeds (RSS Watch).

  [viewer]: https://github.com/Arelle/ixbrl-viewer
  [certification]: https://software.xbrl.org/processor/arelle-arelle



  Whether you've found a bug, need help with installation, have a feature request,
  or want to know how to use Arelle, we can help! Here's a quick guide:

  When reporting issues it's important to include as much information as possible:

  - what version of Arelle are you using?
  - how are you using Arelle (GUI, command line, web server, or the Python API?)
  - what operating system (Windows, macOS, Ubuntu, etc.) are you using?
  - what plugins if any do you have enabled?
  - can you provide an XBRL report that recreates the issue?
  - what's the diagnostics output (`arelleCmdLine.exe --diagnostics`) on your system?



  A number of service providers embed Arelle within their XBRL products and tools.
  If you're having an issue with Arelle within one of these offerings please
  contact the developer of that tool for support or first verify that you have the
  same issue when using Arelle directly. Most issues in these situations are caused
  by the tool using an old version of Arelle or not running a valid command.



  The SEC develops and maintains the EDGAR plugins. Please report issues with these
  plugins directly to the SEC (<StructuredData@sec.gov>).



  Most installation and startup issues can be resolved by downloading the latest version
  of Arelle and performing a [clean install][clean-install]. If that doesn't resolve
  the problem for you, please [report a bug](#bug-report-or-feature-request).

  [clean-install]: https://arelle.readthedocs.io/en/latest/install.html#clean-install



  Please use the GitHub [issue tracker][github-issue-tracker] if you'd like to suggest
  a new feature or report a bug.

  Before opening a new issue, please:

  - Check that the issue has not already been reported.
  - Check that the issue has not already been fixed in the latest release.
  - Be clear and precise (do not prose, but name functions and commands exactly).
  - For bug reports include the version of Arelle you're using.

  [github-issue-tracker]: https://github.com/Arelle/Arelle/issues



  Identified a security concern? Email the Arelle team (<Support@arelle.org>) so we
  can resolve the issue and make sure service providers and authorities who use Arelle
  in production are prepared to update and apply security patches before notifying
  the general public.



  Have a question that isn't covered by the [documentation](#documentation)?
  Join our [Arelle Google Group][google-group] and start a conversation with the Arelle
  team and community of experts.



  The Arelle team can also be reached by email (<Support@arelle.org>) for issues that
  aren't a good fit for the other support channels. However, please note that you will
  likely receive a faster response if you [open a GitHub issue][new-github-issue]
  or start a new conversation in the [Arelle Google Group][google-group] where the
  Arelle team is active and other people within the community can also see and respond
  to your message.

  [google-group]: https://groups.google.com/g/arelle-users
  [new-github-issue]: https://github.com/Arelle/Arelle/issues/new/choose



  Interested in contributing to Arelle? Awesome! Make sure to review our
  [contribution guidelines][contribution guidelines].

  [contribution guidelines]: https://arelle.readthedocs.io/en/latest/contributing.html



  <div align="center">
    <a href="https://github.com/Arelle/Arelle/graphs/contributors">
      <img src="https://contrib.rocks/image?repo=Arelle/Arelle&max=100&columns=10" style="margin: 5px;" />
    </a>
    <p>Join our community and become a contributor today! 🚀 </p>
  </div>



  [Apache License 2.0][license]

  [license]: https://arelle.readthedocs.io/en/latest/license.html


pkgId: 7f512d38e61b3238acb0cbf1fb74f53209110ab4d90172cd757a98461dcf0acd
name: python-aresponses
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Asyncio response mocking. Similar to the responses library used for 'requests'
url: https://github.com/aresponses/aresponses
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aresponses-3.0.0-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/aresponses.svg)](https://pypi.org/project/aresponses/)
  [![image](https://img.shields.io/pypi/pyversions/aresponses.svg)](https://pypi.org/project/aresponses/)
  [![build status](https://github.com/CircleUp/aresponses/workflows/Python%20Checks/badge.svg)](https://github.com/CircleUp/aresponses/actions?query=branch%3Amaster)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)


  an asyncio testing server for mocking external services


   - Fast mocks using actual network connections
   - allows mocking some types of network issues
   - use regular expression matching for domain, path, method, or body
   - works with https requests as well (by switching them to http requests)
   - works with callables



  Add routes and responses via the `aresponses.add` method:

  ```python
  def add(
      host_pattern=ANY,
      path_pattern=ANY,
      method_pattern=ANY,
      response="",
      *,
      route=None,
      body_pattern=ANY, m
      match_querystring=False,
      repeat=1
      )
  ```

  When a request is received the first matching response will be returned
  and removed from the routing table.  The `response` argument can be
  either a string, Response, dict, or list.  Use `aresponses.Response`
  when you need to do something more complex.


  **Note that version >=2.0 requires explicit assertions!**
  ```python
  @pytest.mark.asyncio
  async def test_simple(aresponses):
      aresponses.add("google.com", "/api/v1/", "GET", response="OK")
      aresponses.add('foo.com', '/', 'get', aresponses.Response(text='error', status=500))

      async with aiohttp.ClientSession() as session:
          async with session.get("http://google.com/api/v1/") as response:
              text = await response.text()
              assert text == "OK"

          async with session.get("https://foo.com") as response:
              text = await response.text()
              assert text == "error"

      aresponses.assert_plan_strictly_followed()
  ```


  In aresponses 1.x requests that didn't match a route stopped the event
  loop and thus forced an exception.  In aresponses >2.x it's required to
  make assertions at the end of the test.

  There are three assertions functions provided:
  - `aresponses.assert_no_unused_routes` Raises `UnusedRouteError` if all
  the routes defined were not used up.
  - `aresponses.assert_called_in_order` - Raises `UnorderedRouteCallError`
  if the routes weren't called in the order they were defined.
  - `aresponses.assert_all_requests_matched` - Raises `NoRouteFoundError`
  if any requests were made that didn't match to a route.  It's likely
  but not guaranteed that your code will throw an exception in this
  situation before the assertion is reached.

  Instead of calling these individually, **it's recommended to call
  `aresponses.assert_plan_strictly_followed()` at the end of each test as
  it runs all three of the above assertions.**



  `host_pattern`, `path_pattern`, `method_pattern` and `body_pattern` may
  be either strings (exact match) or regular expressions.

  The repeat argument permits a route to be used multiple times.

  If you want to just blanket mock a service, without concern for how many
  times its called you could set repeat to a large number and not call
  `aresponses.assert_plan_strictly_followed` or
  `arespones.assert_no_unused_routes`.

  ```python
  @pytest.mark.asyncio
  async def test_regex_repetition(aresponses):
      aresponses.add(re.compile(r".*\.?google\.com"), response="OK", repeat=2)

      async with aiohttp.ClientSession() as session:
          async with session.get("http://google.com") as response:
              text = await response.text()
              assert text == "OK"

          async with session.get("http://api.google.com") as response:
              text = await response.text()
              assert text == "OK"

      aresponses.assert_plan_strictly_followed()
  ```


  As a convenience, if a dict or list is passed to `response` then it will
  create a json response. A `aiohttp.web_response.json_response` object
  can be used for more complex situations.

  ```python
  @pytest.mark.asyncio
  async def test_json(aresponses):
      aresponses.add("google.com", "/api/v1/", "GET", response={"status": "OK"})

      async with aiohttp.ClientSession() as session:
          async with session.get("http://google.com/api/v1/") as response:
              assert {"status": "OK"} == await response.json()

      aresponses.assert_plan_strictly_followed()
  ```



  Custom functions can be used for whatever other complex logic is
  desired. In example below the handler is set to repeat infinitely
  and always return 500.

  ```python
  import math

  @pytest.mark.asyncio
  async def test_handler(aresponses):
      def break_everything(request):
          return aresponses.Response(status=500, text=str(request.url))

      aresponses.add(response=break_everything, repeat=math.inf)

      async with aiohttp.ClientSession() as session:
          async with session.get("http://google.com/api/v1/") as response:
              assert response.status == 500
  ```



  Pass `aresponses.passthrough` into the response argument to allow a
  request to bypass mocking.

  ```python
      aresponses.add('httpstat.us', '/200', 'get', aresponses.passthrough)
  ```


  History of calls can be inspected via `aresponses.history` which returns
  the namedTuple `RoutingLog(request, route, response)`

  ```python
  @pytest.mark.asyncio
  async def test_history(aresponses):
      aresponses.add(response=aresponses.Response(text="hi"), repeat=2)

      async with aiohttp.ClientSession() as session:
          async with session.get("http://foo.com/b") as response:
              await response.text()
          async with session.get("http://bar.com/a") as response:
              await response.text()

      assert len(aresponses.history) == 2
      assert aresponses.history[0].request.host == "foo.com"
      assert aresponses.history[1].request.host == "bar.com"
      assert "Route(" in repr(aresponses.history[0].route)
      aresponses.assert_plan_strictly_followed()
  ```


  ```python
  import aiohttp
  import pytest
  import aresponses


  @pytest.mark.asyncio
  async def test_foo(event_loop):
      async with aresponses.ResponsesMockServer(loop=event_loop) as arsps:
          arsps.add('foo.com', '/', 'get', 'hi there!!')
          arsps.add(arsps.ANY, '/', 'get', arsps.Response(text='hey!'))

          async with aiohttp.ClientSession(loop=event_loop) as session:
              async with session.get('http://foo.com') as response:
                  text = await response.text()
                  assert text == 'hi'

              async with session.get('https://google.com') as response:
                  text = await response.text()
                  assert text == 'hey!'

  ```



  If you need to use aresponses together with pytest-aiohttp, you should re-initialize main aresponses fixture with `loop` fixture
  ```python
  from aresponses import ResponsesMockServer

  @pytest.fixture
  async def aresponses(loop):
      async with ResponsesMockServer(loop=loop) as server:
          yield server
  ```

  If you're trying to use the `aiohttp_client` test fixture then you'll need to mock out the aiohttp `loop` fixture
  instead:
  ```python
  @pytest.fixture
  def loop(event_loop):
      """replace aiohttp loop fixture with pytest-asyncio fixture"""
      return event_loop
  ```




    - **install pyenv and pyenv-virtualenv**  - Makes it easy to install specific versions of python and switch between them. Make sure you install the virtualenv bash hook
    - `git clone` the repo and `cd` into it.
    - `make init` - installs proper version of python, creates the virtual environment, activates it and installs all the requirements


    - **`git checkout -b my-feature-branch`**
    - **make some cool changes**
    - **`make autoformat`**
    - **`make test`**
    - **`make lint`**
    - **create pull request**


    - `make deploy`





  - fix: start using `asyncio.get_running_loop()` instead of `event_loop` per the error:
      ```
      PytestDeprecationWarning: aresponses is asynchronous and explicitly requests the "event_loop" fixture.
      Asynchronous fixtures and test functions should use "asyncio.get_running_loop()" instead.
      ```
  - drop support for python 3.6
  - add comprehensive matrix testing of all supported python and aiohttp versions
  - tighten up the setup.py requirements


  - fix: incorrect pytest plugin entrypoint name (#72)


  - support asyncio_mode = strict (#68)


  - fix: don't assume utf8 request contents


  - accidental no-op release


  - documentation: add pypi documentation



  - bugfix: RecursionError when aresponses is used in more than 1000 tests (#63)


  - feature: add convenience method `add_local_passthrough`
  - bugfix: fix https subrequest mocks. support aiohttp_client compatibility


  - bugfix: ensure request body is available in history


  **Warning! Breaking Changes!**
  - breaking change: require explicit assertions for test failures
  - feature: autocomplete works in intellij/pycharm
  - feature: can match on body of request
  - feature: store calls made
  - feature: repeated responses
  - bugfix: no longer stops event loop
  - feature: if dict or list is passed into `response`, a json response
  will be generated



  - make passthrough feature work with binary data


  - regex fix for Python 3.7.0


  - Added passthrough option to permit live network calls
  - Added example of using a callable as a response



  - Added an optional `match_querystring` argument that lets you match on querystring as well



  * Bryce Drennan, CircleUp <aresponses@brycedrennan.com>
  * Marco Castelluccio, Mozilla <mcastelluccio@mozilla.com>
  * Jesse Vogt, CircleUp <jesse.vogt@gmail.com>
  * Pavol Vargovcik, Kiwi.com <pavol.vargovcik@gmail.com>


pkgId: 4d6c519588369910aa91da71f2c897abcb1e287bf352bede96863af85d589914
name: python-arff
arch: src
version: 0.9
epoch: 0
release: 1
summary: Python package for reading and writing Weka arff files
url: http://code.google.com/p/arff/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arff-0.9-1.src.rpm
checksum_type: sha256
description:
      >>> data = [[1,2,'a'], [3, 4, 'john']]
      >>> arff.dump('result.arff', data, relation="whatever", names=['num', 'day', 'title'])
  results in the creation of this file:
  @relation whatever
  @attribute num integer
  @attribute day integer
  @attribute title string
  @data
  1,2,'a'


pkgId: 402de54380b4a1815975243ddc838790360c49a4c54b782e67646d1933732b1b
name: python-arfs
arch: src
version: 2.3.2
epoch: 0
release: 1
summary: All Relevant Feature Selection and Maximal Relevant minimal redundancy FS
url: https://pypi.org/project/arfs/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arfs-2.3.2-1.src.rpm
checksum_type: sha256
description:
  <img src="logo.png" alt="drawing" width="200"/>

  [buy me caffeine](https://ko-fi.com/V7V72SOHX)

  [![PyPI version](https://badge.fury.io/py/arfs.svg)](https://badge.fury.io/py/arfs) [![Downloads](https://static.pepy.tech/personalized-badge/arfs?period=total&units=international_system&left_color=grey&right_color=yellow&left_text=Downloads)](https://pepy.tech/project/arfs) [![Documentation Status](https://readthedocs.org/projects/arfs/badge/?version=latest)](https://arfs.readthedocs.io/en/latest/?badge=latest) [![Code Style](https://img.shields.io/badge/code%20style-black-black)](https://img.shields.io/badge/code%20style-black-black)


  [ARFS readthedocs](https://arfs.readthedocs.io/en/latest/#)



  All relevant feature selection means trying to find all features carrying information usable for prediction, rather than finding a possibly compact subset of features on which some particular model has a minimal error. This might include redundant predictors. All relevant feature selection is model agnostic in the sense that it doesn't optimize a scoring function for a *specific* model but rather tries to select all the predictors which are related to the response.

  This package implements 3 different methods (Leshy is an evolution of Boruta, BoostAGroota is an evolution of BoostARoota and GrootCV is a new one). They are sklearn compatible. See hereunder for details about those methods. You can use any sklearn compatible estimator with Leshy and BoostAGroota but I recommend lightGBM. It's fast, accurate and has SHAP values builtin. It also provides a module for performing preprocessing and perform basic feature selection (autobinning, remove columns with too many missing values, zero variance, high-cardinality, highly correlated, etc.). Examples and detailled methods hereunder.

  Moreover, as an alternative to the all relevant problem, the ARFS package provides a MRmr feature selection which, theoretically, returns a subset of the predictors selected by an arfs method. ARFS also provides a `LASSO` feature selection which works especially well for (G)LMs and GAMs. You can combine Lasso with the `TreeDiscretizer` for introducing non-linearities into linear models and perform feature selection.

  Please note that one limitation of the lasso is that it treats the levels of a categorical predictor individually. However, this issue can be addressed by utilizing the `TreeDiscretizer`, which automatically bins numerical variables and groups the levels of categorical variables.



  `$ pip install arfs`

  REM: If you're interested in using the `fastshap` option, you'll need to install [fasttreeshap](https://github.com/linkedin/FastTreeSHAP) first. For a smooth installation process, I suggest using `conda install -c conda-forge fasttreeshap` since the c++ source code requires compilation. Using pip may involve additional dependencies, such as requiring VS for compiling the c++ code.



  Working examples for:

   - [Preprocessing](./docs/notebooks/preprocessingipynb)
   - [Basic FS (best before ARFS)](./docs/notebooks/basic_feature_selection.ipynb)
   - [Regression](./docs/notebooks/arfs_regression.ipynb)
   - [Classification](./docs/notebooks/arfs_classification.ipynb)
   - [LASSO and (G)LM feature selection](./docs/notebooks/lasso_feature_selection.ipynb)
   - [Passing custom params](./docs/notebooks/arfs_grootcv_custom_params.ipynb)
   - [Non-normal loss and sample weights](./docs/notebooks/arfs_non_normal_loss_and_sample_weight.ipynb)
   - [ARFS on GPU](./docs/notebooks/arfs_on_GPU.ipynb)
   - [Fast Shap](./docs/notebooks/arfs_shap_vs_fastshap.ipynb)
   - [Categoricals](./docs/notebooks/issue_categoricals.ipynb)
   - [Collinearity](./docs/notebooks/issue_collinearity.ipynb)
   - [Reducing run time for large data](./docs/notebooks/arfs_large_data_sampling.ipynb)
   - [Comparison to Boruta and BorutaShap](./docs/notebooks/arfs_boruta_borutaShap_comparison.ipynb)
   - [MRmr alternative](./docs/notebooks/mrmr_feature_selection.ipynb)
   - [MRmr vs ARFS](./docs/notebooks/mrmr_fs_VS_arfs.ipynb)

  For imbalanced classification:
   - GrootCV will automatically detect imbalanced data and set the lightGBM `'is_unbalance' = True`
   - For Leshy and BoostAGroota, you can pass the estimator with the relevant parameter (e.g. `class_weight = 'balanced'`)





  The Boruta algorithm tries to capture all the important features you might have in your dataset with respect to an outcome variable. The procedure is the following:

   * Create duplicate copies of all independent variables. When the number of independent variables in the original data is less than 5, create at least 5 copies using existing variables.
   * Shuffle the values of added duplicate copies to remove their correlations with the target variable. It is called shadow features or permuted copies.
   * Combine the original ones with shuffled copies
   * Run a random forest classifier on the combined dataset and performs a variable importance measure (the default is Mean Decrease Accuracy) to evaluate the importance of each variable where higher means more important.
   * Then Z score is computed. It means mean of accuracy loss divided by the standard deviation of accuracy loss.
   * Find the maximum Z score among shadow attributes (MZSA)
   * Tag the variables as 'unimportant' when they have importance significantly lower than MZSA. Then we permanently remove them from the process.
   * Tag the variables as 'important' when they have importance significantly higher than MZSA.
   * Repeat the above steps for a predefined number of iterations (random forest runs), or until all attributes are either tagged 'unimportant' or 'important', whichever comes first.

  At every iteration, the algorithm compares the Z-scores of the shuffled copies of the features and the original features to see if the latter performed better than the former. If it does, the algorithm will mark the feature as important. In essence, the algorithm is trying to validate the importance of the feature by comparing with randomly shuffled copies, which increases the robustness. This is done by simply comparing the number of times a feature did better with the shadow features using a binomial distribution. Since the whole process is done on the same train-test split, the variance of the variable importance comes only from the different re-fit of the model over the different iterations.




  BoostARoota follows closely the Boruta method but modifies a few things:

   * One-Hot-Encode the feature set
   * Double width of the data set, making a copy of all features in the original dataset
   * Randomly shuffle the new features created in (2). These duplicated and shuffled features are referred to as "shadow features"
   * Run XGBoost classifier on the entire data set ten times. Running it ten times allows for random noise to be smoothed, resulting in more robust estimates of importance. The number of repeats is a parameter than can be changed.
   * Obtain importance values for each feature. This is a simple importance metric that sums up how many times the particular feature was split on in the XGBoost algorithm.
   * Compute "cutoff": the average feature importance value for all shadow features and divide by four. Shadow importance values are divided by four (parameter can be changed) to make it more difficult for the variables to be removed. With values lower than this, features are removed at too high of a rate.
   * Remove features with average importance across the ten iterations that is less than the cutoff specified in (6)
   * Go back to (2) until the number of features removed is less than ten per cent of the total.
   * Method returns the features remaining once completed.

  In the spirit, the same heuristic than Boruta but using Boosting (originally Boruta was supporting only random forest). The validation of the importance is done by comparing to the maximum of the median var. imp of the shadow predictors (in Boruta, a statistical test is performed using the Z-score). Since the whole process is done on the same train-test split, the variance of the variable importance comes only from the different re-fit of the model over the different iterations.



   I forked both Boruta and BoostARoota and made the following changes (under PR):

  **Boruta --> Leshy**:

    - The categorical features (they are detected, encoded. The tree-based models are working better with integer encoding rather than with OHE, which leads to deep and unstable trees). If Catboost is used, then the cat.pred (if any) are set up
    - Using lightGBM as the default speeds up by an order of magnitude the running time
    - Work with Catboost, sklearn API
    - Allow using sample_weight, for applications like Poisson regression or any requiring weights
    - Supports 3 different feature importances: native, SHAP and permutation. Native being the least consistent(because of the imp. biased towards numerical and large cardinality categorical) but the fastest of the 3. Indeed, the impurity var.imp. are biased en sensitive to large cardinality (see [scikit demo](https://scikit-learn.org/stable/auto_examples/inspection/plot_permutation_importance.html#sphx-glr-auto-examples-inspection-plot-permutation-importance-py))

  **BoostARoota --> BoostAGroota**:

    - Replace XGBoost with LightGBM, you can still use tree-based scikitlearn models
    - Replace native var.imp by SHAP var.imp. Indeed, the impurity var.imp. are biased en sensitive to large cardinality (see [scikit demo](https://scikit-learn.org/stable/auto_examples/inspection/plot_permutation_importance.html#sphx-glr-auto-examples-inspection-plot-permutation-importance-py)). Moreover, the native var. imp are computed on the train set, here the data are split (internally) in train and test, var. imp computed on the test set.
    - Handling categorical predictors. Cat. predictors should NOT be one-hot encoded, it leads to deep unstable trees. Instead, it's better to use the native method of lightGBM or CatBoost. A preprocessing step is needed to encode (ligthGBM and CatBoost use integer encoding and reference to categorical columns. The splitting strategies are different then, see official doc).
    - Work with sample_weight, for Poisson or any application requiring a weighting.



  **New: GrootCV**:

    - Cross-validated feature importance to smooth out the noise, based on lightGBM only (which is, most of the time, the fastest and more accurate Boosting).
    - the feature importance is derived using SHAP importance
    - Taking the max of the median of the shadow var. imp over folds otherwise not enough conservative and it improves the convergence (needs less evaluation to find a threshold)
    - Not based on a given percentage of cols needed to be deleted
    - Plot method for var. imp




  **Theory**

   - [Consistent feature selection for pattern recognition in polynomial time](https://www.jmlr.org/papers/volume8/nilsson07a/nilsson07a.pdf)
   - [Maximum Relevance and Minimum Redundancy Feature Selection Methods for a Marketing Machine Learning Platform](https://eng.uber.com/research/maximum-relevance-and-minimum-redundancy-feature-selection-methods-for-a-marketing-machine-learning-platform/)

  **Applications**

   - [The Boruta paper](https://www.jstatsoft.org/article/view/v036i11/v36i11.pdf)
   - [The python implementation](https://github.com/scikit-learn-contrib/boruta_py)
   - [BoostARoota](https://github.com/chasedehan/BoostARoota)


pkgId: 7e37d7b31f0aa4f28cf150d353c02ce819107211a8e15b25944c8ad7e7823261
name: python-arfx
arch: src
version: 2.6.16
epoch: 0
release: 1
summary: Advanced Recording Format Tools
url: https://github.com/melizalab/arfx
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arfx-2.6.16-1.src.rpm
checksum_type: sha256
description:
  |ProjectStatus|_ |Version|_ |BuildStatus|_ |License|_ |PythonVersions|_
  **arfx** is a family of commandline tools for copying sampled data in
  and out of ARF containers. ARF (https://github.com/melizalab/arf) is an
  open, portable file format for storing behavioral and neural data, based
  on `HDF5 <http://www.hdfgroup.org/HDF5>`__.
  installation
  ~~~~~~~~~~~~
     pip install arfx
  or from source:
     python setup.py install
  usage
  ~~~~~
  The general syntax is ``arfx operation [options] files``. The syntax is
  similar to ``tar``. Operations are as follows:
  -  **-A:** copy data from one container to another
  -  **-c:** create a new container
  -  **-r:** append data to the container
  -  **-t:** list contents of the container
  -  **-x:** extract entries from the container
  -  **-d:** delete entries from the container
  Options specify the target ARF file, verbosity, automatic naming
  schemes, and any metadata to be stored in the entry.
  -  **-f FILE:** use ARF file FILE
  -  **-v:** verbose output
  -  **-n NAME:** name entries sequentially, using NAME as the base
  -  **-a ANIMAL:** specify the animal
  -  **-e EXPERIMENTER:** specify the experimenter
  -  **-p PROTOCOL:** specify the protocol
  -  **-s HZ:** specify the sampling rate of the data, in Hz
  -  **-T DATATYPE:** specify the type of data
  -  **-u:** do not compress data in the arf file
  -  **-P:** when deleting entries, do not repack
  input files
  **arfx** can read sampled data from ``pcm``, ``wave``, ``npy`` and
  ``mda`` files. Support for additional file formats can be added as
  plugins (see 4).
  When adding data to an ARF container (``-c`` and ``-r`` modes), the
  input files are specified on the command line, and added in the order
  given. By default, entries are given the same name as the input file,
  minus the extension; however, if the input file has more than one entry,
  they are given an additional numerical extension. To override this, the
  ``-n`` flag can be used to specify the base name; all entries are given
  sequential names based on this.
  The ``-n, -a, -e, -p, -s, -T`` options are used to store information
  about the data being added to the file. The DATATYPE argument can be the
  numerical code or enumeration code (run ``arfx --help-datatypes`` for a
  list), and indicates the type of data in the entries. All of the entries
  created in a single run of arfx are given these values. The ``-u``
  option tells arfx not to compress the data, which can speed up I/O
  operations slightly.
  Currently only one sampled dataset per entry is supported. Clearly this
  does not encompass many use cases, but **arfx** is intended as a simple
  tool. More specialized import procedures can be easily written in Python
  using the ``arf`` library.
  output files
  The entries to be extracted (in ``-x`` mode) can be specified by name.
  If no names are specified, all the entries are extracted. All sampled
  datasets in each entry are extracted as separate channels, because they
  may have different sampling rates. Event datasets are not extracted.
  By default the output files will be in ``wave`` format and will have
  names with the format ``entry_channel.wav``. The ``-n`` argument can be
  used to customize the names and file format of the output files. The
  argument must be a template in the format defined by the `python string
  module <http://docs.python.org/library/string.html###format-specification-mini-language>`__.
  Supported field names include ``entry``, ``channel``, and ``index``, as
  well as the names of any HDF5 attributes stored on the entry or channel.
  The extension of the output template is used to determine the file
  format. Currently only ``wave`` is supported, but additional formats may
  be supplied as plugins (see 4).
  The metadata options are ignored when extracting files; any metadata
  present in the ARF container that is also supported by the target
  container is copied.
  other operations
  As with ``tar``, the ``-t`` operation will list the contents of the
  archive. Each entry/channel is listed on a separate line in path
  notation.
  The ``-A`` flag is used to copy the contents of one ARF file to another.
  The entries are copied without modification from the source ARF file(s)
  to the target container.
  The ``-d`` (delete) operation uses the same syntax as the extract
  operation, but instead of extracting the entries, they are deleted.
  Because of limitations in the underlying HDF5 library, this does not
  free up the space, so the file is repacked unless the ``-P`` option is
  set.
  The ``-U`` (update) operation can be used to add or update attributes of
  entries, and to rename entries (if the ``-n`` flag is set).
  The ``--write-attr`` operation can be used to store the contents of text
  files in top-level attributes. The attributes have the name
  ``user_<filename>``. The ``--read-attr`` operation can be used to read
  out those attributes. This is useful when data collection programs
  generate log or settings files that you want to store in the ARF file.
  other utilities
  ~~~~~~~~~~~~~~~
  This package comes with a few additional scripts that do fairly specific
  operations.
  arfx-split
  ^^^^^^^^^^
  This script is used to reorganize very large recordings, possibly
  contained in multiple files, into manageable chunks. Each new entry is
  given an updated timestamp and attributes from the source entries.
  Currently, no effort is made to splice data across entries or files.
  This may result in some short entries. Only sampled datasets are
  processed.
  arfx-collect-sampled
  ^^^^^^^^^^^^^^^^^^^^
  This script is used to export data into a flat binary structure. It
  collects sampled data across channels and entries into a single 2-D
  array. The output can be stored in a multichannel wav file or in a raw
  binary ``dat`` format (N samples by M channels), which is used by a wide
  variety of spike-sorting tools.
  extending arfx
  ~~~~~~~~~~~~~~
  Additional formats for reading and writing can be added using the Python
  setuptools plugin system. Plugins must be registered in the ``arfx.io``
  entry point group, with a name corresponding to the extension of the
  file format handled by the plugin.
  An arfx IO plugin is a class with the following required methods:
  ``__init__(path, mode, **attributes)``: Opens the file at ``path``. The
  ``mode`` argument specifies whether the file is opened for reading
  (``r``), writing (``w``), or appending (``a``). Must throw an
  ``IOError`` if the file does not exist or cannot be created, and a
  ``ValueError`` if the specified value for ``mode`` is not supported. The
  additional ``attributes`` arguments specify metadata to be stored in the
  file when created. **arfx** will pass all attributes of the channel and
  entry (e.g., ``channels``, ``sampling_rate``, ``units``, and
  ``datatype``) when opening a file for writing. This method may issue a
  ``ValueError`` if the caller fails to set a required attribute, or
  attempts to set an attribute inconsistent with the data format.
  Unsupported attributes should be ignored.
  ``read()``: Reads the contents of the opened file and returns the data
  in a format suitable for storage in an ARF file. Specifically, it must
  be an acceptable type for the ``arf.entry.add_data()`` method (see
  https://github.com/melizalab/arf for documentation).
  ``write(data)``: Writes data to the file. Must issue an ``IOError`` if
  the file is opened in the wrong mode, and ``TypeError`` if the data
  format is not correct for the file format.
  ``timestamp``: A readable property giving the time point of the data.
  The value may be a scalar indicating the number of seconds since the
  epoch, or a two-element sequence giving the number of seconds and
  microseconds since the epoch. If this property is writable it will be
  set by **arfx** when writing data.
  ``sampling_rate``: A property indicating the sampling rate of the data
  in the file (or current entry), in units of Hz.
  The class may also define the following methods and properties. If any
  property is not defined, it is assumed to have the default value defined
  below.
  ``nentries``: A readable property indicating the number of entries in
  the file. Default value is 1.
  ``entry``: A readable and writable integer-valued property corresponding
  to the index of the currently active entry in the file. Active means
  that the ``read()`` and ``write()`` methods will affect only that entry.
  Default is 0, and **arfx** will not attempt to change the property if
  ``nentries`` is 1.
  version information
  ~~~~~~~~~~~~~~~~~~~
  **arfx** uses semantic versioning and is synchronized with the
  major/minor version numbers of the arf package specification.


pkgId: e70109c286011fb8a0569fe808a4b912c52ecfa76323dc628f6f263a829f2baa
name: python-arg-services
arch: src
version: 1.7.1
epoch: 0
release: 1
summary: gRPC definitions for microservice-based argumentation machines
url: http://recap.uni-trier.de
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arg-services-1.7.1-1.src.rpm
checksum_type: sha256
description:
  This project contains Protobuf definitions for building complex argumentation machines.
  The idea is to facilitate a microservice-oriented architecture where individual parts can be swapped out easily.
  Along with the Protobuf files, the project also contains code for generating libraries for multiple programming languages that are released as packages in their respective registries:

  - [Python](https://pypi.org/project/arg-services/)
  - [TypeScript](https://www.npmjs.com/package/arg-services)

  Documentation can be found at the [Buf Schema Registry](https://buf.build/recap/arg-services).



  `./generate.sh`


pkgId: 7c8e121c2cf6da380cacf99824f1902459e9d0adc8045ab832e137ffcd15bd6f
name: python-argbind
arch: src
version: 0.3.9
epoch: 0
release: 1
summary: Simple way to bind function arguments to the command line.
url: https://github.com/pseeth/argbind/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argbind-0.3.9-1.src.rpm
checksum_type: sha256
description:
      name : str, optional
          Who you're saying hello to, by default 'world'
      """
      print("Hello " + name)
  if __name__ == "__main__":
      
      
      args = argbind.parse_args()
      
      
      with argbind.scope(args):
          hello()
  ```
  Help text is automatically generated from the docstring:
  ```
  ❯ python examples/hello_world/with_argbind.py -h
  usage: with_argbind.py [-h] [--args.save ARGS.SAVE] [--args.load ARGS.LOAD] [--args.debug ARGS.DEBUG] [--hello.name HELLO.NAME]
  optional arguments:
    -h, --help            show this help message and exit
    --args.save ARGS.SAVE
                          Path to save all arguments used to run script to.
    --args.load ARGS.LOAD
                          Path to load arguments from, stored as a .yml file.
    --args.debug ARGS.DEBUG
                          Print arguments as they are passed to each function.
  Generated arguments for function hello:
    Say hello to someone.
    --hello.name HELLO.NAME
                          Who you're saying hello to, by default 'world'
  ```
  Execution of this could look like:
  ```

  ❯ python examples/hello_world/with_argbind.py
  Hello world

  ❯ python examples/hello_world/with_argbind.py --hello.name=you --args.save=/tmp/args.yml
  Hello you

  ❯ python examples/hello_world/with_argbind.py --args.load=/tmp/args.yml
  Hello you

  ❯ python examples/hello_world/with_argbind.py --args.load=/tmp/args.yml --hello.name=me
  Hello me

  ❯ python examples/hello_world/with_argbind.py --args.load=/tmp/args.yml --args.debug=1
  hello(
    name : str = you
  )
  Hello you
  ```
  You can also run the `hello` function from another Python script or a Jupyter notebook:
  ```python
  import argbind

  from .hello_world import hello

  args = argbind.load_args('/tmp/args.yml')

  with argbind.scope(args):
      
      hello() # Prints 'Hello you'.
  hello() # Prints 'Hello world', as it's outside scope.

  args['hello.name'] = 'me'
  with argbind.scope(args):
      hello() # Prints 'Hello me'.
  ```
  You'll notice that ArgBind forces you to document and type your
  function arguments, which is always a good idea!
  Please check out the [examples](#examples) for more details!

  ArgBind is designed around a decorator that can be used on
  functions the user wants to expose to command line or to a .yml file.
  The arguments to that function are
  then bound to a dictionary. When the function is called,
  each argument is looked up in the dictionary and its
  value is replaced with the corresponding value in the dictionary. The
  dictionary that the function looks for values in is controlled by
  `scope`:
  ```python
  import argbind
  @argbind.bind()
  def func(arg : str = 'default'):
      print(arg)
  dict1 = {
      'func.arg': 1,
  }
  dict2 = {
      'func.arg': 2
  }
  with argbind.scope(dict1):
      func() # prints 1
  with argbind.scope(dict2):
      func() # prints 2
  func(arg=3) # prints 3.
  ```
  The function arguments are bound to the command line. Continuing the
  simple program from above:
  ```python
  if __name__ == "__main__":
      args = argbind.parse_args()
      with argbind.scope(args):
          func()
      with argbind.scope(args):
          func(arg=3)
  ```
  You can call this function like so:
  ```bash
  ❯ python examples/readme_example.py --func.arg 5
  1 # Looks up `arg` in dict1
  2 # Looks up `arg` in dict2
  3 # arg is passed in on python call `func(arg=3)`
  5 # Looks up `arg` from command line call `--func.arg 5`
  3 # arg is passed in from two places: `func(arg=3)` and `--func.arg 5`. Former overrides the latter.
  ```
  The logic here is that arguments that are bound that are closer to the actual function call get priority. From highest priority, to lowest, it goes:
  1. Bound explicitly in Python code
  2. Bound via command line
  3. Bound via .yml file
  4. Bound via default for kwarg
  You can also use `bind` directly on classes - see [here](./examples/bind_existing).

  There are some limitations to ArgBind, some due to how Python function decorator works,
  and others out of a desire to keep ArgBind's code simple and straightforward.

  If a boolean is flipped to True in a `.yml` file, there's no
  way to override it from the command line. If you want a flag to
  be flippable, make the argument an int instead of a bool and use
  0 and 1 for True and False. Then you can override from command
  line like `--func.arg 0` or `--func.arg 1`.

  Functions that are bound must be unique, even if they are in different files. The
  function name is resolved in the argument parser only using the immediate name, not
  a path to the function etc.

  ArgBind uses [docstring-parser](https://github.com/rr-/docstring_parser), and so
  the only supported styles are: ReST, Google, and Numpydoc-style docstrings.

  ArgBind supports most types that might pop up in your script, but not all. The supported types can be seen in the [typing example](./examples/typing/).

  If the a positional argument is saved into a .yml file, and loaded
  via `--args.load`, then any positional argument passed in the
  command line will be overridden. Take care not to pass in
  positional arguments via `.yml` files.

  Do the following steps:
  ```
  python setup.py sdist
  ```
  Upload it to test PyPI:
  ```
  pip install twine
  twine upload --repository testpypi dist/*
  pip install -U --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple -U argbind
  ```
  Make sure you can install it and it works (e.g. run the examples). Now upload
  to actual PyPI:
  ```
  twine upload dist/*
  ```

  If you've run into some issues with ArgBind, or have some questions, please ask
  via Github Issues. Projects like ArgBind are pretty tricky to get right, so there
  may be some edge cases that have been missed.


pkgId: 921ea88746225d8d551caf8f1e4ee516e690ae7bcf2936388f5a90e159ed4c64
name: python-argcmdr
arch: src
version: 1.1.0
epoch: 0
release: 1
url: https://github.com/dssg/argcmdr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argcmdr-1.1.0-1.src.rpm
checksum_type: sha256
summary:
  Thin argparse wrapper for quick, clear and easy declaration of hierarchical console command interfaces


pkgId: 95251ac8639686d842b77c288e00a8599139ec444eefee9afbf86db4c4cff789
name: python-argcomplete
arch: src
version: 3.5.0
epoch: 0
release: 1
summary: Bash tab completion for argparse
url: https://github.com/kislyuk/argcomplete
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argcomplete-3.5.0-1.src.rpm
checksum_type: sha256
description:
  *Tab complete all the things!*
  Argcomplete provides easy, extensible command line tab completion of arguments for your Python application.
  It makes two assumptions:
  * You're using bash or zsh as your shell
  * You're using `argparse <http://docs.python.org/3/library/argparse.html>`_ to manage your command line arguments/options
  Argcomplete is particularly useful if your program has lots of options or subparsers, and if your program can
  dynamically suggest completions for your argument/option values (for example, if the user is browsing resources over
  the network).


pkgId: 1d85389fe98dfa1e6c94f5739e76bd3e68381ae886ba1d591a8ed8886f395a7a
name: python-argdispatch
arch: src
version: 1.3.1
epoch: 0
release: 1
url: http://framagit.org/spalax/argdispatch
rpm_license: GPLv3 or any later version
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argdispatch-1.3.1-1.src.rpm
checksum_type: sha256
summary:
  A drop-in replacement for `argparse` dispatching subcommand calls to functions, modules or binaries.

description:
  If your parser has a few subcommands, you can parse them with ``argparse``. If you have more, you still can, but you will get a huge, unreadable code. This module makes this easier by dispatching subcommand calls to functions, modules or binaries.


pkgId: c8dba20125fc8034c50c73b10b048b8ec378f51b7fd31c4a38faadd07bae8fb9
name: python-argformat
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Provides a structured formatter for the argparse module
url: https://github.com/Thijsvanede/argformat
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argformat-0.0.3-1.src.rpm
checksum_type: sha256
description:
  Provides a more structured formatter for python's argparse module.


  ```
  pip install argformat
  ```


  Simply import the `StructuredFormatter` and set it as the argparse `formatter_class`:


  ```python
  import argparse
  from argformat import StructuredFormatter


  parser = argparse.ArgumentParser(
      prog        = <Your program>,
      description = <Your description>,
      formatter_class=StructuredFormatter
  )


  ```


pkgId: 01e3f1d0087caab6ee164715e6ae435eb5166cdbd4786686e5f86959e104bb68
name: python-argh
arch: src
version: 0.31.3
epoch: 0
release: 1
summary: Plain Python functions as CLI commands without boilerplate
url: https://github.com/neithere/argh
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argh-0.31.3-1.src.rpm
checksum_type: sha256
description:
  **The power of Argparse with plain Python functions!**
  Building a command-line interface?  Found yourself uttering "argh!" while
  struggling with the API of `argparse`?  Don't like the complexity but need
  the power?
  `Argh` builds on the power of `argparse` (which comes with Python) and makes it
  really easy to use.  It eliminates the complex API and lets you "dispatch"
  ordinary Python functions as CLI commands.


pkgId: 1ac164bb8d09e7ba058e550c58f4e09040027248ca212ca4b9ac7ee4fdac4021
name: python-arghandler
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: argparse extended with awesome feature enhancements to make life easier
url: http://www.github.com/druths/arghandler
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arghandler-1.3.1-1.src.rpm
checksum_type: sha256
description:
  *Making argparse even more awesome*

  I love [argparse](https://docs.python.org/3/library/argparse.html), but there
  are some things that it simply doesn't help with as much as I'd like. Enter
  arghandler.

  The goal behind arghandler is to provide all the capabilities of argparse
  *plus* some high-level capabilities that crop up a lot when writing
  command-line tools: the library aims for high quality command line interfaces
  with (even more) minimal code.

  At present, arghandler provides two key capabilities:

    1. Adding subcommands with basically zero extra lines of code. This gives
    support for writing programs like `git` and `svn` which have nested
    subcommands.

    1. Configuring the logging framework (e.g., the desired logging level) from
    the command line - again with basically one line of code.

  We have lots more improvements we want to add - and as we have time and receive
  feedback, we'll add more features.

  If you have ideas, [email me](mailto:druths@networkdynamics.org) or code it up
  and generate a pull request!



  Use `pip` or `easy_install` to install the library:

  	pip install arghandler

  or

  	easy_install arghandler

  You can find arghandler on pypi for relevant details should you need them.



  Just like with
  [argparse.ArgumentParser](https://docs.python.org/3/library/argparse.html#argumentparser-objects),
  in `arghandler` everything revolves around `ArgumentHandler`. In fact, it's
  (not so secretly) a subclass of ArgumentParser, so you can use it exactly the
  way you use `ArgumentParser`.  But `ArgumentHandler` has some new tricks.

  To benefit from `ArgumentHandler`, your command-line configuration code will
  follow this logic:

  	from arghandler import ArgumentHandler

  	handler = ArgumentHandler() # this accepts all args supported by ArgumentParser

  	

  	handler.run() # throw the configured handler at an argument string!

  Now for some details...



  `ArgumentHandler` can be invoked on arguments in two ways.

  *`ArgumentHandler.parse_args([argv])`* is little different from
  `ArgumentParser.parse_args([argv])`.  If `argv` is omitted, then the value of
  `sys.argv` is used. The only notable differences are:

    * If a logging argument was set, then this will be included in the namespace
      object returned.

    * If subcommands are available, then the subcommand will be given by the
  	value of `args.cmd` and the subcommand's arguments will be given by
  	`args.cargs`.

  *`ArgumentHandler.run(argv,context_fxn)`* makes the class perform its more
  unique and powerful capabilities.  Notably: configuring the logger and running
  subcommands.  As with `parse_args(...)`, if `argv` is not specified, then
  `sys.argv` will be used.  The `context_fxn` is also optional and is used as
  part of subcommand processing.  See that [section](#subcommands) below for more
  details.



  When constructing an `ArgumentHandler`, you can enable autocompletion.  This
  requires doing two separate things.

  First, pass the keyword argument `enable_autocompetion=True` to
  `ArgumentHandler(...)`.

  Second, in the top-level script that will be your command-line tool, include
  the line

  	

  near the top (in the first 1024 bytes).  For more details on this, see the
  [argcomplete](https://argcomplete.readthedocs.io/en/latest/) documentation.

  For an example of this in action, see [examples/dummy.py!](examples/dummy.py).



  If you use the python [logging](https://docs.python.org/3/library/logging.html)
  package, this feature will save you some time.

  The `ArgumentParser.set_logging_argument(...)` method allows you to specify a
  command-line argument that will set the logging level.  The method accepts
  several arguments:

  	ArgumentParser.set_logging_argument(*names,default_level=logging.ERROR,config_fxn=None)


    * `*names` stands in for one or more arguments that specify the
  	argument names that will be used. These follow the same rules as ones
  	passed into
  	[ArgumentParser.add_argument(...)](https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser.add_argument).
  	Moreover, they MUST be optional arguments (i.e., start with a '-'
  	character).

    * `default_level` indicates the default level the logging
  	framework will be set to should the level not be specified on the command
  	line.

    * `config_fxn` allows the developer to write special logging
  	configuration code.  If not specified, the
  	[logging.basicConfig](https://docs.python.org/3/library/logging.html#logging.basicConfig)
  	function will be invoked with the appropriate logging level. The function
  	must accept two arguments: the logging level and the namespace args object
  	returned by the `ArgumentParser.parse_args` method. The configuration
  	itself will happen when the `ArgumentHandler.run(...)` method is called.

  If you're cool with the defaults in `basicConfig`, then your method call will
  look something like this

  	handler.set_logging_argument('-l','-log_level',default_level=logging.INFO)

  If you do want to do some customization, then your code will look like this

  	handler.set_logging_argument('-l','-llevel',
  		config_fxn=lambda level,args: logging.basicConfig(level=level,format=''))



  This feature makes it possible to write nested commands like `git commit` and
  `svn checkout` with basically zero boilerplate code.  To do this `arghandler`
  provides the `@subcmd` decorator.  To declare a subcommand, just put the
  decorator on the function  you want to act as the subcommand.

  	from arghandler import *

  	@subcmd
  	def echo(parser,context,args):
  		print ' '.join(args)

  	
  	@subcmd('foobar', help = 'Does foobar')
  	def cmd_foobar(parser,context,args):
  		print 'foobar'

  	handler = ArgumentHandler()
  	handler.run(['echo','hello','world']) # echo will be called and 'hello world' will be printed

  Notice that the subcommands always take three arguments.

  `args` is the set of arguments that *follow* the subcommand on the command
  line.

  `context` is an object that can make valuable global information available to
  subcommands.  By default, the context is the namespace object returned by the
  internal call to `ArgumentHandler.parse_args(...)`.  Other contexts can be
  produced by passing a context-producing function to the
  `ArgumentHandler.run(...)` function:

  	@subcmd('ping')
  	def ping_server(parser,server_address,args):
  		os.system('ping %s' % server_address)

  	handler = ArgumentHandler()
  	handler.add_argument('-s','--server')

  	
  	
  	handler.run(['-s','127.0.0.1','ping'],context_fxn=lambda args: args.server

  Finally, `parser` is an instance of `argparse.ArgumentParser` which has been
  preconfigured to behave properly for the subcommand.  Most crucially, this
  means that `parser.prog` is set to `<top_level_program> <sub_command>` so that
  help messages print out correctly for the subcommand.  Should your subcommand
  want to parse arguments, this parser object should be used.



  While decorators are the preferred way to specify subcommands, subcommands can
  also be specified using the `ArgumentHandler.set_subcommands(...)` function.
  This method expects a dictionary: keys are command names, values are the
  command functions:

  	from arghandler import *

  	def echo(parser,context,args):
  		print ' '.join(args)

  	def cmd_foobar(parser,context,args):
  		print 'foobar'

  	handler = ArgumentHandler()
  	handler.set_subcommands( {'echo':echo, 'foobar':cmd_foobar} )
  	handler.run(['echo','hello','world']) # echo will be called and 'hello world' will be printed

  All the logic and rules around the context function apply here.  Moreoever, the
  complete set of subcommands include those specified using decorators AND those
  specified through the `set_subcommands(...)` method.


  One valuable use for the `set_subcommands(...)` method is implementing
  subcommand options for a subcommand.  For example, suppose you want a program with the following
  command subtree:

  ```
  power
    - create
      - config
      - proj
    - run
      - all
      - proj
  ```

  In this case, `create` and `run` would be top-level subcommands that could be
  declared using standard `subcmd` decorators.  But what about the `config` and
  `proj` commands underneath `create`?  These can be created using a new
  `ArgumentHandler` inside the `create` function like this:

  ```
  def create_config(parser, context, args):
      parser.add_argument('location')
      args = parser.parse_args(args)

      

      return

  def create_proj(parser, context, args):
      parser.add_argument('name')
      args = parser.parse_args(args)

      print(f'Creating the project: {args.name}')

      

      return


  @subcmd('create', help='create a resource')
  def create(parser, context, args):
      handler = ArgumentHandler()

      handler.set_subcommands({'config': (create_config, 'create a config file'),
                               'proj': (create_proj, 'create a project')
                              },
                              use_registered_subcmds=False)

      handler.run(args)
  ```

  Note the use of `use_registered_subcmds=False` - this is important to omit any
  functions globally registered as commands using the `@subcmd` decorator.



  The format of the help message can be set to one more friendly for subcommands
  by passing the `ArgumentHandler` constructor the keyword argument
  `use_subcommand_help=True`.

  This will produce a help message that looks something like this:

  	usage: test.py [-h] subcommand

  	positional arguments:
  	  subcommand
          cmd1  cmd1_help_str

  	optional arguments:
    	  -h, --help  show this help message and exit



  *Use `ArgumentParser` or `ArgumentHandler` inside subcommands.* This will
  ensure that informative help messages are available for all your subcommands.

  	from arghandler import *

  	@subcmd
  	def echo(parser,context,args):
  		parser.add_argument('-q','--quote_char',required=True)
  		args = parser.parse_args(args)
  		print '%s%s%s' % (args.quote_char,' '.join(args),args.quote_char)

  	@subcmd('foobar')
  	def cmd_foobar(parser,context,args):
  		print 'foobar'

  	handler = ArgumentHandler()
  	handler.run(['echo','-h']) # the help message for echo will be printed

  *Use logging.* Logging gives you much more control over what
  debugging/informational content is printed out by your program. And with
  `arghandler` it's easier than ever to configure from the command line!


pkgId: abf9f0e1bfbe24f57f241c513ef2f64b1a2bd2eb7886cb91690622b055f4e7e8
name: python-argilla-dataset-manager
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A tool for managing and uploading datasets to Argilla
url: https://github.com/jordanrburger/argilla_dataset_manager
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argilla-dataset-manager-0.1.5-1.src.rpm
checksum_type: sha256
description:
  A Python-based tool for managing and uploading datasets to Argilla, specifically designed for handling various types of text datasets with advanced configuration options.



  - Easy dataset creation with predefined templates
  - Flexible dataset configuration for different use cases
  - Dataset migration and versioning
  - Workspace management
  - Robust error handling and logging





  ```bash
  pip install argilla-dataset-manager
  ```



  1. Clone the repository:
  ```bash
  git clone https://github.com/jordanrburger/argilla_dataset_manager.git
  cd argilla-dataset-manager
  ```

  2. Install in development mode:
  ```bash
  pip install -e .
  ```



  Create a `.env` file in your project directory with your Argilla credentials:
  ```env
  ARGILLA_API_URL=your_argilla_api_url
  ARGILLA_API_KEY=your_api_key
  ```





  ```python
  from argilla_dataset_manager import DatasetManager, get_argilla_client, SettingsManager


  client = get_argilla_client()
  dataset_manager = DatasetManager(client)
  settings_manager = SettingsManager()


  settings = settings_manager.create_text_classification(
      labels=['positive', 'negative', 'neutral'],
      guidelines="Sentiment analysis dataset",
      include_metadata=True,
      metadata_fields=['source', 'confidence']
  )


  dataset = dataset_manager.create_dataset(
      workspace="my_workspace",
      dataset="sentiment_analysis",
      settings=settings
  )


  record = rg.Record(
      fields={
          "text": "This product is amazing!"
      },
      metadata={
          "source": "reviews",
          "confidence": 0.95
      }
  )
  dataset.records.log([record])
  ```



  ```python

  settings = settings_manager.create_qa_dataset(
      include_context=True,
      include_keywords=True,
      include_references=True,
      guidelines="Customer support Q&A dataset"
  )


  dataset = dataset_manager.create_dataset(
      workspace="support_workspace",
      dataset="customer_qa",
      settings=settings
  )


  record = rg.Record(
      fields={
          "question": "How do I reset my password?",
          "answer": "Click on 'Forgot Password' and follow the instructions.",
          "context": "User authentication flow",
          "keywords": "password,reset,auth",
          "references": "docs/auth.md"
      },
      metadata={
          "source": "support_tickets",
          "date": "2023-12-01"
      }
  )
  dataset.records.log([record])
  ```



  ```python

  new_version = dataset_manager.update_dataset_settings(
      workspace="my_workspace",
      dataset="customer_qa",
      new_settings=updated_settings,
      create_new_version=True
  )


  cloned_dataset = dataset_manager.clone_dataset(
      workspace="development",
      dataset="customer_qa",
      new_name="customer_qa_prod",
      new_workspace="production"
  )
  ```



  The `SettingsManager` provides several predefined templates:

  1. **Text Classification**
     - Basic text classification with customizable labels
     - Optional metadata fields

  2. **Q&A Datasets**
     - Question and answer fields
     - Optional context, keywords, and references
     - Configurable metadata

  3. **Text Generation**
     - Prompt and response fields
     - Optional prompt templates
     - Model-specific metadata

  4. **Text Summarization**
     - Text and summary fields
     - Length and compression ratio tracking
     - Source tracking

  5. **Custom Datasets**
     - Create datasets with custom fields
     - Flexible metadata configuration





  1. Clone the repository:
  ```bash
  git clone https://github.com/jordanrburger/argilla_dataset_manager.git
  cd argilla-dataset-manager
  ```

  2. Create a virtual environment:
  ```bash
  python -m venv venv
  source venv/bin/activate  # On Windows: venv\Scripts\activate
  ```

  3. Install development dependencies:
  ```bash
  pip install -e ".[dev]"
  ```



  ```bash
  pytest tests/
  ```



  This project uses:
  - Black for code formatting
  - isort for import sorting
  - mypy for type checking

  To format code:
  ```bash
  black .
  isort .
  mypy .
  ```



  ```
  argilla_dataset_manager/
  ├── __init__.py            # Package initialization
  ├── utils/
  │   ├── argilla_client.py  # Argilla API interaction
  │   ├── dataset_manager.py # Dataset management
  │   └── logger.py          # Logging configuration
  └── datasets/
      └── settings_manager.py # Dataset settings and templates
  ```



  The library includes comprehensive error handling:
  - Connection validation
  - Workspace existence checks
  - Dataset creation validation
  - Record format validation



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



  MIT License - see the [LICENSE](LICENSE) file for details


pkgId: 2ea1878f487fd9bf76460ed57f65d9a7617d74022f460450653a448321c8104f
name: python-argklass
arch: src
version: 1.4.4
epoch: 0
release: 1
summary: Argparse generator from dataclass
url: https://argklass.readthedocs.io
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argklass-1.4.4-1.src.rpm
checksum_type: sha256
description:
  |pypi| |py_versions| |codecov| |docs| |tests| |style|
  Inspired by `Simple Parsing <https://github.com/lebrice/SimpleParsing>`_, simplified
  and extended to build extensive, extendable command line interface without much code.
     pip install argklass


pkgId: edbee1dd2c336d6f3b65b8fa0c61d322807d262450eea6e27d147898e3d6fbe2
name: python-arglu
arch: src
version: 2.1.4
epoch: 0
release: 1
summary: Some utilities for Argument Mining
url: https://github.com/pypa/sampleproject
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arglu-2.1.4-1.src.rpm
checksum_type: sha256
description:
  Arglu stands for ARGumentative Language Utils

  The project contains some fairly basic utilities which seem to be required in a number of projects on Argument Mining.

  Namely, a simple way to plot argument graphs, and tools for converting graphs between different formats.


pkgId: 21344af0e50f0beefa4e649ef7e42cff15df84cdd6a382b2352e47aaf7ce1fe9
name: python-argmagic
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Parse environment variables and CLI arguments for a given function signature.
url: https://github.com/xiamaz/argmagic
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argmagic-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Based on a idea by [@lbb](https://github.com/lbb/).

  Automatically generate argparse based env-var/CLI-interface from a given function.

  Example:

  Given a function with a docstring and type hints.

  ```python
  def hello(name: str):
      '''
      Say hello to name.

      Args:
          name: Your name.

      Raises:
          Nothing.

      Returns:
          Nothing.
      '''
      print('Hello', name)
  ```

  Create a CLI interface:

  ```python
  argmagic(hello)
  ```

  Argmagic will call the function with all parameters filled from CLI arguments.

  ```sh
  $ ./hello.py -h
  usage: hello [-h] [--name NAME]

  Say hello to name.

  optional arguments:
    -h, --help   show this help message and exit
    --name NAME  Your name.
  ```

  Additionally all specified parameters can also be defined via environment
  variables.

  ```sh
  $ NAME=test hello.py
  Hello test
  ```

  These can then again be overriden by CLI arguments.

  ```sh
  $ NAME=test hello.py --name something
  Hello something
  ```



  Current parsing of lists, tuples and unions are supported.

  For example a typehint containing `List[str]`, will parse input `[a, b, c]` to
  a python list containing `["a", "b", "c"]`.

  Also these types can be arbitrarily nested, such as `Dict[str, List[int]]` will
  correctly parse strings of structure `{a: [1, 2, 3], b: [5, 3]}`.

  Syntax overview:

  ```
  Tuple syntax:
  (a, b, c)

  List syntax:
  [a, b, c]

  Dict syntax:
  {a: i, b: j, k: l}
  ```



  [click](https://github.com/pallets/click) uses decorators


pkgId: 4f4d819af8bbe08f6be084d958a9da4149ced45e786c99247a15a872b1f485f3
name: python-argnorm
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Normalize antibiotic resistance genes (ARGs) results by using the ARO ontology (developed by CARD).
url: https://github.com/BigDataBiology/argNorm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argnorm-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/BigDataBiology/argNorm/actions/workflows/python-package.yml/badge.svg)](https://github.com/BigDataBiology/argNorm/actions/workflows/python-package.yml)
  [![Downloads](https://pepy.tech/badge/argNorm)](https://pepy.tech/project/argNorm)
  ![](https://img.shields.io/badge/status-beta-yellow?style=flat)
  [![install with bioconda](https://img.shields.io/badge/install%20with-bioconda-brightgreen.svg?style=flat)](http://bioconda.github.io/recipes/argnorm/README.html)
  [![Anaconda-Server Badge](https://anaconda.org/bioconda/argnorm/badges/platforms.svg)](https://anaconda.org/bioconda/argnorm)
  [![Anaconda-Server Badge](https://anaconda.org/bioconda/argnorm/badges/license.svg)](https://anaconda.org/bioconda/argnorm)


  argNorm is a tool to normalize antibiotic resistance genes (ARGs) by mapping them to the [antibiotic resistance ontology (ARO)](https://obofoundry.org/ontology/aro.html) created by the [CARD database](https://card.mcmaster.ca/).

  argNorm also enhances antibiotic resistance gene annotations by providing drug categorization of the drugs that antibiotic resistance genes confer resistance to.



  Right now, many tools exist for annotation ARGs in genomes and metagenomes. However, each tools will have distinct output formats.

  The [hAMRonization package](https://github.com/pha4ge/hAMRonization) can normalize file formats, but each tool will use different names/identifiers (_e.g._, `TetA` or `TETA` or `tet(A)` or `tet-A` are all different ways to spell the same gene name).

  For a small number of isolate genomes, a human user can manually evaluate the outputs. However, in metagnomics, especially for large-scale projects, this becomes infeasible. Thus argNorm normalizers the output vocabulary of ARG annotation tools by mapping them to the same ontology (ARO).

  Besides performing normalization, argNorm also provides categorization of drugs that antibiotic resistance genes confer resistance to.

  For example, the `PBP2b` (`ARO:3003042`) gene confers resistance to the drug class `amoxicillin`. `amoxicillin` is then categorized into a broader category of `beta lactam antibiotic`.

  argNorm provides support for this, and adds the `confers_resistance_to` and `resistance_to_drug_classes` columns to ARG annotations.

  The `confers_resistance_to` column will contain ARO numbers of all the drug classes that a gene provides resistance to (`ARO:0000064` for `amoxicillin` in the previous example).

  The `resistance_to_drug_classes` column will contain ARO numbers of the broader categories of the drug classes in the `confers_resistance_to` column (`ARO:3000007` for `beta lactam antibiotic` in the previous example).


  ![argNorm Overview](./docs/images/argnorm_overview.svg)

  *General overview of argNorm. (a) Genomes and metagenomes can be annotated using ARG annotation tools. argNorm accepts the outputs of these ARG annotation tools directly or after the outputs are processed by hAMRonization to perform ARO normalization and drug categorization. (b) The argNorm workflow includes: mapping gene names in the ARG annotation outputs to ARO accessions from ARO annotation tables constructed using RGI and manual curation; and mapping gene ARO accessions to drugs and drugs classes. (c) In categorizing drugs, agrNorm reports the immediate child of the ‘antibiotic molecule’ node in the ARO*




  *Schematic illustration of argNorm workflow through a Resfinder output example: mapping gene names in the ARG annotation outputs to gene names from the ARO mapped ARG databases and adding corresponding drug categorization, namely “confers resistance to immediate drug class” and “overall category of drug class”, from the ARO ontology file.*

  ![argNorm Workflow](./docs/images/argnorm_workflow.svg)



  - [DeepARG](https://bench.cs.vt.edu/deeparg) (v1.0.2)
  - [ARGs-OAP](https://galaxyproject.org/use/args-oap/) (v3)
  - [ABRicate](https://github.com/tseemann/abricate) (v1.0.1) with NCBI (v3.6), ResFinder (v4.1.11), MEGARes (v2.0), ARG-ANNOT (v5), ResFinderFG (v2)
  - [ResFinder](https://bitbucket.org/genomicepidemiology/resfinder/src/master/) (v4.0)
  - [AMRFinderPlus](https://github.com/ncbi/amr) (v3.10.30)
  - [GROOT](https://github.com/will-rowe/groot) (v1.1.2)


  argNorm can be installed using pip:
  ```bash
  pip install argnorm
  ```

  argNorm can also be installed through conda:
  ```
  conda install bioconda::argnorm
  ```

  argNorm is also available as an [nf-core module](https://nf-co.re/modules/argnorm/). If using an nf-core pipeline, argNorm can be installed using:
  ```
  nf-core modules install argnorm
  ```



  [![argNorm Tutorial](https://markdown-videos-api.jorgenkh.no/url?url=https%3A%2F%2Fyoutu.be%2Fvx8MCQ7gDLs)](https://youtu.be/vx8MCQ7gDLs)



  The only positional argument required is `tool` which can be:
  - `deeparg`
  - `argsoap`
  - `abricate`
  - `resfinder`
  - `amrfinderplus`
  - `groot`

  The available options are:
  - `-h` or `--help`: shows available options and exits.
  - `--db`: database used to perform ARG annotation. Supported databases are:
      - SARG (`sarg`)
      - NCBI (`ncbi`)
      - ResFinder (`resfinder`)
      - DeepARG (`deeparg`)
      - MEGARes (`megares`)
      - ARG-ANNOT (`argannot`)
      - `groot-core-db`, `groot-db`, `groot-resfinder`, `groot-argannot`, `groot-card`
  - `--hamronized`: use this if the input is hamronized by [hAMRonization](https://github.com/pha4ge/hAMRonization)
  - `-i` or `--input`: path to the annotation result
  - `-o` or `--output`: the file to save normalization results

  Use `argnorm -h` or `argnorm --help` to see available options.

  ```bash
  >argnorm -h
  usage: argnorm [-h]
                 [--db {sarg,ncbi,resfinder,deeparg,megares,argannot,resfinderfg,groot-argannot,groot-resfinder,groot-db,groot-core-db,groot-card}]
                 [--hamronized] [-i INPUT] [-o OUTPUT]
                 {argsoap,abricate,deeparg,resfinder,amrfinderplus,groot}

  argNorm normalizes ARG annotation results from different tools and databases to the same ontology, namely ARO (Antibiotic Resistance Ontology).

  positional arguments:
    {argsoap,abricate,deeparg,resfinder,amrfinderplus,groot}
                          The tool you used to do ARG annotation.

  optional arguments:
    -h, --help            show this help message and exit
    --db {sarg,ncbi,resfinder,deeparg,megares,argannot,resfinderfg,groot-argannot,groot-resfinder,groot-db,groot-core-db,groot-card}
                          The database you used to do ARG annotation.
    --hamronized          Use this if the input is hamronized (processed using the hAMRonization tool)
    -i INPUT, --input INPUT
                          The annotation result you have
    -o OUTPUT, --output OUTPUT
                          The file to save normalization results
  ```

  Here is a basic outline of calling argNorm.

  ```bash
  argnorm [tool] -i [original_annotation.tsv] -o [annotation_result_with_aro.tsv]
  ```



  Here is a quick demo of running argNorm on the command line.



  Install argNorm and check installation
  ```
  pip install argnorm
  argnorm -h
  ```

  `argnorm -h` or `argnorm --help` will display all the available options to run argNorm with.

  ```
  > argnorm -h
  usage: argnorm [-h]
                 [--db {sarg,ncbi,resfinder,deeparg,megares,argannot,resfinderfg}]
                 [--hamronized] [-i INPUT] [-o OUTPUT]
                 {argsoap,abricate,deeparg,resfinder,amrfinderplus}

  argNorm normalizes ARG annotation results from different tools and databases to the same ontology, namely ARO (Antibiotic Resistance Ontology).

  positional arguments:
    {argsoap,abricate,deeparg,resfinder,amrfinderplus}
                          The tool you used to do ARG annotation.

  optional arguments:
    -h, --help            show this help message and exit
    --db {sarg,ncbi,resfinder,deeparg,megares,argannot,resfinderfg}
                          The database you used to do ARG annotation.
    --hamronized          Use this if the input is hamronized (processed using
                          the hAMRonization tool)
    -i INPUT, --input INPUT
                          The annotation result you have
    -o OUTPUT, --output OUTPUT
                          The file to save normalization results
  ```



  argNorm adds ARO mappings and drug categories as additional columns to the outputs of ARG annotation tools.

  For this example, we will run argNorm on the ARG annotation output from the [ResFinder](https://bitbucket.org/genomicepidemiology/resfinder/src/master/) tool (with the [ResFinder database](https://bitbucket.org/genomicepidemiology/resfinder_db/raw/8aad1d20603fbec937cdae55024568de6dbd609f/all.fsa)).

  Create a folder called `argNorm_tutorial` and store the downloaded data file in it. Navigate into the `argNorm_tutorial` folder.

  ```
  mkdir argNorm_tutorial
  cd argNorm_tutorial
  ```

  Click [here](https://raw.githubusercontent.com/BigDataBiology/argNorm/main/examples/raw/resfinder.resfinder.orfs.tsv) to download the input data.

  If you are on Linux:
  ```
  wget https://raw.githubusercontent.com/BigDataBiology/argNorm/main/examples/raw/resfinder.resfinder.orfs.tsv
  ```



  Here is a basic outline of most argNorm commands:

  ```bash
  argnorm [tool] -i [original_annotation.tsv] -o [argnorm_result.tsv] [--hamronized]
  ```

  Here, `tool` refers to the ARG annotation tool used (ResFinder in this case). `original_annotation.tsv` is the path to the input data and `argnorm_result.tsv` is the path to output file where the resulting table from argNorm will be stored. `--hamronized` is an option to indicate if the input data is a result of using the [hAMRonization package](https://github.com/pha4ge/hAMRonization). In our example, the input data is not a result of using the hAMRonization package, and so the `--hamronized` option can be omitted.


  To run argNorm on the input data, use this command in your terminal:

  ```
  argnorm resfinder -i ./resfinder.resfinder.orfs.tsv -o ./resfinder.resfinder.orfs.normed.tsv
  ```

  The argNorm result will be stored in the file `resfinder.resfinder.orf.normed.tsv`.





  Save this piece of Python code to a file called `argnorm_tutorial.py`

  ```

  from argnorm.lib import map_to_aro
  from argnorm.drug_categorization import confers_resistance_to, drugs_to_drug_classes


  list_of_input_genes = ['sul1_2_U12338', 'sul1_3_EU855787', 'sul2_1_AF542061']


  database = 'resfinder'



  list_of_aros = []
  for gene in list_of_input_genes:
      
      
      list_of_aros.append(map_to_aro(gene, database).id)
  print(list_of_aros)



  list_of_drugs = []
  for aro in list_of_aros:
      list_of_drugs.append(confers_resistance_to(aro))
  print(list_of_drugs)



  list_of_drug_classes = []
  for drug in list_of_drugs:
      list_of_drug_classes.append(drugs_to_drug_classes(drug))
  print(list_of_drug_classes)
  ```



  To use argNorm as a library, we must first import it in our Python file:

  ```
  from argnorm.lib import map_to_aro
  from argnorm.drug_categorization import confers_resistance_to, drugs_to_drug_classes
  ```

  The `lib` module contains the function `map_to_aro` which will return the ARO number of a particular antibiotic resistance gene. The `drug_categorization` module contains the functions `confers_resistance_to` and `drugs_to_drug_classes`. The `confers_resistance_to` function returns the drugs to which a gene confers resistance to. The `drugs_to_drug_classes` function returns the drug class to which a specific drug belongs.

  The `map_to_aro` function takes two arguments: `gene` and `database`. `gene` is the name of an antibiotic resistance gene. `database` is the database from which `gene` is taken from.

  In this example, a list of genes from the ResFinder database is used, and `map_to_aro` maps each gene in the list to an ARO term.

  The ARO numbers from the ARO terms are also stored in the `list_of_aros` list. The ARO numbers can be accessed using the `id` attribute of the ARO terms. The names of the gene of the ARO terms an be accessed using the `name` attribute.

  ```
  database = 'resfinder'

  list_of_aros = []
  for gene in list_of_input_genes:
      list_of_aros.append(map_to_aro(gene, database).id)
  print(list_of_aros)
  ```

  Once a list of ARO numbers is created for each gene, the `confers_resistance_to` function can be used on each ARO number to create a list of drugs to which each gene/ARO confers resistance to:

  ```
  list_of_drugs = []
  for aro in list_of_aros:
      list_of_drugs.append(confers_resistance_to(aro))
  print(list_of_drugs)
  ```

  Now, each drug in the `list_of_drugs` can be categorized into a broader drug category using the `drugs_to_drug_classes` function:

  ```
  list_of_drug_classes = []
  for drug in list_of_drugs:
      list_of_drug_classes.append(drugs_to_drug_classes(drug))
  print(list_of_drug_classes)
  ```



  ```
  List of ARO numbers
  ['ARO:3000410', 'ARO:3000410', 'ARO:3000412']

  Confers resistance to
  [['ARO:3000324', 'ARO:3000325', 'ARO:3000327', 'ARO:3000329', 'ARO:3000330', 'ARO:3000683', 'ARO:3000684', 'ARO:3000698', 'ARO:3000699'], ['ARO:3000324', 'ARO:3000325', 'ARO:3000327', 'ARO:3000329', 'ARO:3000330', 'ARO:3000683', 'ARO:3000684', 'ARO:3000698', 'ARO:3000699'], ['ARO:3000324', 'ARO:3000325', 'ARO:3000327', 'ARO:3000329', 'ARO:3000330', 'ARO:3000683', 'ARO:3000684', 'ARO:3000698', 'ARO:3000699']]

  Resistance to drug classes
  [['ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282'], ['ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282'], ['ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282', 'ARO:3000282']]
  ```



  - Vedanth Ramji [vedanth.ramji@gmail.com](mailto:vedanth.ramji@gmail.com)*
  - Hui Chong [huichong.me@gmail.com](mailto:huichong.me@gmail.com)
  - Svetlana Ugarcina Perovic [svetlana.ugarcina@gmail.com](mailto:svetlana.ugarcina@gmail.com)
  - Finlay Maguire [finlaymaguire@gmail.com](mailto:finlaymaguire@gmail.com)
  - [Luis Pedro Coelho](https://luispedro.org) [luis@luispedro.org](mailto:luis@luispedro.org)

  *: current maintainer


pkgId: 245ed351b3c4e534e2bbe89fa75a9ab625cbb6cccbdada30c60009aab5530680
name: python-argo-ams-library
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: A simple python library for interacting with the ARGO Messaging Service
url: https://github.com/ARGOeu/argo-ams-library
rpm_license: ASL 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argo-ams-library-0.6.2-1.src.rpm
checksum_type: sha256
description:
  <img src="https://jenkins.argo.grnet.gr/static/3c75a153/images/headshot.png" alt="Jenkins" width="25"/> [![Build Status](https://jenkins.argo.grnet.gr/job/argo-ams-library_devel/badge/icon)](https://jenkins.argo.grnet.gr/job/argo-ams-library_devel)

  A simple python library for interacting with the ARGO Messaging Service.

  The Messaging Services is implemented as a Publish/Subscribe Service. Instead of focusing on a single Messaging API specification for handling the logic of publishing/subscribing to the broker network the API focuses on creating nodes of Publishers and Subscribers as a Service.

  In the Publish/Subscribe paradigm, Publishers are users/systems that can send messages to named-channels called Topics. Subscribers are users/systems that create Subscriptions to specific topics and receive messages.

  You may find more information about [the ARGO Messaging Service documentation](http://argoeu.github.io/messaging/v1/)



  Library is tested and should work with Python versions 2.7, 3.6, 3.7, 3.8, 3.9, 3.10, 3.11 running on CentOS 7, Rocky 8 and Rocky 9 releases.

  RPM packages are prepared for CentOS and Rocky releases and you may find it and download it from ARGO Repository. PyPI packages are prepared as well.

  RPM production packages:

  * http://rpm-repo.argo.grnet.gr/ARGO/prod/centos7/
  * http://rpm-repo.argo.grnet.gr/ARGO/prod/rocky8/
  * http://rpm-repo.argo.grnet.gr/ARGO/prod/rocky9/

  RPM devel packages:

  * http://rpm-repo.argo.grnet.gr/ARGO/devel/centos7/
  * http://rpm-repo.argo.grnet.gr/ARGO/devel/rocky8/
  * http://rpm-repo.argo.grnet.gr/ARGO/devel/rocky9/

  PyPI package:

  https://pypi.org/project/argo-ams-library/



  The AMS library uses a valid AMS token to execute requests against the AMS cluster.
  This token can be provided with 2 ways:

  - Obtain a valid ams token and then use it when initializing the ams object.
  ```python
  from argo_ams_library import ArgoMessagingService
  ams = ArgoMessagingService(endpoint="ams_endpoint", project="ams_project", token="your_ams_token")
  ```

  - Use a valid certificate
  ```python
  from argo_ams_library import ArgoMessagingService
  ams = ArgoMessagingService(endpoint="ams_endpoint", project="ams_project", cert="/path/to/cert", key="/path/to/cert/key")
  ```
  The library will use the provided certificate to access the corresponding ams token through [the ARGO Authentication Service](https://github.com/ARGOeu/argo-api-authn) and then set the ams object's token field with the retrieved token.



  In the folder `examples`, you may find examples of using the library:

  - for publishing messages (`examples/publish.py`)
  - for consuming messages in pull mode (`examples/consume-pull.py`)
  - retry feature for publish/consume methods (`examples/retry.py`)



  This example explains how to publish messages in a topic with the use of the library. Topics are resources that can hold messages. Publishers (users/systems) can create topics on demand and name them (Usually with names that make sense and express the class of messages delivered in the topic). A topic name must be scoped to a project.

  You may find more information about [Topics in the ARGO Messaging Service documentation](http://argoeu.github.io/messaging/v1/api_topics/)

  ```
  publish.py  --host=[the FQDN of AMS Service]
  --token=[the user token]
  --project=[the name of your project registered in AMS Service]
  --topic=[the topic to publish your messages]
  ```



  This example explains how to consume messages from a predefined subscription with the use of the library. A subscription is a named resource representing the stream of messages from a single, specific topic, to be delivered to the subscribing application. A subscription name  must be scoped to a project. In pull delivery, your subscriber application initiates requests to the Pub/Sub server to retrieve messages. When you create a subscription, the system establishes a sync point. That is, your subscriber is guaranteed to receive any message published after this point. Messages published before the sync point may not be delivered.

  You may find more information about [Subscriptions in the ARGO Messaging Service documentation](http://argoeu.github.io/messaging/v1/api_subs/)

  ```
  consume-pull.py  --host=[the FQDN of AMS Service]
  --token=[the user token]
  --project=[the name of your project registered in AMS Service]
  --topic=[the topic from where the messages are delivered ]
  --subscription=[the subscription name to pull the messages]
  --nummsgs=[the num of messages to consume]

  ```



  Library has self-implemented HTTP request retry ability to seamlesssly interact with the ARGO Messaging service. Specifically, requests will be retried in case of:
  * timeouts from AMS (HTTP `408`) or load balancer (HTTP `408` and `504`)
  * load balancer HTTP `502`, `503`
  * connection related problems in the lower network layers

  It has two modes: static sleep and backoff. Examples are given in the in `examples/retry.py`.


pkgId: d1e480558b8fd22393272b1ac9bf948d7663ad064e0f61c009c37af0be6ad30b
name: python-argo-client
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: A JSON RPC client library.
url: https://pypi.org/project/argo-client/
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argo-client-0.0.13-1.src.rpm
checksum_type: sha256
description:
  A python library for client connections to [JSON RPC](https://www.jsonrpc.org/specification) servers, specifically designed with the Haskell [Argo](https://github.com/galoisinc/argo) sister library in mind.



  Currently argo is tested against Python 3.12.


pkgId: 9da0cc3236293574e20cb46caa2bc98740a447b0e93ff68093b54213e175d66d
name: python-argo-models
arch: src
version: 2.7.5
epoch: 0
release: 1
summary: Generated openapi models for Argo objects.
url: https://github.com/e2fyi/argo-models
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argo-models-2.7.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/e2fyi/argo-models.svg?branch=master)](https://travis-ci.org/e2fyi/argo-models)
  [![PyPI version](https://badge.fury.io/py/argo-models.svg)](https://badge.fury.io/py/argo-models)
  [![Downloads](https://pepy.tech/badge/argo-models/month)](https://pepy.tech/project/argo-models/month)

  `argo-models` is a `argo` namespaced package with the `argo.models` subpackage
  which contains the generated OpenAPI models from [Argo](https://github.com/argoproj/argo).

  Documentations can be found at https://argo-models.readthedocs.io/en/latest/

  ```bash
  pip install argo-models
  ```

  ```py
  from argo.models import V1alpha1ArtifactLocation, V1alpha1S3Artifact
  from kubernetes.client.models import V1SecretKeySelector


  access_key_secret = V1SecretKeySelector(name="s3_secret", key="accesskey")
  secret_key_secret = V1SecretKeySelector(name="s3_secret", key="secretkey")


  s3_artifact = V1alpha1S3Artifact(
      bucket="foobar",
      endpoint="s3.amazonaws.com"
      insecure=False,
      access_key_secret=access_key_secret,
      secret_key_secret=secret_key_secret,
      key=""
  )


  artifact_location = V1alpha1ArtifactLocation(s3=s3_artifact)

  ```



  To generate the latest models, update `version.txt` with the desired argo release
  (e.g. `2.3.0-rc3`) and then run `./generate-api.sh`.

  To release new version to pypi, create a release with the corresponding version tag (e.g. `v2.2.1`). Travis will automatically publish the package.

  > NOTE:
  >
  > `version.txt` should hold the current/latest argo version to be generated, as it
  > is also used by `setup.py` as the `argo-models` package version.
  >
  > Please install [@openapitools/openapi-generator-cli](https://www.npmjs.com/package/@openapitools/openapi-generator-cli) to
  > generate the openapi specs.



  This package is licensed under [Apache-2.0](./LICENSE) and is a derivative of the [Argo project](https://github.com/argoproj/argo) using [OpenAPI generator](https://github.com/OpenAPITools/openapi-generator).


pkgId: 1a1bf6f26f9b03fe9f0092e25a81855b44ea4a4b8c3454265e995691aadf3be6
name: python-argo-workflows
arch: src
version: 6.5.10
epoch: 0
release: 1
summary: Argo Workflows API
url: https://pypi.org/project/argo-workflows/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argo-workflows-6.5.10-1.src.rpm
checksum_type: sha256
description:
      Argo Workflows is an open source container-native workflow engine for orchestrating parallel jobs on Kubernetes. For more information, please see https://argo-workflows.readthedocs.io/en/release-3.5/  # noqa: E501


pkgId: 1f98f74e7a98c6a95c7ebb4c037562d14856705b114c1ea422f5fc71a7444ca8
name: python-argo-workflows
arch: src
version: 6.6.0
epoch: 0
release: 1
summary: Argo Workflows API
url: https://pypi.org/project/argo-workflows/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argo-workflows-6.6.0-1.src.rpm
checksum_type: sha256
description:
      Argo Workflows is an open source container-native workflow engine for orchestrating parallel jobs on Kubernetes. For more information, please see https://argo-workflows.readthedocs.io/en/latest/  # noqa: E501


pkgId: 676866ab62952fb803591e8b81664be7220b836f656cca712ac1695e05d46338
name: python-argopt
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: doc to argparse driven by docopt
url: https://github.com/casperdcl/argopt
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argopt-0.8.2-1.src.rpm
checksum_type: sha256
description:
  doc to ``argparse`` driven by ``docopt``
  |Py-Versions| |PyPI| |Conda-Forge|
  |Build-Status| |Coverage-Status| |Branch-Coverage-Status| |Codacy-Grade| |Libraries-Rank| |PyPI-Downloads|
  |LICENCE| |OpenHub-Status| |Gift-Casper|
  Define your command line interface (CLI) from a docstring (rather than the
  other way around). Because it's easy. It's quick. Painless. Then focus on
  what's actually important - using the arguments in the rest of your program.
  The problem is that this is not always flexible. Still need all the features of
  `argparse`? Now have the best of both worlds... all the extension such as
  `shtab <https://github.com/iterative/shtab>`__ or
  `Gooey <https://github.com/chriskiehl/Gooey>`__ but with the simple syntax of


pkgId: 937c7b4fc4c24a0a5f08f62f5d8a576d8ef114c1a3f710d5201400338b60ef05
name: python-argos-monitoring
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Distributed supervision tool for HTTP.
url: https://pypi.org/project/argos-monitoring/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argos-monitoring-0.5.0-1.src.rpm
checksum_type: sha256
description:
  A monitoring and status board for your websites.

  ![Screenshot of Argos’ status page](docs/dashboard.jpg)

  1. Define a list of websites to monitor
  2. Specify a list of checks to run on these websites.
  3. Argos will run the checks periodically and alert you if something goes wrong.

  Internally, a HTTP API is exposed, and a job queue is used to distribute the checks to the agents.

  - [Online documentation](https://argos-monitoring.framasoft.org/)
  - [Issue tracker](https://framagit.org/framasoft/framaspace/argos/-/issues)



  - **Python**: 3.11+
  - **Backends**: SQLite (development), PostgreSQL 14+ (production)



  Copyright © 2023 Alexis Métaireau, Framasoft

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU Affero 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 Affero General Public License](LICENSE) for more details.


pkgId: 32622dfefd165ce908b8e12e734477944323f206acb8049df185b4ea27099c26
name: python-argos-spacy-compatibility
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Compatiblity fix for argostranslate. Should no longer be required post 1.9.7
url: https://pypi.org/project/argos-spacy-compatibility/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argos-spacy-compatibility-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [Demo](https://libretranslate.com) | [Website](https://www.argosopentech.com) | [Docs](https://argos-translate.readthedocs.io) |  [Forum](https://community.libretranslate.com/c/argos-translate/5) | [GitHub](https://github.com/argosopentech/argos-translate) | [PyPI](https://pypi.org/project/argostranslate/)

  **Open-source offline translation library written in Python**

  Argos Translate uses [OpenNMT](https://opennmt.net/) for translations and can be used as either a Python library, command-line, or GUI application. Argos Translate supports installing language model packages which are zip archives with a ".argosmodel" extension containing the data needed for translation. [LibreTranslate](https://libretranslate.com) is an API and web-app built on top of Argos Translate.

  Argos Translate also manages automatically pivoting through intermediate languages to translate between languages that don't have a direct translation between them installed. For example, if you have a es → en and en → fr translation installed you are able to translate from es → fr as if you had that translation installed. This allows for translating between a wide variety of languages at the cost of some loss of translation quality.


  Arabic, Azerbaijani, Catalan, Chinese, Czech, Danish, Dutch, English, Esperanto, Finnish, French, German, Greek, Hebrew, Hindi, Hungarian, Indonesian, Irish, Italian, Japanese, Korean, Malay, Persian, Polish, Portuguese, Russian, Slovak, Spanish, Swedish, Turkish, Ukrainian, and more

  [Request a language](https://github.com/argosopentech/argos-translate/discussions/91)



  Argos Translate is available from [PyPI](https://pypi.org/project/argostranslate/) and can be easily installed or updated with [pip](https://pip.pypa.io/en/stable/installation/).

  ```
  pip install argostranslate
  ```

  Install [GUI](https://github.com/argosopentech/argos-translate-gui):
  ```
  pip install argostranslategui
  ```



  Download a copy of this repo and install with pip.

  ```
  git clone https://github.com/argosopentech/argos-translate.git
  cd argos-translate
  virtualenv env
  source env/bin/activate
  pip install -e .
  ```




  ```python
  import argostranslate.package
  import argostranslate.translate

  from_code = "en"
  to_code = "es"


  argostranslate.package.update_package_index()
  available_packages = argostranslate.package.get_available_packages()
  package_to_install = next(
      filter(
          lambda x: x.from_code == from_code and x.to_code == to_code, available_packages
      )
  )
  argostranslate.package.install_from_path(package_to_install.download())


  translatedText = argostranslate.translate.translate("Hello World", from_code, to_code)
  print(translatedText)

  ```


  ```
  argospm update
  argospm install translate-en_de
  argos-translate --from en --to de "Hello World!"


  ```

  Install all translation packages:
  ```
  argospm install translate
  ```


  ![Web App Screenshot](img/WebAppScreenshot.png)



  ```javascript
  const res = await fetch("https://translate.argosopentech.com/translate", {
  	method: "POST",
  	body: JSON.stringify({
  		q: "Hello!",
  		source: "en",
  		target: "es"
  	}),
  	headers: {
  		"Content-Type": "application/json"}
  	});

  console.log(await res.json());

  {
      "translatedText": "¡Hola!"
  }
  ```


  The GUI code is in a [separate repository](https://github.com/argosopentech/argos-translate-gui).

  ![Screenshot](/img/Screenshot.png)
  ![Screenshot2](/img/Screenshot2.png)



  - [Browse](https://www.argosopentech.com/argospm/index/)
  - [P2P download with BitTorrent](/p2p/README.md)
  - [Training scripts](https://github.com/argosopentech/argos-train)
  - [Google Drive download](https://drive.google.com/drive/folders/11wxM3Ze7NCgOk_tdtRjwet10DmtvFu3i)




  To enable GPU support, you need to set the `ARGOS_DEVICE_TYPE` env variable to `cuda` or `auto`.

  ```
  $ ARGOS_DEVICE_TYPE=cuda argos-translate --from-lang en --to-lang es "Hello World"
  Hola Mundo
  ```

  The above env variable passes the device type to [CTranslate2](https://github.com/OpenNMT/CTranslate2).


  The [translate-html](https://github.com/argosopentech/translate-html) library is built on top of Argos Translate and [Beautiful Soup](https://beautiful-soup-4.readthedocs.io/en/latest/) and parses and translates HTML. The LibreTranslate API also has support for translating HTML.



  The [argos-translate-files](https://github.com/LibreTranslate/argos-translate-files) library is built on top of Argos Translate and parses and translates files. The LibreTranslate API also has support for translating files.



  ``` shell
  pip uninstall argostranslate
  ```

  You may choose to also delete temporary and cached files:

  ``` shell
  rm -r ~/.local/cache/argos-translate
  rm -r ~/.local/share/argos-translate
  ```


  - [LibreTranslate-py](https://github.com/argosopentech/LibreTranslate-py) - Python bindings for LibreTranslate
  - [MetalTranslate](https://github.com/argosopentech/MetalTranslate) - Customizable translation in C++
  - [LibreTranslate/Locomotive](https://github.com/LibreTranslate/Locomotive) - Toolkit for training/converting LibreTranslate compatible language models 🚂
  - [DesktopTranslator](https://github.com/ymoslem/DesktopTranslator) - [OpenNMT](https://opennmt.net/) based translation application
  - [LibreTranslate-rs](https://github.com/grantshandy/libretranslate-rs) - LibreTranslate Rust bindings
  - [LibreTranslate Go](https://github.com/SnakeSel/libretranslate) - LibreTranslate Golang bindings
  - [LibreTranslate Java](https://github.com/dynomake/libretranslate-java) - LibreTranslate Java bindings
  - [LibreTranslator](https://gitlab.com/BeowuIf/libretranslator) - LibreTranslate Android app
  - [LiTranslate](https://community.libretranslate.com/t/litranslate-ios-app/333) - iOS LibreTranslate client


  Contributions are welcome! Available issues are on the [GitHub issues page](https://github.com/argosopentech/argos-translate/issues). Contributions of code, data, and pre-trained models can all be accepted.


  For support please use the [LibreTranslate Forum](https://community.libretranslate.com/c/argos-translate/5) or [GitHub Issues](https://github.com/argosopentech/argos-translate/issues).

  For questions about [CTranslate2](https://github.com/OpenNMT/CTranslate2) or general machine translation research the [OpenNMT Forum](https://forum.opennmt.net/) is a good resource.


  Custom models trained on your own data are available for $1000/language (negotiable).

  [I am also available for hire](https://www.argosopentech.com/about/) to do support, consulting, or custom software development.


  If you find this software useful donations are greatly appreciated and help to make this project sustainable.
  - [GitHub Sponsor](https://github.com/sponsors/argosopentech)
  - [PayPal](https://www.paypal.com/biz/fund?id=MCCFG437JP9PJ)
  - Bitcoin: 16UJrmSEGojFPaqjTGpuSMNhNRSsnspFJT
  - Ethereum: argosopentech.eth
  - Litecoin: MCwu7RRWeCRJdsv2bXGj2nnL1xYxDBvwW5
  - BCH: bitcoincash:qzvpxe8y5kq45kahqkyv3p88sjrhlymj2v6xdrj3cv

  Paid supporters receive priority support.


  You can help support Argos Translate financially by purchasing hosting through these referral links:
  - [Vast.ai](http://vast.ai/?ref=24817) - Cheap GPU rentals
  - [DigitalOcean](https://m.do.co/c/a1af57be6e3f) - Best all around hosting
  - [Sharktech](https://portal.sharktech.net/aff.php?aff=1181) - Cheap bandwith
  - [Time4VPS](https://www.time4vps.com/?affid=6929) - Cheap storage


  Contributions are welcome! Bug reports, pull requests, documentation writing, and feature ideas are all appreciated.


  Argos Translate is dual licensed under either the [MIT License](https://github.com/argosopentech/argos-translate/blob/master/LICENSE) or [Creative Commons CC0](https://creativecommons.org/share-your-work/public-domain/cc0/).


pkgId: d570daba0e2d5e7fef8f29c2123026c5b26d20f88ae71ca2d0e0b07741c9e4de
name: python-argosim
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Radio interferometric simulations package for the ARGOS radio telescope.
url: https://pypi.org/project/argosim/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argosim-0.0.1-1.src.rpm
checksum_type: sha256
description:
  Argosim is a python package for radio interferometric observation simulations and image reconstruction.

  See the [documentation](https://argos-telescope.github.io/argosim/) for installing and running Argosim.

  Software developed at the [CosmoStat](https://www.cosmostat.org/) laboratory, CEA, Paris-Saclay, for the [ARGOS](https://argos-telescope.eu) telescope.


pkgId: 0db2e796f8274bb88b0173fa6d102d67d186dc44521a174cc73cf3d39cf4cf13
name: python-argparse
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Python command-line parsing library
url: https://github.com/ThomasWaldmann/argparse/
rpm_license: Python Software Foundation License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse-1.4.0-1.src.rpm
checksum_type: sha256
description:
  argparse should work on Python >= 2.3, it was tested on:
  * 2.3, 2.4, 2.5, 2.6 and 2.7
  * 3.1, 3.2, 3.3, 3.4


pkgId: bc8112f4899b8f9adce67fb19d760e85206bf5f0f50afbe5259dc596c9d98c5a
name: python-argparse-addons
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: Additional argparse types and actions.
url: https://github.com/eerimoq/argparse_addons
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse-addons-0.12.0-1.src.rpm
checksum_type: sha256
description:
  Additional Python argparse types and actions.
  Project homepage: https://github.com/eerimoq/argparse_addons


pkgId: 99397c3a18a0b08c23ff4bc2f3a974c19bf10b744ae9f56bc0f1cb0f63a76ed0
name: python-argparse-color-formatter
arch: src
version: 2.0.0.post1
epoch: 0
release: 1
url: https://pypi.org/project/argparse-color-formatter/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse-color-formatter-2.0.0.post1-1.src.rpm
checksum_type: sha256
summary:
  A `formatter_class` for `argparse` that deals with ANSI colour escapes. Specifically, this formatter does not count escape characters as displayed characters when wrapping `argparse`'s help text into the terminal.

description:
  A [`formatter_class` for `argparse`](https://docs.python.org/3/library/argparse.html#formatter-class) that deals with ANSI colour escapes. Specifically, this formatter does not count escape characters as displayed characters when wrapping argparse's help text into the terminal.

  ![That script's help text is so cool...](https://docs.arrai.dev/argparse-color-formatter/readme/acf.png "That script's help text is so cool...")

  [![PYPI](https://img.shields.io/pypi/v/argparse-color-formatter?style=for-the-badge)](https://pypi.org/project/argparse-color-formatter/)

  ![Tests](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python312.svg) [![Coverage](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python312.coverage.svg)](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/htmlcov_python312/)

  ![Tests](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python311.svg) [![Coverage](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python311.coverage.svg)](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/htmlcov_python311/)

  ![Tests](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python310.svg) [![Coverage](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python310.coverage.svg)](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/htmlcov_python310/)

  ![Tests](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python39.svg) [![Coverage](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python39.coverage.svg)](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/htmlcov_python39/)

  ![Tests](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python38.svg) [![Coverage](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python38.coverage.svg)](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/htmlcov_python38/)

  ![Tests](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python37.svg) [![Coverage](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/python37.coverage.svg)](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/htmlcov_python37/)

  ![Flake8](https://docs.arrai.dev/argparse-color-formatter/artifacts/main/flake8.svg)



  ```shell
  $ pip install argparse-color-formatter
  ```



  Pass in `argparse_color_formatter.ColorHelpFormatter` to a new argument parser as `formatter_class`

  ```python
  import argparse
  from argparse_color_formatter import ColorHelpFormatter

  parser = argparse.ArgumentParser(
      formatter_class=ColorHelpFormatter
  )
  ```





  ```shell
  pipenv install --dev
  pre-commit install
  pre-commit install --hook-type commit-msg
  ```



  ```shell
  pipenv run build
  ```



  ```shell
  pipenv run test
  ```


  ANSI colour escapes using this library's new `ColorHelpFormatter`:
  ![after screenshot](https://docs.arrai.dev/argparse-color-formatter/readme/after.png)

  ANSI colour escapes using the default `HelpFormatter`:
  ![before screenshot](https://docs.arrai.dev/argparse-color-formatter/readme/before.png)

rpm_license:
  BSD 3-Clause License  Copyright (c) 2017, Emergence by Design Inc. 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 copyright holder 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: 061b0c7c1de594a46f18b66b98bb46d151d1ee9ebde0bf3aa8afeaee37f19431
name: python-argparse-ext
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: argparse extension;
url: https://github.com/cykerway/argparse-ext
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse-ext-1.4.2-1.src.rpm
checksum_type: sha256
description:
  argparse extension;



      pip install argparse-ext



  Copyright (C) 2018-2021 Cyker Way

  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/>.


pkgId: cfd7c9474e45d18d5cb68f409d7ad3d480701f681265977d8d3d7861ba742bed
name: python-argparse-formatter
arch: src
version: 1.4
epoch: 0
release: 1
summary: Paragraph-preserving formatter for argparse
url: https://github.com/davesteele/argparse_formatter
rpm_license: GPL 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse-formatter-1.4-1.src.rpm
checksum_type: sha256
description:
  This project is a simple Python module that provides
  [**argparse**](https://docs.python.org/3/library/argparse.html) formatters
  that support more flexibility in the display of description, help, and epilog
  text.


pkgId: a09d00eeb09749602246f6ba83680e0e5c0b33b7d8453869df26a4002eaa24b9
name: python-argparse-helper
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: Yet another argparse helper: complex sub-command trees made simple
url: https://github.com/jan-g/{name}
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse-helper-0.9.3-1.src.rpm
checksum_type: sha256
description:
  Writing complex subcommand parsers using `argparse` is certainly possible, but it involves a lot
  of laborious repetition.

  This library provides a small wrapper around `argparse` that adds a convenience method. That
  lets you specify a sequence of words that form a command, together with flags - and the
  definitions of those flags are passed at the same time.

      parser = ArgumentParser()
      parser.add_command("foo bar baz --json",
                         func=lambda *args: print("foo-bar-baz"),
                         json=dict(default=False, action="store_true"),
                         )
      parser.add_command("foo bar quux",
                         func=lambda *args: print("foo-bar-quux"),
                         )

  The `func` parameter will be set on the resulting namespace. Note, there is no particular requirement
  for the arguments that must be passed to `func` - this is down to the library user to define.

  Additionally, a new `argparse.Action` subclass is provided, `OptionalOverride`. This supports
  having the *same* flag appear in a global position and be repeated by a subcommand. It works
  well - in as much as defaults set by the global position won't be re-set in the subordinate
  position.

      parser.add_command("--flag", flag=dict(default="foo"))
      parser.add_command("xyzzy --flag", flag=dict(action=OptionalOverride))

  Where a flag is repeated in an `add_command` call, the second and subsequent values receive an
  `OptionalOveride` setting automatically.

      parser.add_command("--glob xyzzy --glob", glob=dict(action=AtMostOnce))
      

  `AtMostOnce` is supplied as an action type; this causes an explicit error (rather than
  just overriding the previous value) if a flag is specified more than once.

  We also have `AppendN(t)` as an action type. It works like `Append`, but the type constructor
  `t` is applied to its collected argument(s) before the result is appended to the list.


pkgId: 971dd89da85f2747545ef3fae61509e7dbde391bf5b453bcfe9566e22e299c0a
name: python-argparse-manpage
arch: src
version: 4.6
epoch: 0
release: 1
summary: Build manual page from python's ArgumentParser object.
url: https://github.com/praiskup/argparse-manpage
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse-manpage-4.6-1.src.rpm
checksum_type: sha256
description:
  Avoid documenting your Python script arguments on two places!  This is typically
  done in an [argparse.ArgumentParser][ap-docs] help configuration (`help=`,
  `description=`, etc.), and also in a manually crafted manual page.

  The good thing about an `ArgumentParser` objects is that it actually provides
  a traversable "tree-like" structure, with all the necessary info needed to
  **automatically generate** documentation, for example in a *groff* typesetting
  system (manual pages).  And this is where this project can help.

  There are two supported ways to generate the manual, either script it using the
  installed command `argparse-manpage`, or via `setup.py build` automation (with a
  slight bonus of automatic manual page installation with `setup.py install`).




  Most of the (meta)data is stored in the `ArgumentParser` object, therefore
  `argparse-manpage` needs to know its location—it can be either the object
  itself, or a method to call to get the object [^1].

  On top of this, several manual page fields (like *author* or *project* name)
  need to be specified, either on command-line or via `setup.py` metadata.




  See the following example:

  ```
  $ argparse-manpage --pyfile ./pythonfile.py --function get_parser \
                     --author "John --author-email doe@example.com" \
                     --project-name myproject --url https://pagure.io/myproject \
  > cool-manpage.1
  ```

  This (a) processes the `./pythonfile.py`, (b) calls the `get_parser` inside to
  obtain the `ArgumentParser` instance, (c) transforms it into a manual page and
  (d) stores it into the `cool-manpage.1` file.

  Alternatively those options above can be combined with

  - option `--module mymodule.main`, to load a Python module `mymodule.main`
    from `PYTHONPATH`, or
  - `--object parser_object_name` if the `parser_object_name` is a global
    variable.




  First, you need to declare in `pyproject.toml` that argparse-manpage is needed
  at build-time and use the setuptools.builds_meta` backend:

  ```toml
  [build-system]
  requires = ["argparse-manpage[setuptools]"]
  build-backend = "setuptools.build_meta"
  ```

  Alternatively, you can place the `build_manpages` (sub)directory from this
  project somewhere onto `PYTHONPATH` so you can use it at build time.  For
  example:

  ```bash
  git submodule add --name build_manpages https://github.com/praiskup/build_manpages
  git submodule update --init
  ```

  Then in `pyproject.toml` (re)define `cmdclass` commands:

  ```toml
  [tool.setuptools.cmdclass]
  build_py = "build_manpages.build_py"
  install = "build_manpages.install"
  build_manpages = "build_manpages.build_manpages"
  ```

  And specify the list of built manual pages:

  ```toml
  [tool.build_manpages]
  manpages = [
      "man/foo.1:object=parser:pyfile=bin/foo.py",
      "man/bar.1:function=get_parser:pyfile=bin/bar",
      "man/baz.1:function=get_parser:pyfile=bin/bar:prog=baz",
  ]
  ```



  In your `setup.py` use pattern like:

  ```python
  [...]
  from build_manpages import build_manpages, get_build_py_cmd, get_install_cmd

  setup(
    [...]
    cmdclass={
        'build_manpages': build_manpages,
        
        
        'build_py': get_build_py_cmd(),
        'install': get_install_cmd(),
    }
  )
  ```

  And in `setup.cfg` configure the manual pages you want to automatically
  generate and install:

  ```
  [build_manpages]
  manpages =
      man/foo.1:object=parser:pyfile=bin/foo.py
      man/bar.1:function=get_parser:pyfile=bin/bar
      man/baz.1:function=get_parser:pyfile=bin/bar:prog=baz
  ```



  The format of those lines is a colon separated list of arguments/options.  The
  first argument determines the filename of the generated manual page.  Then
  follows a list of options of format `option=value`.  Supported values are:

  - pyfile - what python file the argparse object resides in
  - object - the name of arparse object in "pyfile" to import
  - function - the name of function in pyfile to call to get the argparse object
  - format - format of the generated man page: `pretty` (default), `single-commands-section`
  - author - author of the program; can be specified multiple times
  - description - description of the program, used in the NAME section, after the
      leading 'name - ' part, see man (7) man-pages for more info
  - project_name - name of the project the program is part of
  - version - version of the project, visible in manual page footer
  - prog - value that substitutes %prog in ArgumentParser's usage
  - url - link to project download page
  - manual_section - section of the manual, by default 1, see man (7) man-pages
      for more info about existing sections
  - manual_title - the title of the manual, by default "Generated Python Manual",
      see man (7) man-pages for more instructions
  - include - a file of extra material to include; see below for the format
  - manfile - a file containing a complete man page that just needs to be installed
      (such files must also be listed in `MANIFEST.in`)

  The values from setup.cfg override values from setup.py's setup(). Note that
  when `manfile` is set for a particular page, no other option is allowed.

  Then run `setup.py build_manpages` to build a manpages for your project.  Also,
  if you used `get_build_py` helper, `setup.py build` then transitively builds the
  manual pages.



  The include file format is based on GNU `help2man`'s `--include` format.

  The format is simple:

  ```
  [section]
  text

  /pattern/
  text
  ```

  Blocks of verbatim *roff text are inserted into the output either at
  the start of the given `section` (case insensitive), or after a
  paragraph matching `pattern`, a Python regular expression.

  Lines before the first section are silently ignored and may be used for
  comments and the like.

  Other sections are prepended to the automatically produced output for the
  standard sections given above, or included near the bottom of the man page,
  before the `AUTHOR` section, in the order they occur in the include file.

  Placement of the text within the section may be explicitly requested by
  using the syntax `[<section]`, `[=section]` or `[>section]` to place the
  additional text before, in place of, or after the default output
  respectively.



  This package is distributed [in PyPI][pypi-page], can be installed by:

      $ pip install argparse-manpage

  It can simply downloaded, or distributed as a git submodule (see above).




  The Git snapshot RPMs–pre-release version automatically built from the `main`
  branch–are available in Fedora Copr build system

  [![build status](https://copr.fedorainfracloud.org/coprs/praiskup/argparse-manpage-ci/package/argparse-manpage/status_image/last_build.png)](https://copr.fedorainfracloud.org/coprs/praiskup/argparse-manpage-ci/)

  The `argparse-manpage` project is provided natively on many distributions:

  ![build status](https://repology.org/badge/vertical-allrepos/python:argparse-manpage.svg?exclude_unsupported=1&header=argparse-manpage)

  Try your package manager directly (e.g. on Fedora `dnf install -y
  argparse-manpage`).




  The initial code was developed for CrunchyFrog, a database query tool for Gnome.
  The [frog] is now retired and [RunSQLRun] is it's successor.  Then, the
  `build_manpage` command was developed in [andialbrecht] and edited slightly
  in [gabrielegiammatteo].  There's even an [old blog post] about this command.

  Since some useful work has been done in [python pull request], the code from the
  PR has been used here too.

  Later more options and flexibility has been implemented in this fork, with the
  help of many contributors.  Thank you!

  Historically, `build_manpage` setup.py command was provided (mostly for
  `OptionParser`).  Later we migrated to more versatile `build_manpages` command.
  But the old variant is still [supported](examples/old\_format/README.md).



  This work is released under the terms of the Apache License v2.0.
  See LICENSE for details.


  [^1]: `argparse-manpage` needs to process the location (file/module) via Python
        interpreter, and thus please avoid side-effects (typically, the `main.py`
        files need to use the `if __name__ == "__main__"` condition, and similar).

  [gabrielegiammatteo]: https://github.com/andialbrecht/build\_manpage
  [andialbrecht]: https://github.com/andialbrecht/build\_manpage
  [frog]: http://crunchyfrog.googlecode.com/svn/
  [RunSQLRun]: https://github.com/andialbrecht/runsqlrun
  [old blog post]: https://andialbrecht.wordpress.com/2009/03/17/creating-a-man-page-with-distutils-and-optparse/
  [python pull request]: https://github.com/python/cpython/pull/1169
  [ap-docs]: https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser
  [pypi-page]: https://pypi.org/project/argparse-manpage/


pkgId: 688e6e08f156e070d808a45dbdd0eb032b5611d774fabf4d7265486ace889ec0
name: python-argparse-prompt
arch: src
version: 0.0.5
epoch: 0
release: 1
url: https://github.com/MelbourneGenomics/ArgparsePrompt
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse-prompt-0.0.5-1.src.rpm
checksum_type: sha256
summary:
  Wrapper for the built-in Argparse, allowing missing command-line arguments to be filled in by the user via interactive prompts

description:
  ArgparsePrompt is a wrapper for the built-in Argparse, allowing missing command-line arguments to be filled in by the
  user via interactive prompts


  ArgparsePrompt can be installed using pip:
  ```bash
  pip install argparse_prompt
  ```




  The only public interface of this module is the `PromptParser` class, which is a subclass of Python's
  [ArgumentParser](https://docs.python.org/3/library/argparse.html). Use this class in exactly the same way that you would
  use ArgumentParser, except that, if any argument does not have a specified `default` value, and a value is not provided
  for it on the commandline, the `PromptParser` will prompt for a value for this argument using `input()`, which is read
  from stdin.

  Consider the code below (taken from one of the unit tests):

  ```python
  from argparse_prompt import PromptParser

  parser = PromptParser()
  parser.add_argument('--argument', '-a', help='An argument you could provide', default='foo')
  print(parser.parse_args().argument)
  ```

  If you run this script with a value for `argument`, the parsing will run as normal:
  ```
  $ python test/default_parser.py --argument 12
  12
  ```

  However if you don't specify a value for `arg`, the parser will prompt you for one
  ```
  $ python test/default_parser.py
  argument: An argument you could provide
  > (foo) car
  car
  ```


  Since this argument has a default value, you can also just hit enter and this value will be used automatically:
  ```
  python test/default_parser.py
  argument: An argument you could provide
  > (foo)
  foo
  ```


  You can also specify a type for the argument in the normal way:

  ```python
  from argparse_prompt import PromptParser

  parser = PromptParser()
  parser.add_argument('--argument', '-a', help='An argument you could provide', type=int)
  print(parser.parse_args().argument)
  ```

  If you do, this type checking will be used for the value you enter at the prompt:
  ```
  $ python test/typed_parser.py
  argument: An argument you could provide
  abc
  Argument "argument" was given a value not of type <class 'int'>
  ```


  For arguments that need to be secure, such as passwords, secret keys etc, you can use `secure=True` when defining your
  argument. This will cause whatever the user inputs for that field to be hidden from the terminal, in the same way that
  `git`, or `ssh` hides the password input.

  For example:
  ```python
  parser.add_argument('--password', '-p', help='A very secret password', secure=True)
  ```



  If you use the `prompt` argument to `add_argument`, parsing will be disabled:

  ```python
  parser.add_argument('--argument', '-a', help='An argument you could provide', default='foo', prompt=False)
  ```

  Also, if you want to disable all prompting (for an automated script, for example), just set the `ARGPARSE_PROMPT_AUTO` to
  a truthy value:
  ```bash
  ARGPARSE_PROMPT_AUTO=1 python test/default_parser.py
  ```


pkgId: d7d3d8b1d9b38e1a1c0be942c38e95d32efc241fc1a58ec420bd64caae00fea8
name: python-argparse-to-md
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Pre-commit hook to generate markdown documentation from argparse-based CLI scripts
url: https://pypi.org/project/argparse-to-md/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse-to-md-0.3.1-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/argparse-to-md?labelColor=383838)
   [![CI](https://github.com/igrr/argparse_to_md/actions/workflows/main.yml/badge.svg)](https://github.com/igrr/argparse_to_md/actions/workflows/main.yml) ![Python](https://img.shields.io/badge/dynamic/yaml?url=https://raw.githubusercontent.com/igrr/argparse_to_md/main/.github/workflows/main.yml&query=$.jobs['test'].strategy.matrix['python-version']&label=Python&logo=python&color=3366ff&logoColor=ffcc00&labelColor=383838)

  `argparse_to_md` tool helps developers of command-line tools written in Python keep the usage instructions in their README.md files up to date. It can automatically update usage instructions in README.md file based on `argparse` parsers defined in the code. It can be invoked as a pre-commit hook or as a standalone script.



  1. In your CLI tool, move creation of `argparse.ArgumentParser` into a separate function:
      ```python
      import argparse

      def create_parser() -> argparse.ArgumentParser:
          parser = argparse.ArgumentParser(prog='mytool')
          parser.add_argument(...)
          return parser

      def main():
          parser = create_parser()
          parser.parse_args()
      ```
  2. In your README.md file, add a section where the usage would be described. Replace `mytool` with the fully qualified name of the module and `create_parser` with the name of the function which returns an `argparse.ArgumentParser`.
      ```md
      

      <!-- argparse_to_md:mytool:create_parser -->
      <!-- argparse_to_md_end -->
      ```
  3. Run `argparse_to_md`, either manually or as a pre-commit hook. The README.md file will be updated, the usage instructions will appear inside this section.
  4. Whenever you modify the parser in your code, re-run `argparse_to_md`, or let the pre-commit hook run. README.md will be updated with the new usage instructions.



  Add to your .pre-commit-config.yaml. This pre-commit hook will be triggered by changes to all Python or Markdown files, and it will edit README.md:

  ```yaml
  repos:
  -   repo: https://github.com/igrr/argparse_to_md.git
      rev: v0.3.1
      hooks:
      -   id: argparse_to_md
  ```

  If you need to adjust the list of files to be updated, specify them in `args:` as follows:

  ```yaml
  repos:
  -   repo: https://github.com/igrr/argparse_to_md.git
      rev: v0.3.1
      hooks:
      -   id: argparse_to_md
          args: [--input=README.md, --input=README_CN.md]
  ```



  You can also use argparse_to_md from the command line:

  <!-- argparse_to_md:argparse_to_md.__main__:get_parser -->
  Usage:
  ```
  argparse_to_md [-h] [-i INPUT [INPUT ...]]
                            [--extra-sys-path EXTRA_SYS_PATH [EXTRA_SYS_PATH ...]] [--check]
                            [--version]
  ```

  Optional arguments:
  - `-i INPUT [INPUT ...]`, `--input INPUT [INPUT ...]`: Markdown file to update (can be specified multiple times).
  - `--extra-sys-path EXTRA_SYS_PATH [EXTRA_SYS_PATH ...]`: Extra paths to add to PYTHONPATH before loading the module
  - `--check`: Check if the files need to be updated, but don't modify them. Non-zero exit code is returned if any file needs to be updated.
  - `--version`: show program's version number and exit
  <!-- argparse_to_md_end -->



  - https://github.com/9999years/argdown/ — Generates Markdown and RestructuredText from argparse-based parsers.
  - https://github.com/alex-rudakov/sphinx-argparse — Sphinx extension for documenting argparse-based parsers.
  - https://github.com/docopt/docopt — Inverse of the above, constructs a parser based on documentation.



  This tool is Copyright (c) 2024 Ivan Grokhotkov and distributed under the [MIT License](LICENSE).

rpm_license:
  MIT License  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: c096ffe1176faca7f8f054fbed76d2087b75547d0b8ee1db76305705278d79ea
name: python-argparse-tree
arch: src
version: 0.1.3.post6
epoch: 0
release: 1
summary: Split parse args into filesystem tree for complex projects.
url: https://github.com/bvraghav/argparse_tree
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse-tree-0.1.3.post6-1.src.rpm
checksum_type: sha256
description:
  Let the commandline arguments be distributed along the
  source directory, which can be collected into one with
  a single collection as a parent before initialising the
  command.




  ```shell
  pip install argparse_tree
  ```


  ```shell
  git clone "https://github.com/bvraghav/argparse_tree"
  cd argparse_tree
  pip install .
  ```



  A detailed usage can be found in the folder
  [`example`](./example). The crux of the matter is
  illustrated below:

  ```python
  parser = ArgumentParser(
    parents=collect_parsers(
      '*_style1.py', 'style2/*.py',
      parent_package = __package__
    ),
  )

  parser.add_argument(
    '-v', '--verbose', action='store_true',
    help="Verbosity switch."
  )

  add_commands(
    parser, '*_command.py',
    parent_package=__package__,
    action=load_module_subparser_action(
      '*_command.py', __package__
    ),
  )
  ```

  Inside of [`style2/generic.py`](./example/style2/generic.py)
  ```python
  parser.add_argument(
    '--style2', choices=collect_keys('style2/*.py'),
    action=load_module_action('*.py', __package__)
  )
  ```

  Four functions namely,
  [`collect_parsers`](./argparse_tree/utils.py#L13),
  [`collect_keys`](./argparse_tree/utils.py#L73),
  [`add_commands`](./argparse_tree/utils.py#L90), and
  [`load_module_subparser_action`](./argparse_tree/load_module_action.py#L31)
  are utilized to achieve the desired behaviour, that is

  1. To have a set of argument groups collected from a
     set of files following a convenvention in names;
  2. To allow, non-homogeneity in such groups; and
  3. To extend this behaviour for sub-parsers.


  A set of files, each containing a function
  [`cli_args`](./example/alpha_style1.py#L1) that returns
  parser information, are grouped together using a
  certain convention in their file names, for example,
  using a suffix say,`*_data.py` may represent different
  datasets. The arguments generic to all datasets may be
  written to `generic_data.py`. They are all collected
  using the function `collect_parsers`.

  The convention may have simple been altered to follow a
  prefixed format, say `data/*.py` --- should work
  equally well.



  ```python
  collect_parsers(
    *patterns,
    root=None,
    parent_package=None
  )
  ```

  Glob the `ROOT` folder with `PATTERNS`, one at a time,
  and collect their parsers. If not specified, `ROOT` is
  computed, using the `inspect` API, to be the folder
  where the caller script resides.

  `PARENT_PACKAGE` is the name of package corresponding
  to `ROOT` folder. If not specified, `PARENT_PACKAGE` is
  not used.



  ```python
  collect_keys(
    pattern,
    root=None,
    mod_to_key=utils.mod_to_key
  )
  ```
  Glob the `ROOT` folder with `PATTERN` and create a key
  corresponding to each module. Key is computed using
  `MOD_TO_KEY` functional, which follows the same
  signature as
  [`utils.mod_to_key`](./argparse_tree/utils.py#L47).




  ```python
  add_commands(
    parser, pattern,
    *,
    root=None,
    parent_package=None,
    dest='command',
    action=None,
    mod_to_key=utils.mod_to_key
  )
  ```

  Create subcommands to cli using `PARSER`, one
  corresponding to each `PATTERN`. Command name is
  computed using `MOD_TO_KEY` functional, which follows
  the same signature as
  [`utils.mod_to_key`](./argparse_tree/utils.py#L47).

  The same convention as
  [`collect_parsers`](#collect_parsers) is followed for
  `PATTERN`, `ROOT`, and `PARENT_PACKAGE`.

  `DEST` and `ACTION` are forwarded to
  [`argparse.ArgumentParser.add_subparsers`](https://docs.python.org/3/library/argparse.html?highlight=argparse%20argumentparser%20add_subparsers#argparse.ArgumentParser.add_subparsers).




  ```python
  load_module_subparser_action(
    pattern,
    package=None,
    key_to_mod=utils.key_to_mod
  )
  ```

  Create an `argparse.Action` to load a module
  corresponding to a user-given key, based on `PATTERN`,
  and `PACKAGE` using a decoder `KEY_TO_MOD` functional,
  which follows the same signature as
  [`utils.key_to_mod`](./argparse_tree/utils.py#L110).

  In case it is desirable to load a module corresponding
  to value in user-specified argument, at the time of
  parsing the args, use this as value of `action` in
  [`argparser.ArgumentParser.add_argument`](https://docs.python.org/3/library/argparse.html?highlight=argparse%20argumentparser%20add_argument#argparse.ArgumentParser.add_argument).


  **Version >= 0.1.3** : Code issues separate actions
  corresponding to `store` action and `subparser` action,
  as `load_module_store_action` and
  `load_module_subparser_action`
  respectively. *BREAKING*: `load_module_action` is an
  alias for `load_module_store_action`.




  The core idea behind this project is to exploit [this
  argparse
  functionality](https://docs.python.org/3/library/argparse.html?highlight=parents#parents):

  ```python
  local_parser = argparse.ArgumentParser()
  local_parser.add_argument('--foo')

  global_parser = argparse.ArgumentParser(
    parents=[local_parser, ...]
  )
  ```

  The proof of concept can be seen in [this
  code](./scratchpad/proof_of_concept.py).

  For example in machine learning training routines,
  there can be many models, many solvers, many datasets,
  each with different set of options. We can have
  something like:

  ```python


  def cli_parser() :
    from argparse import ArgumentParser
    parser = ArgumentParser(add_help=False)
    group = parser.add_argument_group(
      'Generic Dataset Options'
    )
    group.add_arguemnt('--foo')

    return parser

  ```

  And similarly add cli parsers for `a_dataset.py`,
  `b_dataset.py` and so forth. Here, we have followed the
  norm of suffxing `dataset` to each python module. We
  can collect them into the global parser as follows:

  ```python

  from argparse import
  import argparse_tree as Atree

  def cli_parser() :
    parser = ArgumentParser(
      parents=Atree.collect(['*_dataset.py'])
    )
    parser.add_argument(
      '--verbose', help="Verbosity switch."
    )

    return parser
  ```

  We can also have an option of collection from any
  pattern. For example,

  + `data/*.py` for any module in folder `data`.
  + Any other pattern compatible with
    [`pathllib.Path.glob`](https://docs.python.org/3/library/pathlib.html?highlight=glob#pathlib.Path.glob)







  Here is an experiment which has an affirmative result.
  ```python


  class A :
    def __init__(self) :
      from pathlib import Path
      import inspect
      f = inspect.stack().pop(1)
      
      self.p = Path(f.filename)
  ```

  ```python


  from alpha import A
  print (A().p)
  ```

  The idea is the use this behaviour and search the
  caller's parent path for the relevant module patterns.

  This may be interesting; but it is always better to
  provide an unambiguous argument instead of inspect!


pkgId: 30beeb83519338fbf12c42a8be565c1667d8a9be7387dbf3ee39961587d60e9d
name: python-argparse_pydantic
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: argparse config with pydantic model.
url: https://github.com/ayasyrev/argparse_pydantic
rpm_license: apache2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparse_pydantic-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Config for argparse with pydantic model.

  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/argparse_pydantic)](https://pypi.org/project/argparse_pydantic/)
  [![PyPI version](https://img.shields.io/pypi/v/argparse_pydantic?color=blue)](https://pypi.org/project/argparse_pydantic/)
  [![Tests](https://github.com/ayasyrev/argparse_pydantic/workflows/Tests/badge.svg)](https://github.com/ayasyrev/argparse_pydantic/actions?workflow=Tests)  [![Codecov](https://codecov.io/gh/ayasyrev/argparse_pydantic/branch/main/graph/badge.svg)](https://codecov.io/gh/ayasyrev/argparse_pydantic)

  Simple wrapper for python argparse.
  Use pydantic model for you app config.
  It gives you typed config instead of default Namespace from argparse.

  Tested on python 3.8 - 3.12

  WIP



  Install from pypi:

  `pip install argparse_pydantic`

  Or install from github repo:

  `pip install git+https://github.com/ayasyrev/argparse_pydantic.git`



  We use python argparse to parse arguments from command line.
  So, just create parser as usual:


  ```python
  import argparse

  parser = argparse.ArgumentParser(prog="MyApp")
  ```

  Than create config for you app with Pydantic.


  ```python
  from pydantic import  BaseModel


  class AppCfg(BaseModel):
      echo: str
  ```

  Now add argument to parser from you config.


  ```python
  from argparse_pydantic import add_args_from_model

  parser = add_args_from_model(parser, AppCfg)
  ```

  So we got parser with arguments from config.

  It exactly like parser made classic way:
  `parser.add_argument("echo")`

  Now we can use parser in you script usual way - `parser.parse_args()`

  <!-- termynal -->
  ```
  $ python my_app.py -h
  usage: MyApp [-h] echo

  positional arguments:
    echo

  options:
    -h, --help  show this help message and exit
  ```

  Parse command line as usual.


  ```python
  args = parser.parse_args(["argument from command line"])
  ```

  When we parse command line, we got Namespace object.
  Bat we can convert it to config object.


  ```python
  from argparse_pydantic import create_model_obj

  cfg = create_model_obj(AppCfg, args)
  ```

  Now we got  config with type checks / validation ont type hinting when use it at IDE.


  ```python
  cfg
  ```
  <details open> <summary>output</summary>
      <pre>AppCfg(echo='argument from command line')</pre>
  </details>




  ```python
  cfg.echo
  ```
  <details open> <summary>output</summary>
      <pre>'argument from command line'</pre>
  </details>





  We can use undefined arguments as positional or optional (but required).


  ```python
  class AppCfg2(BaseModel):
      arg_int: int
      arg_float: float = 0.1
  ```


  ```python
  parser = argparse.ArgumentParser(prog="MyApp")
  parser = add_args_from_model(parser, AppCfg2, undefined_positional=False)
  ```

  <!-- termynal -->
  ```
  $ python my_app.py -h
  usage: MyApp [-h] --arg_int ARG_INT [--arg_float ARG_FLOAT]

  options:
    -h, --help            show this help message and exit
    --arg_int ARG_INT
    --arg_float ARG_FLOAT
  ```



  And we can add type hints to help message from our config.



  ```python
  parser = argparse.ArgumentParser(prog="MyApp")
  parser = add_args_from_model(
      parser,
      AppCfg2,
      undefined_positional=False,
      help_def_type=True,
  )
  ```

  <!-- termynal -->
  ```
  $ python my_app.py -h
  usage: MyApp [-h] --arg_int ARG_INT [--arg_float ARG_FLOAT]

  options:
    -h, --help            show this help message and exit
    --arg_int ARG_INT     [int]
    --arg_float ARG_FLOAT
                          [float] default: 0.1
  ```



  You can see examples at `examples` folder - Same examples as at python docs and tutorial for argparse.


pkgId: f3b69a708a13215ee2f3ca30aaad82dde765d2563faca7c9cbf0a5060781eea7
name: python-argparsedirs
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A simple extension for argparse to allow readable/writeable dir types
url: https://pypi.org/project/argparsedirs/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argparsedirs-0.2.0-1.src.rpm
checksum_type: sha256
description:
  This is a very simple action for argparse that allows
  you to specify a readable or a writeable directory as an `argparse` action.
  I found it on StackOverflow years ago and used it since then,
  unfortunately I cannot find the original source now.

  I guess it would be best to have this added directly into `argparse` anyway.


  Just import and use as an action:

      import argparse
      import argparsedirs

      argparser = argparse.ArgumentParser()

      argparser.add_argument('indir', type=argparsedirs.ReadableDirType)
      argparser.add_argument('outdir', type=argparsedirs.WriteableDirType)

      args = argparser.parse_args()


pkgId: cd74a1ebfce95d4a5cabe6809dcf66dd6b42fbc00cc1b7a2335b86b44c2c86d1
name: python-argpi
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Next Level Argument Parser
url: https://pypi.org/project/argpi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argpi-1.1.0-1.src.rpm
checksum_type: sha256
description:
  `argpi` revolutionizes argument parsing in python by introducing a registration based system. This allows users to implement argument parsing in one line of code. Any type of argument can be defined other than the conventional `--` and `-` prefix type arguments. For example, arguments can be of the type `argument1` or `_argument1` or any keyword you set. There is not restrictions on the short form of the argument. You can have `--argument1` as the long form while `_arg1` as the shorter form. This brings a lot of flexibility and customization to the users.



  - [Features](#features)
  - [Installation](#installation)
  - [Usage and Examples](#usage-and-examples)
  - [Contributing](#contributing)
  - [License](#license)



  * `argpi`'s one line implementation and fault finding system helps users maintain readability and reliability in their code.
  * Flexibility and customization while defining arguments.
  * Automatic help text generation.
  * Prep and Exec based argument parsing helps users to create complex argument structures.



  ```bash
  pip install argpi
  ```



  Using `argpi` is pretty simple. `argpi` was made keeping in mind the concepts of Object Oriented Programming and therefore, it is recommended to create a class for your argument preparations and executions separately.

  What the above statement means is that suppose you have an argument, say, `--install` which is the base argument for installing something. Now, there are different flag type arguments (meaning, let's say, `--install-with-pip` or `--install-with-conda` or `--install-with-git`, which are used to determine some boolean or case based code execution), or some arguments which take some value (like `--install-path` which takes a path as an argument). These are termed as `prep` arguments while `--install` is the `exec` argument. Before `--install`'s backend code execution, all `prep`s will be performed. Let us see how we can do this in code.

  To begin, we need to import `Definition` and `Pathways` classes from `argpi` module.

  ```python
  from argpi import Definition, Pathways
  ```

  All the argument definitions are stored in the `Definition` class. Let us add the definitions from our example above.

  ```python
  def_obj = Definition([
      {
          'name': 'Installation Argument',
          'value': '--install',
          'short': '_i',
          'description': 'Install something\nSyntax: <script_name> --install'
      },
      {
          'name': 'Install with pip',
          'value': '--install-with-pip',
          'short': '_ip',
          'description': 'Install with pip\nSyntax: <script_name> --install-with-pip'
      },
      {
          'name': 'Install with conda',
          'value': '--install-with-conda',
          'short': '_ic',
          'description': 'Install with conda\nSyntax: <script_name> --install-with-conda'
      },
      {
          'name': 'Install path',
          'value': '--install-path',
          'short': '_ip',
          'description': 'Install path\nSyntax: <script_name> --install-path <path>'
      },
  ])
  ```

  Once we have our definitions ready, we can use the `Pathways` class to auto-capture the arguments and register preps and execs.

  Now, for our example, `--install` is the exec argument and the rest are prep arguments. We will create a class for our preparations and executions.

  For preparations, we will create a class `Configurations` and for executions, we will create a class `Drivers`.

  > **Note:** You can name the classes anything you want. `Configurations` class basically contains information on how a particular method (let's say, for `--install`) will be executed.
  Understand it this way, the method we will define for `--install` can go several ways. The user may want to use `pip` or `conda` or `git` to install something. This is where the `Configurations` class will be used.
  `Configurations` class will have methods and attributes which will store our conditional variables such as which installer to use: `pip`, `conda`, `git` etc and the path to install the software.

  ```python
  from typing import Union

  class Configurations:
      def __init__(self) -> None:
          
          self.pip: bool = False
          self.conda: bool = False
          self.git: bool = False
          self.path: Union[str, None] = None

      def set_pip(self) -> None:
          self.pip = True

      def set_conda(self) -> None:
          self.conda = True

      def set_git(self) -> None:
          self.git = True

      def set_path(self, path: str) -> None:
          self.path = path
  ```

  ```python
  class Drivers:
      @staticmethod
      def install(configurations: Configurations) -> None:
          if configurations.pip:
              print(f"Installing with pip to {configurations.path}")
          elif configurations.conda:
              print(f"Installing with conda to {configurations.path}")
          elif configurations.git:
              print(f"Installing with git to {configurations.path}")

          
  ```

  Once we have our classes ready, we can use the `Pathways` class to auto-capture the arguments and register preps and execs.

  ```python

  configurations = Configurations()

  pathways = PathWays(definition=def_obj)




  ```

  Once we have our `Pathways` object ready, we can register our preps and execs. All arguments except `--install` are prep arguments.

  While registering, we can provide a function which will be called if the argument is present. The important point to note here is that the arguments that are passed to your provided functions can either be defined by you or can be captured from the command line. This is what makes `argpi` better than other argument parsing libraries.

  The `pathways.register` function has 2 signatures, where the first one is where you give your own function and own arguments. The second one is where you provide your own function but let `argpi` capture the values provided to the argument by the user and pass it to the function.

  There are 3 ways you can choose to capture values from the command line:

  - `Single`: This is used when you know that the argument will take only one value and whatever it is, you want to pass it to the function.
  - `Till Next`: This is used when you know that the argument will take multiple values but you want to stop capturing when the next argument is encountered.
  - `Till Last`: This is used when you know that the argument will take multiple values and you know for sure this argument will be the last argument passed by the user.

  Do not worry, If you are unsure about `Till Next` and `Till Last`, just use `Till Next` and it will automatically detect if the argument is the last argument or not and act accordingly.

  ```python

  pathways.register(
      argument='--install-with-pip',
      function=configurations.set_pip,
      type='PREP',
      arguments=(True,), # we are passing our own arguments to the function
  )

  pathways.register(
      argument='--install-with-conda',
      function=configurations.set_conda,
      type='PREP',
      arguments=(True,),
  )

  pathways.register(
      argument='--install-with-git',
      function=configurations.set_git,
      type='PREP',
      arguments=(True,),
  )

  pathways.register(
      argument='--install-path',
      function=configurations.set_path,
      type='PREP',
      what_value_expected='Single', # we want one value from the command line
  )
  ```

  Now, let us define the `--install` argument.

  ```python
  pathways.register(
      argument='--install',
      function=Drivers.install,
      type='EXEC',
      arguments=(configurations,),
  )
  ```

  Once all definitions and registrations are done, we can now orchestrate the pathway preps and executions.

  ```python
  pathways.orchestrate
  ```

  This will first perform all preps which will set the variables in the `Configurations` class and then it will perform the execution which will use these variables to execute the code.

  Note that the executions will only be performed if the registered argument is present in the command line, else nothing will happen.

  Also, the `pathways.orchestrate` method automatically validates all preparations and executions. It will raise an error if anything fails.



  Contributions are welcome! Please open an issue or submit a pull request if you have any suggestions or improvements.



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


pkgId: 4b19e30a6dd95c7d921625b7b43194c82ddbfc214b1e19625f21b0a8dd9ac449
name: python-args-to-db
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Runs python script in argument combinations and produces dataset of all results.
url: https://github.com/schnellerhase/args_to_db
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-args-to-db-0.1.7-1.src.rpm
checksum_type: sha256
description:
  ```sh
  pip install args_to_db
  ```



  <span style="color:#4078c0">args_to_db</span> is an attempt to generalize and simplify the process of running a programm in different modes or configurations and combining the resulting datasets to allow for further analysis.

  The functionality is separated into three different (independently usable) parts:


  Given a programm/script which is highly dependent on parameters and arguments, which we want to run for swarm of different settings, yielding datasets for further analysis.

  Argument construction is made easy with the interfaces `cmd, option, flag` which are the intended way of constructing `Command` and `CommandList` objects.

  ```python
  from args_to_db import cmd, flag, option

  py = cmd('python')


  script = cmd('script.py')


  data = option('--input', ['file1.csv', 'file2.csv'])



  opt_flags = flag('-O') + flag('-r')





  log_flag = flag('--log', vary=False)


  cmds = py + script + data + opt_flags + log_flag








  ```

  The `CommandList` objects are arrays of commands (which themselves are arrays again), they behave like normal python arrays except for the differnt usage of the `+` and `+=` operators.


  A given `CommandList` object may then be executed with `run`, providing the user with a live interface in the terminal of execution states and parallelisation control of the execution.
  ```python
  run(cmds, threads=4)

  ```


  Data may be produced by the programm/script independently of being called with <span style="color:#4078c0">args_to_db</span>, which is therefore completely optional.
  But functionality is provided to make data collection and combination straight forward and as easy as possible for fast results.

  ```python
  args = argparse.ArgumentParser().parse_args()
  config = config_from_args(args, __file__)
  write_results(config, {'solver_solve_time': solve_time})
  ```

  This produces an output which is then later on combined with the others by the `run` task - note the native support of `argparse` objects which are often used for argument/parameter parsing.


pkgId: bc5e5c7b4069d6bc6963e02dea5a9aa84111512a611f7468c7404924e2489ebf
name: python-argschema
arch: src
version: 3.0.4
epoch: 0
release: 1
url: https://github.com/AllenInstitute/argschema
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argschema-3.0.4-1.src.rpm
checksum_type: sha256
summary:
  "a wrapper for setting up modules that can have parameters specified by command line arguments, json_files, or dictionary objects. Providing a common wrapper for data processing modules."


pkgId: b5c3ee45295fe6aa7167bf139d2d4e7fb91967b26701657c27c33d437c9fbfac
name: python-argsense
arch: src
version: 0.5.8
epoch: 0
release: 1
summary: New command line interface based on Python Rich library.
url: https://github.com/likianta/argsense-cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argsense-0.5.8-1.src.rpm
checksum_type: sha256
description:
  **argsense** is a command line interface made with Python.

  ![group help](.assets/examples/classic/20220615143658.jpg)

  ![minimal help](.assets/examples/classic/20220615143730.jpg)

  ![command help](.assets/examples/classic/20220615143751.jpg)

  ![group help (ex)](.assets/examples/classic/20220615143817.jpg)



  > Currently this section is under construction.
  >
  > Please check the folder ./examples for your reference.



  > I picked several official examples from [Typer](https://typer.tiangolo.com/) project to show differences by code to code.



  **typer**

  ```python
  import typer

  def main(name: str):
      typer.echo(f"Hello {name}")

  if __name__ == "__main__":
      typer.run(main)
  ```

  **argsense**

  ```python
  from argsense import cli

  @cli.cmd()
  def main(name: str):
      print(f'Hello {name}')

  if __name__ == '__main__':
      cli.run(main)
  ```

  ![](.assets/20220618124348.png)



  **typer**

  ```python
  import typer

  app = typer.Typer()

  @app.command()
  def hello(name: str):
      typer.echo(f"Hello {name}")

  @app.command()
  def goodbye(name: str, formal: bool = False):
      if formal:
          typer.echo(f"Goodbye Ms. {name}. Have a good day.")
      else:
          typer.echo(f"Bye {name}!")

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

  **argsense**

  ```python
  from argsense import cli

  @cli.cmd()
  def hello(name: str):
      print(f'Hello {name}')

  @cli.cmd()
  def goodbye(name: str, formal: bool = False):
      if formal:
          print(f'Goodbye Ms. {name}. Have a good day.')
      else:
          print(f'Bye {name}!')

  if __name__ == '__main__':
      cli.run()
  ```

  ![](.assets/snip-20220618-124911.png)

  ![](.assets/snip-20220618-125016.png)



  **typer**

  ```python
  import typer
  from typing import Optional

  def main(name: Optional[str] = typer.Argument(None)):
      if name is None:
          typer.echo("Hello World!")
      else:
          typer.echo(f"Hello {name}")

  if __name__ == "__main__":
      typer.run(main)
  ```

  **argsense**

  ```python
  """
  Argsense (v0.3.0) doesn't have a conception of 'optional' argument, an argument
  must be required, or it is considered as an `option`.
  We will bring the support in next version (v0.4.0+).
  """
  from argsense import cli

  @cli.cmd()
  def main(name: str = None):
      if name is None:
          print('Hello World!')
      else:
          print(f'Hello {name}')

  if __name__ == '__main__':
      cli.run(main)
  ```

  *You have to use `--name` to pass the 'optional argument', otherwise it raises an error.*

  ![](.assets/snip-20220618-130345.png)



  **typer**

  ```python
  import typer

  def main(name: str = typer.Argument("Wade Wilson")):
      typer.echo(f"Hello {name}")

  if __name__ == "__main__":
      typer.run(main)
  ```

  **argsense**

  ```python
  """
  Argsense (v0.3.0) doesn't have a conception of 'optional' argument, an argument
  must be required, or it is considered as an `option`.
  We will bring the support in next version (v0.4.0+).
  """
  from argsense import cli

  @cli.cmd()
  def main(name='Wade Wilson'):
      print(f'Hello {name}')

  if __name__ == '__main__':
      cli.run(main)
  ```

  ![](.assets/snip-20220618-131756.png)



  **typer**

  ```python
  import random
  import typer

  def get_name():
      return random.choice(["Deadpool", "Rick", "Morty", "Hiro"])

  def main(name: str = typer.Argument(get_name)):
      typer.echo(f"Hello {name}")

  if __name__ == "__main__":
      typer.run(main)
  ```

  **argsense**

  ```python
  """
  Argsense doesn't have built in support for choices.
  Here is a workaround but not so good.
  """
  from argsense import cli

  @cli.cmd()
  def main(name: str):
      """
      args:
          name: The name should be one of the choices:
              - [red]Deadpool[/]
              - [green]Rick[/]
              - [yellow]Morty[/]
              - [cyan]Hiro[/]
      """
      if name not in ('Deadpool', 'Rick', 'Morty', 'Hiro'):
          print(f'The given name ({name}) is not on the list!')
          exit(1)
      print(f'Hello {name}')

  if __name__ == '__main__':
      cli.run(main)
  ```

  ![](.assets/snip-20220618-132948.png)



  The example shows:

  - Command description.
  - Long description that exceeds 80 characters one line (let's see how do we do line breaks).
  - Multiple lines of description.

  **typer**

  ```python
  import typer

  def main(
      name: str = typer.Argument(..., help="The name of the user to greet"),
      lastname: str = typer.Option(
          "", "--lastname",  "-l",
          help="Last name of person to greet."
      ),
      formal: bool = typer.Option(False, help="Say hi formally."),
  ):
      """
      Say hi to NAME very gently, like Dirk. Optionally with a --lastname/-l, like
      Wilson.

      If --formal is used, say hi very formally.
      """
      if formal:
          typer.echo(f"Good day Ms. {name} {lastname}.")
      else:
          typer.echo(f"Hello {name} {lastname}")

  if __name__ == "__main__":
      typer.run(main)
  ```

  **argsense**

  ```python
  from argsense import cli

  @cli.cmd()
  def main(name: str, lastname='', formal=False):
      """
      Say hi to [blue]NAME[/] very gently, like Dirk. Optionally with a -
      [dim]--lastname/-l[/], like Wilson.
      If [dim]--formal[/] is used, say hi very formally.

      args:
          name: The name of the user to greet.

      kwargs:
          lastname (-l): Last name of person to greet.
          formal: Say hi formally.
      """
      if formal:
          print(f'Good day Ms. {name} {lastname}.')
      else:
          print(f'Hello {name} {lastname}')

  if __name__ == '__main__':
      cli.run(main)
  ```

  ![](.assets/snip-20220618-135437.png)



  **typer**

  ```python
  import typer

  def main(
      name: str,
      email: str = typer.Option(..., prompt=True, confirmation_prompt=True)
  ):
      typer.echo(f"Hello {name}, your email is {email}")

  if __name__ == "__main__":
      typer.run(main)
  ```

  **argsense**

  ```python
  """
  Argsense doesn't have built in support for confirmation prompt.
  Here is a workaround but not so good.
  """
  from argsense import cli

  @cli.cmd()
  def main(name: str):
      email = input('Email: ')
      if input('Repeat for confirmation: ') != email:
          print('Email repetition failed.')
          exit(1)

      print(f'Hello {name}, your email is {email}')

  if __name__ == '__main__':
      cli.run(main)
  ```

  ![](.assets/snip-20220618-140432.png)

  <!-- Template

  **typer**

  ```python

  ```

  **argsense**

  ```python

  ```

  ![](.assets/)

  -->


pkgId: 73c219e577f6b0b418dd6e29d95f635b92f8afc86d66f15503a4f3812f081be5
name: python-argset
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Simple callable argument inspection & filtering
url: https://pypi.org/project/argset/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argset-0.1.1-1.src.rpm
checksum_type: sha256
description:
  ``argset`` requires Python 3.8 or higher.  Just use `pip
  <https://pip.pypa.io>`_ for Python 3 (You have pip, right?) to install
  ``argset`` and its dependencies::
      python3 -m pip install argset


pkgId: d2296ad72fa349eaf604f16394a38e714d2c9bffd61e765e3a3002ca4315e9a9
name: python-argshell
arch: src
version: 1.6.4
epoch: 0
release: 1
summary: Integrates the argparse and cmd modules.
url: https://github.com/matt-manes/argshell
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argshell-1.6.4-1.src.rpm
checksum_type: sha256
description:
  Rather than being limited to input strings, you can use `argparse` style parsers for shell commands.
  Create a function that instantiates an `ArgShellParser` instance, adds arguments, and then returns the `ArgShellParser` object.
  Then you can can decorate `do_*` functions using `with_parser()` to pass a `Namespace` object instead of a string.
  ![](assets/myshell_with_parser.svg)
  In terminal:
  ![](assets/add_help.svg)


pkgId: 2f1de0bbf1ae53bdaf110668c46a20f23567c028111bdcb694786e99d9869e6c
name: python-argsy
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Tiny wrapper for Python's `argparse` package with YAML-based cli configuration.
url: https://pypi.org/project/argsy/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argsy-1.0.3-1.src.rpm
checksum_type: sha256
description:
  Tiny wrapper for Python's `argparse` package with YAML-based cli configuration.



  The `argsy` package aims to make CLI argument configuration and parsing declarative and simple, while still leveraging Python's `argparse` package to handle the parsing details and user help messaging.

  Configuration supports declarative configuration of:

  1. top-level position args, options / flags
  2. a single tier of subcommands
  3. position args, options / flags for each subcommand
  4. support for setting default values for options / flags
  5. partial `nvars` support for capturing multiple input values
  6. support for the `action` directive (for things like toggling booleans)





  ```sh
  pip install argsy>=1.0.0
  ```



  CLI arguments are define as either:

  1. a YAML file or string, or
  2. a Python `dict` object


  ```yaml



  program:
    name: my_program
    descripton: "About what my_program does."
    args:
      option1:
        cmd_type: option
        flags: '-o|--option1'
        help: "Short text about the option."
        required: true
  ```

  ```python



  from argsy import Argsy

  argsy_parser = Argsy(config_file_name="my_cli_args.yml")
  parsed_args = argsy_parser.parse_args(sys.argv[1:])











  ```



  ```python



  from argsy import Argsy

  CLI_ARGS = """
  program:
    name: my_program
    descripton: "About what my_program does."
    args:
      option1:
        cmd_type: option
        flags: '-o|--option1'
        help: "Short text about the option."
        required: true
  """

  argsy_parser = Argsy(config_str=CLI_ARGS)
  parsed_args = argsy_parser.parse_args(sys.argv[1:])











  ```





  ```python



  from argsy import Argsy

  CLI_ARGS = dict(
      program=dict(
          name='my_program',
          description='About what my_program does.',
          args=dict(
              option1=dict(
                  cmd_type='option',
                  flags='-o|--option1',
                  help='Short text about the option.',
                  required=True
              )
          )
      )
  )

  argsy_parser = Argsy(config_dict=CLI_ARGS)
  parsed_args = argsy_parser.parse_args(sys.argv[1:])











  ```


pkgId: 7f5b173047ceab7e0e5301f304b8c15f9f8a6179c60ed24e65830e1c34fa8203
name: python-argsync
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Google Drive syncing script
url: https://github.com/hengtseChou/Auto-ReAuth-GSync
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argsync-1.2.1-1.src.rpm
checksum_type: sha256
description:
  A google drive sync tool that does not requires re-authorize.

  Some of the code was inspired by the [Google-Drive-sync](https://github.com/dtsvetkov1/Google-Drive-sync) project and refactored with PyDrive2 packages.



  It is recommanded to use pipx for an isolated environment.

  ```
  pipx install argsync
  ```



  1. Enable a Google Drive API over [GCP](https://console.cloud.google.com) and retrieve client id and client secret. Make sure you include the account you want to link with this tool when adding user for your API.
  2. Run `argsync setup`, and input your client id and client secret.
  3. When first time running `argsync push` or `argsync pull`, your will be redirected to authorization page. And that's it. From now on, the tool will refresh the credentials automatically.
  4. To switch for different account, run `argsync remove-profile` to remove the credentials and re-authorize with another account.



  This project is not widely tested. Some issues might occur. Anyone is welcomed to contribute.


pkgId: a48af34247b2c530070d4231f442f1c3cde36dbf5a81a59a433e32d29e208ea3
name: python-argteller
arch: src
version: 0.0b21
epoch: 0
release: 1
summary: Decorator for stylized interactive constructor using DSL and parser.
url: https://github.com/mozjay0619/argteller
rpm_license: DSB 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argteller-0.0b21-1.src.rpm
checksum_type: sha256
description:
  The argteller package provides the class and method decorators for a self-documenting, highly user-friendly interactive class object constructor. It will ask you for parameters that you need to provide, one by one. It will tell you the options that are available, and ask you for different parameters depending on what you have already provided. You can encode all of these in the custom DSL (domain specific language) script.


pkgId: f7a7af9926fb1be5fb981f5fda4d60bd41e31a6896d1a472019849156d1c9920
name: python-argtoml
arch: src
version: 0.5.7
epoch: 0
release: 1
url: https://pypi.org/project/argtoml/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argtoml-0.5.7-1.src.rpm
checksum_type: sha256
summary:
  Add the keys from a .toml file to your CLI as arguments. Their values default to the values in the .toml file.

description:
  The `argtoml` package wraps around `argparse`.
  It adds the content of a toml file to the cli options.
  After parsing, it creates a `types.SimpleNameSpace` object.



  Argtoml has no mandatory dependencies outside of pythons standard library.
  ```sh
  pip install argtoml
  ```
  You can optionally install `tomli_w` if you want to save your configuration at runtime.
  ```sh
  pip install 'argtoml[save]'
  ```



  If there's a `src/config.toml`

  ```toml
  debug = true
  home = "~"

  [project]
  author = "Jono"
  name = "argconfig"
  pyproject = "./pyproject.toml"
  ```

  and a `src/__main__.py`

  ```python
  from argtoml import parse_args  # , ArgumentParser

  args = parse_args(path=True)
  print(args.debug)
  print(args.home)
  print(args.project.author)
  print(args.project.name)
  print(args.project.pyproject)
  ```

  then the shell can look like

  ```sh
  $ pwd
  /home/jono/project
  $ python src/__main__.py --project.name argtoml --no-debug
  False
  /home/jono
  Jono
  argtoml
  /home/jono/project/pyproject.toml
  ```



  There is none, the code is not that large, but I expect you to only use:
  ```python
  parse_args(
    
    parser: Optional[argparse.ArumentParser] = None,
    
    description: str = "",
    
    toml_path: pathlib.Path = Path("config.toml"),
    
    toml_dir: Optional[TPath] = None,
    
    base_path: Union[Path, bool] = True,
    
    grandparent: bool = True
  ) -> SimpleNamespace

  save(args: Union[SimpleNamespace, dict], path: pathlib.Path):
    with open(path, "wb") as f:
      tomli_w.dump(args, f)
  ```




  You are encouraged to specify the location of the toml file when calling `parse_args` with an absolute path like this:

  ```python
  parse_args(toml_path="/home/user/dir/my_config.toml")
  ```

  If you provide a relative path, `argtoml` will look for `my_config.toml` in the package directory if the main file using `argtoml` is from a package, otherwise `argtoml` will look for `my_config.toml` in the same directory as the main file.
  This automatic toml-finding function might change in the future, so probably just provide absolute paths.



  If you want to ship a toml file with your package, make sure to [add the toml file to your package](https://setuptools.pypa.io/en/latest/userguide/datafiles.html).
  You should also call `parse_args` with a relative `toml_path`.



  This is a personal tool thus far, some idiosyncrasies remain:

  - Adding dotted arguments not present in the toml might break everything I didn't even test this.
  - I don't feel like adding other formats but toml.
  - I don't know if, in the above example, the user can do something like `python __main__.py --project {author="jo3"} --project.author jjj`, but it should crash if they do this.
  - Interpreting strings as paths _probably_ only works with unix style paths.



  - Add toml comments as argument descriptions.
  - Pretty-print the output of parse_args.
  - Load and merge multiple toml files


pkgId: cb7b497c1b1519adec1f6a6b19e6b4cfacf4a1d1d09b06ad5751e537339d1953
name: python-arguably
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: The best Python CLI library, arguably.
url: https://treykeown.github.io/arguably/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arguably-1.3.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
        <img alt="arguably logo" src="https://raw.githubusercontent.com/treykeown/arguably/main/etc/logo/arguably_black.png">
  </p>

  <p align="center">
      <em>
          The best Python CLI library, arguably.
      </em>
  </p>

  <p align="center">
      <a href="https://github.com/treykeown/arguably/actions/workflows/python-package.yml"><img src="https://github.com/treykeown/arguably/actions/workflows/python-package.yml/badge.svg" alt="Test status"></a>
      <a href="https://treykeown.github.io/arguably/coverage/"><img src="https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/treykeown/f493b14288af4e8358ea8578c393213a/raw/arguably-coverage-badge.json" alt="Code coverage"></a>
      <a href="https://pypi.org/project/arguably/"><img src="https://shields.io/pypi/pyversions/arguably" alt="Supported Python versions"></a>
      <a href="https://pypi.org/project/arguably/"><img src="https://shields.io/pypi/v/arguably" alt="PyPI version"></a>
  </p>
  <hr>

  `arguably` turns functions and docstrings into command line interfaces (CLIs). `arguably` has a tiny API and is
  extremely easy to integrate. You can also use it directly through `python3 -m arguably your_script.py`, more on that
  [here](#no-integration-required).

  To use `arguably` in a script, decorate any functions that should appear on the command line with `@arguably.command`,
  then call `arguably.run()`. If multiple functions are decorated, they'll all appear as subcommands. You can even have
  *multiple levels* of subcommands: `def s3__ls()` becomes `s3 ls`.

  <div align="right"><sub>
      <a href="https://github.com/treykeown/arguably/blob/main/etc/scripts/intro.py">[source]</a>
  </sub></div>

  ```python

  import arguably

  @arguably.command
  def some_function(required, not_required=2, *others: int, option: float = 3.14):
      """
      this function is on the command line!

      Args:
          required: a required argument
          not_required: this one isn't required, since it has a default value
          *others: all the other positional arguments go here
          option: [-x] keyword-only args are options, short name is in brackets
      """
      print(f"{required=}, {not_required=}, {others=}, {option=}")

  if __name__ == "__main__":
      arguably.run()
  ```

  <p align="center"><b><em>becomes</em></b></p>

  ```console
  user@machine:~$ ./intro.py -h
  usage: intro.py [-h] [-x OPTION] required [not-required] [others ...]

  this function is on the command line!

  positional arguments:
    required             a required argument (type: str)
    not-required         this one isn't required, since it has a default value (type: int, default: 2)
    others               all the other positional arguments go here (type: int)

  options:
    -h, --help           show this help message and exit
    -x, --option OPTION  keyword-only args are options, short name is in brackets (type: float, default: 3.14)
  ```

  Arguments to the CLI look just like calling the Python function.

  ```pycon
  >>> from intro import some_function
  >>> some_function("asdf", 0, 7, 8, 9, option=2.71)
  required='asdf', not_required=0, others=(7, 8, 9), option=2.71
  ```

  ```console
  user@machine:~$ ./intro.py asdf 0 7 8 9 --option 2.71
  required='asdf', not_required=0, others=(7, 8, 9), option=2.71
  ```

  `arguably` uses your docstrings to automatically generate help messages. It supports all major formats for docstrings:
  reStructuredText, Google, Numpydoc, and Epydoc.

  Type annotations are optional, but `arguably` can use them to automatically convert arguments. It has smart handling for
  mapping built-in types to the command line, including `tuple`, `list`, `enum.Enum`, and `enum.Flag`.

  There are also a few special behaviors you can attach to a parameter via `Annotated[]` and the `arguably.arg.*`
  functions. Using `arguably.arg.builder()`, you can even build an object to pass in from the command line (using syntax
  inspired by QEMU):

  <div align="right"><sub>
      <a href="https://github.com/treykeown/arguably/blob/main/etc/scripts/build.py">[source]</a>
  </sub></div>

  ```console
  user@machine:~$ ./build.py --nic tap,model=e1000 --nic user,hostfwd=tcp::10022-:22
  nic=[TapNic(model='e1000'), UserNic(hostfwd='tcp::10022-:22')]
  ```



  Don't want to write any code? Simply pass any Python script to `arguably` to give it a command line interface.

  <div align="right"><sub>
      <a href="https://github.com/treykeown/arguably/blob/main/etc/scripts/party-trick.py">[source]</a>
  </sub></div>

  ```console
  user@machine:~$ python3 -m arguably party-trick.py -h
  usage: party-trick [-h] [--version] command ...

  this is the docstring for the whole script

  positional arguments:
    command
      hello                   this is hello's docstring
      goodbye                 any function from a script can be called
      some-class              so can any __init__ for objects defined in the script
      some-class.func-static  a @staticmethod on a class can be called
      some-class.func-cls     so can a @classmethod

  options:
    -h, --help                show this help message and exit
    --version                 show program's version number and exit
  ```



  Install using `pip install arguably`. If you want to install using `conda`, please comment on
  [this issue](https://github.com/treykeown/arguably/issues/12).



  * Why arguably?: [https://treykeown.github.io/arguably/why/](https://treykeown.github.io/arguably/why/)
  * Examples: [https://treykeown.github.io/arguably/examples/](https://treykeown.github.io/arguably/examples/)
  * Tutorial: [https://treykeown.github.io/arguably/tutorial/intro/](https://treykeown.github.io/arguably/tutorial/intro/)
  * API Reference: [https://treykeown.github.io/arguably/api-reference/](https://treykeown.github.io/arguably/api-reference/)



  All of `arguably` is built on top of `argparse`. It has one dependency:

  * `docstring-parser` for parsing function docstrings



  Ideas and help are very much appreciated! There's a guide for getting started with contributing to `arguably` that shows
  you how to run tests and pre-commit hooks.

  * Contributing: [https://treykeown.github.io/arguably/contributing/](https://treykeown.github.io/arguably/contributing/)



  If you have any interest in these (either as a user or implementer), please leave a comment!

  * [#8 - Display all enum options in a command group](https://github.com/treykeown/arguably/issues/8)
  * [#9 - Both positive and negative boolean flags](https://github.com/treykeown/arguably/issues/9)
  * [#10 - Take inputs from environment variables](https://github.com/treykeown/arguably/issues/10)
  * [#13 - Implement config interface](https://github.com/treykeown/arguably/issues/13)
  * [#16 - Integration with rich for formatted CLI output](https://github.com/treykeown/arguably/issues/16)


pkgId: 96ba354cd419128127fda2757bfceaca3064dc94b678ccd81499355d2f9992a8
name: python-arguebuf
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: Create and analyze argument graphs and serialize them via Protobuf
url: https://github.com/recap-utr/arguebuf-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arguebuf-2.6.0-1.src.rpm
checksum_type: sha256
description:
  Arguebuf is a format for serializing argument graphs and specified using Protobuf.
  The complete specification and documentation is available at the [Buf Schema Registry](https://buf.build/recap/arg-services/docs/main:arg_services.graph.v1).
  While Protobuf automatically generates native code for all major programming languages (including Python), we created a custom implementation that provides some additional benefits, including:

  - The ability to import existing formats like [AIF](http://www.argumentinterchange.org), [SADFace](https://github.com/Open-Argumentation/SADFace), and a few others.
  - Export of Arguebuf graphs to AIF, [NetworkX](https://networkx.org), and [Graphviz](https://graphviz.org).
  - Integration with the popular NLP library [spaCy](http://spacy.io).
  - Various helper methods to programmatically manipulate/create argument graphs.
  - More pythonic interfaces than the regular code generated by `protoc`.

  You can easily install the library from [PyPI](https://pypi.org/project/arguebuf/) using pip. The documentation is hosted on [ReadTheDocs](https://arguebuf.readthedocs.io/en/latest/)



  We also offer some tools to simplify dealing with structured argument graphs.
  Among others, it is possible to convert graphs between different formats, translate them, and render images using graphviz.
  To use it, install the `cli` extras when installing the package.
  When using `pip`, this can be accomplished with

  `pip install arguebuf[cli]`

  Afterwards, you can execute it by calling `arguebuf`, for example:

  `arguebuf --help`

  Alternatively, you can use the Docker image available at `ghcr.io/recap-utr/arguebuf-python`.
  To use it, mount a folder to the container and pass the options as the command.

  `docker run --rm -it -v $(pwd)/data:/data ghcr.io/recap-utr/arguebuf-python:latest --help`

  If you use the `nix` package manager, you can run it as follows:

  `nix run github:recap-utr/arguebuf-python -- --help`



  An argument graph is way to represent _structured_ argumentation.
  What sets it apart from _unstructured_ argumentation (e.g., in newspaper articles) is that only the essential/argumentative parts of a text art part of this representation.
  These _units_ of argumentation are also called ADUs (argumentative discourse units).
  The length of ADUs can differ dramatically (depending on various factors like the context), meaning they might contain only a few words, a sentence, or even a whole paragraph.
  The structure of an argument is then represented through _relations_ between these units.
  For this purpose, they can be further subdivided into _claims_ and _premises_:
  A claim is a statement that is supported or attacked by one or multiple premises.
  At the same time, a claim may also function as a premise for another claim, making it possible to construct even complex _argument graphs_.
  One of the claims is called _major claim_ and represents the overall claim of the whole argument.
  In many cases (but not all), this major claim is located right at the top of the graph
  Here is a rather simple example.

  ![Exemplary argument graph](./assets/programmatic.png)

  Claims, premises and the major claim are represented as _atom nodes_ while relations between them are represented by _scheme nodes_.
  The set of nodes $V = A \cup S$ is composed of the set of atom nodes $A$ and the set of scheme nodes $S$.
  The supporting or attacking relations are encoded in a set of edges $E \subseteq V \times V \setminus A \times A$.
  Edges can be drawn between any type of nodes except for two atom nodes.
  For instance, it is possible to connect two scheme nodes to support or attack the _inference_ between two ADUs.
  Based on this, we define an argument graph $G$ as the triple $G = ( V , E , M )$.



  When importing this library, we recommend using an abbreviation such as `ag` (for _argument graph_).

  ```python
  import arguebuf as ag
  ```

  In the following, we will introduce the most important features of `arguebuf`.
  For more details including examples, check out our API documentation.



  We support multiple established formats to represent argument graphs: `AIF`, `OVA`, `SADFace`, `ArgDown`, `BRAT`, and `Kialo`.
  Given an input file, the library can automatically determine the correct format and convert it to a representation in the `arguebuf` format.
  One can either pass a string pointing to the file or a `pathlib.Path` object.

  ```python
  graph = ag.load.file("graph.json")
  ```

  It is also possible to load multiple graphs within a folder.
  Here, you need to pass the folder along with a [glob pattern](https://docs.python.org/3/library/fnmatch.html#module-fnmatch) for selecting the argument graphs.
  This also enables to recursively load all argument graphs from a common parent directory.

  ```python
  graphs = ag.load.folder("./data", "**/*.json")
  ```

  Since atom nodes contain textual information that may need to be analyzed using NLP techniques, we support passing a custom `nlp` function to these loader methods.
  This also makes it really easy to integrate the popular [`spacy` library](http://spacy.io) with `arguebuf` as all texts of atom nodes are automatically converted to a spacy `Doc`.

  ```python
  import spacy
  nlp = spacy.load("en_core_web_lg")
  graph = ag.load.file("graph.json", nlp=nlp)
  ```



  Instead of importing an existing graph, you can also create a new one using an object-oriented API using our library.
  To illustrate this, we generate a graph with two premises that are connected to a major claim.
  **Please note:** In case edges with nodes not yet contained in the graph are added, the respective nodes are added automatically.

  ```python
  graph = ag.Graph()

  premise1 = ag.AtomNode("Text of premise 1")
  premise2 = ag.AtomNode("Text of premise 2")
  claim = ag.AtomNode("Text of claim")

  scheme1 = ag.SchemeNode(ag.Support.DEFAULT)
  scheme2 = ag.SchemeNode(ag.Attack.DEFAULT)

  graph.add_edge(ag.Edge(premise1, scheme1))
  graph.add_edge(ag.Edge(scheme1, claim))
  graph.add_edge(ag.Edge(premise2, scheme2))
  graph.add_edge(ag.Edge(scheme2, claim))

  graph.major_claim = claim
  gv_graph = ag.dump.graphviz(graph)
  ag.render.graphviz(gv_graph, "./assets/programmatic.png")
  ```

  With this code, we get the following output

  ![Output of programmatic graph creation](./assets/programmatic.png)



  We support different output formats and integration with other libraries to ease the use of argument graphs.
  Have a look at the following code snippet to get an overview of the possibilities

  ```python

  dot = ag.dump.graphviz(graph)


  ag.render.graphviz(dot, "./graph.pdf")


  nx = ag.dump.networkx(graph)


  ag.dump.file(graph, "./graph.json")


  ag.dump.file(graph, "./graph.json", ag.GraphFormat.AIF)
  ```



  To pull the testing data, make sure to install [DVC](https://dvc.org/doc/install) and run `dvc pull` in the root directory of the repository.


pkgId: c82902b79533a27a27e4f7a3f130a411e4c04b4cd7abba9585db843447d276b0
name: python-argument-mining-framework
arch: src
version: 0.1.9
epoch: 0
release: 1
url: https://github.com/orgs/arg-tech/projects/2
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argument-mining-framework-0.1.9-1.src.rpm
checksum_type: sha256
summary:
  Argument Mining Framework (AMF) is a comprehensive toolkit designed to streamline and unify various argument mining modules into a single platform.

description:
  - **Argument Segmentator**: Identifies and segments arguments within argumentative text.
  - **Turninator**: Determines dialogue turns within conversations.
  - **Argument Relation Identification**: Identifies argument relationships between argument units.
  - **Argument Scheme Classification**: Classifies arguments based on predefined schemes.

  - [Documentation & Tutorials](https://wiki.arg.tech/books/amf)
  - [Online Demo](https://n8n.arg.tech/workflow/2)
  - [GitHub Source](https://github.com/arg-tech/amf)
  - [PyPI Package](https://pypi.org/project/argument-mining-framework/)

  1. [Overview](#overview)
  2. [Installation](#installation)
  3. [Components](#components)
      - [Argument Segmentor](#argument-segmentor)
      - [Turnator](#turnator)
      - [Argument Relation Identifier](#argument-relation-identifier)
      - [Argument Scheme Classifier](#argument-scheme-classifier)
  4. [Usage](#usage)
      - [Predictor Example](#predictor-example)
      - [Full Workflow Example](#full-workflow-example)
  5. [API Reference](#api-reference)
  6. [License](#license)

  AMF provides a modular approach to argument mining, integrating various components into a cohesive framework. The main features include:
  - **Argument Segmentator:** Identifies and segments arguments within argumentative text.
  - **Turninator:** Determines dialogue turns within conversations.
  - **Argument Relation Identification:** Identifies argument relationships between argument units.
  - **Argument Scheme Classification:** Classifies arguments based on predefined schemes.

  <details>
  <summary>Prerequisites & Setup</summary>
  Ensure you have Python installed on your system. AMF is compatible with Python 3.6 and above.

  It's recommended to create a virtual environment to manage dependencies:
  ```bash
  python -m venv amf-env
  ```
  Activate the virtual environment:
  - **Windows:**
    ```bash
    .\amf-env\Scripts\activate
    ```
  - **macOS/Linux:**
    ```bash
    source amf-env/bin/activate
    ```

  With the virtual environment activated, install AMF using pip:
  ```bash
  pip install argument-mining-framework
  ```
  This command will install the latest version of AMF along with its dependencies.
  </details>


  The Argument Segmentor component is responsible for detecting and segmenting arguments within text.
  [Read More](http://default-segmenter.amfws.arg.tech/segmenter-01)

  The Turnator identifies and segments dialogue turns, facilitating the analysis of conversations and interactions within texts. This module is particularly useful for dialogue-based datasets.
  [Read More](http://default-turninator.amfws.arg.tech/turninator-01)

  This component identifies and categorizes the relationships between argument units.
  [Read More](http://bert-te.amfws.arg.tech/bert-te)

  The Argument Scheme Classifier categorizes arguments based on predefined schemes, enabling structured argument analysis.
  [Read More](http://amf-schemes.amfws.arg.tech)


  Below is an example of how to use the AMF Predictor class to generate an argument map using an input provided based on AIF:
  ```python
  from argument_mining_framework.argument_relation.predictor import ArgumentRelationPredictor
  import json

  predictor = ArgumentRelationPredictor(model_type="dialogpt", variant="vanilla")

  xaif = {
      "AIF": {
          "nodes": [
              {"nodeID": "1", "text": "THANK YOU", "type": "I", "timestamp": "2016-10-31 17:17:34"},
              {"nodeID": "2", "text": "COOPER : THANK YOU", "type": "L", "timestamp": "2016-11-10 18:34:23"},
              
          ],
          "edges": [
              {"edgeID": "1", "fromID": "1", "toID": "20", "formEdgeID": "None"},
              {"edgeID": "2", "fromID": "20", "toID": "3", "formEdgeID": "None"}
              
          ],
          "locutions": [],
          "participants": []
      },
      "text": "people feel that they have been treated disrespectfully..."
  }

  xaif_json = json.dumps(xaif)

  result_map = predictor.argument_map(xaif_json)
  print(result_map)
  ```

  In this section, we demonstrate how to use multiple components of the AMF framework in a complete argument mining workflow. This example shows how to process a text input through the Turninator, Segmenter, Propositionalizer, and Argument Relation Predictor components and visualize the output.
  ```python
  from argument_mining_framework.loader import Module
  def process_pipeline(input_data):
      """Process input data through the entire pipeline."""
      
      turninator = load_amf_component('turninator')()
      segmenter = load_amf_component('segmenter')()
      propositionalizer = load_amf_component('propositionalizer')()
      argument_relation = load_amf_component('argument_relation', "dialogpt", "vanila")
      visualiser = load_amf_component('visualiser')()
      
      turninator_output = turninator.get_turns(input_data, True)
      print(f'Turninator output: {turninator_output}')
      
      segmenter_output = segmenter.get_segments(turninator_output)
      print(f'Segmenter output: {segmenter_output}')
      
      propositionalizer_output = propositionalizer.get_propositions(segmenter_output)
      print(f'Propositionalizer output: {propositionalizer_output}')
      
      argument_map_output = argument_relation.get_argument_map(propositionalizer_output)
      print(f'Argument relation prediction output: {argument_map_output}')
      
      print("Get all claims:")
      print(argument_relation.get_all_claims(argument_map_output))
      print("===============================================")
      print("Get evidence for claim:")
      print(argument_relation.get_evidence_for_claim(
          "But this isn’t the time for vaccine nationalism", argument_map_output))
      print("===============================================")
      print("Visualise the argument map")
      visualiser.visualise(argument_map_output)
  def main():
      
      input_data = (
          """Liam Halligan: Vaccines mark a major advance in human achievement since the """
          """enlightenment into the 19th Century and Britain’s been at the forefront of """
          """those achievements over the years and decades. But this isn’t the time for """
          """vaccine nationalism. I agree we should congratulate all the scientists, those """
          """in Belgium, the States, British scientists working in international teams here """
          """in the UK, with AstraZeneca.\n"""
          """Fiona Bruce: What about the logistical capabilities? They are obviously """
          """forefront now, now we’ve got a vaccine that’s been approved. It’s good -- I’m """
          """reassured that the British Army are going to be involved. They’re absolute world """
          """experts at rolling out things, complex logistic capabilities. This is probably """
          """going to be the biggest logistical exercise that our armed forces have undertaken """
          """since the Falklands War, which I’m old enough to remember, just about. So, as a """
          """neutral I’d like to see a lot of cross-party cooperation, and I’m encouraged with """
          """Sarah’s tone, everybody wants to see us getting on with it now. They don’t want """
          """to see competition on whose vaccine is best. There will be some instances where """
          """the Pfizer vaccine works better, another where you can’t have cold refrigeration, """
          """across the developing world as well, a cheaper vaccine like the AstraZeneca works """
          """better. Let’s keep our fingers crossed and hope we make a good job of this."""
      )
      process_pipeline(input_data)
  if __name__ == "__main__":
      main()
  ```

  For detailed API documentation, please refer to the [official documentation](https://wiki.arg.tech/books/amf) or
  check out the source code on [GitHub](https://github.com/arg-tech/amf).

  We welcome contributions from the community. Please read our [contributing guidelines](CONTRIBUTING.md) to get started.

  The AMF is licensed under the GNU General Public License (GPL) v3.0, with additional custom terms.

  - **Commercial Use**: To use this software for commercial purposes, please contact us for licensing arrangements.
  - **Non-commercial Use**: You may use, modify, and distribute this software freely for non-commercial purposes, as long as you adhere to the GPL v3.0 terms.
  For more detailed information about the GPL v3.0 license, visit the [GPL License](https://www.gnu.org/licenses/gpl-3.0.html) page.


pkgId: b20160a1ed6118f541e4cc4ec08d1e23dec892ad03f8b53a4c1773b359f48c1c
name: python-argumentparser
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Python 2/3 compatible commandline argument parser
url: UNKNOWN
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argumentparser-1.2.1-1.src.rpm
checksum_type: sha256
description:
  A utility class for parsing command-line arguments.

  Constructor:

   | @param names list<string> - This is a list of "names" which should reflect each argument.
   | @param shortOptions list<string>  - This is a list of short (-x val) options. Length should match names. If no short option is available, use 'None'. Omit the leading -
   | @param longOptions  list<string>  - This is a list of long (--xyz val or --xyz= val) options. If no long option is available, use 'None'. Omit the leading --
   | @param staticOptions list<string> - This is a list of static options (arguments that have meaning just being present, without taking an additional value).
   |                                           Any members of this list will be present in the results of #parse, set to True is present, otherwise False.
   | @param multipleStaticOptions <dict> - A dictionary for multiple static arguments that resolve to one value. Key is the "name", values are all potential values. Ex: {'cheese' : ['--cheddar', 'gouda'] } presence of either 'gouda' or '--cheddar' in results would set cheese to True, otherwise False.
   | @param allowOtherArguments <bool> default False - if False, consider non-specified arguments as errors. Regardless of value, unmatched params will be in 'unmatched' key of return value.

  Functions:

   | def parse(args)
   |    parse - Parses provided arguments and returns information on them. If using sys.argv, omit the first argument.

   | @return - dict keys are
   |            'result' => dictionary of result name->value
   |            'errors'  => list of strings of errors or empty list
   |            'warnings' => list of strings of warnings, or empty list
   |            'unmatched' => list of strings of unmatched params, in order

  Example:

   | In [1]: from ArgumentParser import ArgumentParser
   | In [2]: parser = ArgumentParser(['firstName', 'lastName', 'birthday'],
   |   ...:     ['f', 'l', 'b'],
   |   ...:     ['first-name', 'last-name', 'birthday'],
   |   ...:     ['--citizen']
   |   )
   |
   | In [3]: parser.parse('-f Tim --last-name=savannah --birthday 6/28'.split(' '))
   | Out[3]:
   | {'errors': [],
   |  'result': {'--citizen': False,
   |  'birthday': '6/28',
   |  'firstName': 'Tim',
   |  'lastName': 'savannah'},
   |  'warnings': [],
   |  'unmatched' : []}
   |
   | In [4]: parser.parse('-f Tim --last-name=savannah --citizen'.split(' '))
   | Out[4]:
   | {'errors': [],
   |  'result': {'--citizen': True, 'firstName': 'Tim', 'lastName': 'savannah'},
   |  'warnings': [],
   |  'unmatched': []}

  Example2:

   |  >>> from ArgumentParser import ArgumentParser
   |  >>> parser = ArgumentParser(['name'], ['n'], ['name'], None, False)
   |  >>> parser.parse('-n hello some other args'.split(' '))
   |  {'errors': ["Unknown argument 'some' (at position 2)", "Unknown argument 'other' (at position 3)", "Unknown argument 'args' (at position 4)"], 'result': {'name': 'hello'}, 'unmatched': ['some', 'other', 'args'], 'warnings': []}
   |  >>> parser = ArgumentParser(['name'], ['n'], ['name'], None, True)
   |  >>> parser.parse('-n hello some other args'.split(' '))
   |  {'errors': [], 'result': {'name': 'hello'}, 'unmatched': ['some', 'other', 'args'], 'warnings': []}

  Example3:

   |  >>> import ArgumentParser
   |  >>> parser = ArgumentParser.ArgumentParser( ('one', 'two'), ('o', 't'), ('uno', 'dos'), ('x'), {'cheese' : ['cheddar', 'gouda'], 'baby' : {'child', 'infant'}} )
   |  >>> parser.parse(['-o', '1', 'cheddar'])
   |  {'errors': [], 'result': {'baby': False, 'cheese': True, 'x': False, 'one': '1'}, 'unmatched': [], 'warnings': []}


pkgId: 88de0f29c3ff7e70179eda8565f8fbf915ebe06ded6612f5c97eee7fa665c602
name: python-argus-api
arch: src
version: 3.18.0
epoch: 0
release: 1
summary: SDK for the Argus API
url: https://mnemonic.io
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argus-api-3.18.0-1.src.rpm
checksum_type: sha256
description:
  `argus-api` is the python API client library for [mnemonic](https://www.mnemonic.io/)'s Argus API.

  Documentation for this library can be found at: [argus-api documentation](https://argus-api.docs.mnemonic.no)



  In order to report issues or request features, please contact Mnemonic's development
  team: [opensource@mnemonic.no](mailto:opensource@mnemonic.no)


pkgId: 8c2fccc7d6fec3da2e5f14856c59bede38841f5a9bb984a83d03ab367838164d
name: python-argus-server
arch: src
version: 1.26.0
epoch: 0
release: 1
summary: Argus is an alert aggregator for monitoring systems
url: https://github.com/Uninett/Argus
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argus-server-1.26.0-1.src.rpm
checksum_type: sha256
description:
  [![test badge](https://github.com/Uninett/Argus/actions/workflows/python.yml/badge.svg)](https://github.com/Uninett/Argus/actions)
  [![codecov badge](https://codecov.io/gh/Uninett/Argus/branch/master/graph/badge.svg)](https://codecov.io/gh/Uninett/Argus)
  [![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)
  [![docs badge](https://readthedocs.org/projects/argus-server/badge/?version=latest&style=flat)](http://argus-server.rtfd.io/en/latest/)

  Argus is a platform for aggregating incidents across network management systems, and
  sending notifications to users. Users create notification profiles that define which
  incidents they subscribe to. See [Argus docs](http://argus-server.rtfd.io/en/latest/) for more details.

  This repository hosts the backend built with Django. There is also a
  [REACT SPA frontend](https://github.com/Uninett/Argus-frontend).


  See also the the [Python client library](https://github.com/Uninett/pyargus).



  There are several ways to install Argus.





  * Python 3.8+
  * Django 4.2 or 5.0
  * pip



  * **Redis**
    is recommended if you are going to run the frontend.
    Redis backs the websockets, in order to push realtime updates to the frontend.
  * [Argus-frontend](https://github.com/Uninett/Argus-frontend/)
  * PostgreSQL
  * Docker and Docker Compose to run Argus in Docker



  Dataporten authentication is supported by Argus and can be used to log into
  Argus-frontend.
  Refer to the [Dataporten](https://argus-server.rtfd.io/en/latest/authentication.html#dataporten) section of the documentation to learn
  about Dataporten registration, and how to set it up with Argus.



  You can also install Argus with `pip` via PyPI. The package name is `argus-server`:
  ```console
  $ pip install argus-server
  ```

  If you are using the PyPI package in production, please note: The file
  `requirements.txt` contains the pinned versions of dependencies that the
  release was tested on. The file `constraints.txt` is for controlling versions
  of sub-dependencies so as to not poison the pyproject.toml.

  To update the dependency lock-files, use `tox`:

  ```console
  $ pip install tox
  $ tox -e upgrade-deps -- -U
  ```

  To upgrade a single dependency, replace the `-U` flag with `-P PACKAGENAME`.

  To install from the lock-file use pip:

  ```console
  $ pip install -c constraints.txt --upgrade -r requirements.txt
  ```

  Now change and adapt [Argus' settings](#settings-in-argus) according to your needs.

  Run the initial Argus setup, and make note of the admin password that is generated:

  ```console
  $ python manage.py initial_setup
  ******************************************************************************

    Created Argus superuser "admin" with password "2S0qJbjVEew0GunL".

     Please change the password via the admin interface.

  ******************************************************************************
  ```

  Then run the Argus API server:

  ```console
  $ python manage.py runserver
  ```



  Download the source code first.
  ```console
  $ git clone https://github.com/Uninett/Argus.git
  $ cd Argus
  ```

  Running Argus with Docker Compose is as simple as
  ```console
  $ docker compose up
  ```

  Run the initial Argus setup, and make note of the admin password that is generated:

  ```console
  $ docker compose exec api django-admin initial_setup
  ******************************************************************************

    Created Argus superuser "admin" with password "ns6bfoKquW12koIP".

     Please change the password via the admin interface.

  ******************************************************************************
  ```


  You will find Argus running at http://localhost:8000/.



  Site-specific settings can either be set using environment variables, using a
  `settings.py` file, or a combination of both.

  For more information on both methods and a list of the settings, consult the
  documentation section on
  [site-specific settings](http://argus-server.rtfd.io/en/latest/site-specific-settings.html).






  You can use Docker Compose to conveniently setup a complete dev environment for Argus,
  including PostgreSQL. Instructions
  [are provided above](#setup-argus-using-docker-compose).

  To do a manual install instead, follow these steps.

  Download the source code first.
  ```console
  $ git clone https://github.com/Uninett/Argus.git
  $ cd Argus
  ```

  We recommend using virtualenv or virtaulenvwrapper to create
  a place to stash Argus' dependencies.

  Create and activate a Python virtual environment.
  ```console
  $ python -m venv venv
  $ source venv/bin/activate
  ```

  Install Argus' requirements into the virtual env.
  ```console
  $ pip install -r requirements-django42.txt
  $ pip install -r requirements/dev.txt
  ```



  Copy the `cmd.sh-template` to `cmd.sh` and make it executable
  ```console
  $ cp cmd.sh-template cmd.sh
  $ chmod u+x cmd.sh
  ```
  Now set the environment variables in the file using an editor.

  Required settings in `cmd.sh` are

  - `DATABASE_URL`,
  - `DJANGO_SETTINGS_MODULE` and
  - `SECRET_KEY`.

  The `DATAPORTEN` variables are optional. Refer to the dataporten section of
  [setting site-specific settings](http://argus-server.rtfd.io/en/latest/site-specific-settings.html) for details.

  `DJANGO_SETTINGS_MODULE` can be set to `argus.site.settings.dev`.

  If you need more complex settings than environment variables and ``cmd.sh`` can provide,
  we recommend having a `localsettings.py` in the same directory as `manage.py` with any
  overrides.

  Refer to the [development notes](http://argus-server.rtfd.io/en/latest/development.html) for further details and
  useful hints on managing Argus in development mode.



  Afterwards, run the initial Argus setup and start the server.
  ```console
  $ python manage.py initial_setup
  $ python manage.py runserver
  ```

  You will find Argus running at http://localhost:8000/.



  Argus uses ruff as a source code formatter. Ruff will automatically install
  with the [dev requirements](requirements/dev.txt).

  A pre-commit hook will format new code automatically before committing.
  To enable this pre-commit hook, run

  ```console
  $ pre-commit install
  ```




  Given that Argus is installed and configured as described above,
  this command is the most basic option to run the tests.
  ```console
  $ python manage.py test
  ```

  If you have installed `tox`, the following command will
  test Argus code against several Django versions, several Python versions, and
  automatically compute code coverage.
  ```console
  $ tox
  ```
  An [HTML coverage report](htmlcov/index.html) will be generated.
  Refer to the [tox.ini](tox.ini) file for further options.



  To be able to automatically produce the changelog for a release one file for each
  pull request (also called news fragment) needs to be added to the folder
  `changelog.d/`.

  The name of the file consists of three parts separated by a period:
  1. The identifier: either the issue number (in case the pull request fixes that issue)
  or the pull request number. If we don't want to add a link to the resulting changelog
  entry then a `+` followed by a unique short description.
  2. The type of the change: we use `security`, `removed`, `deprecated`, `added`,
  `changed` and `fixed`.
  3. The file suffix, e.g. `.md`, towncrier does not care which suffix a fragment has.

  So an example for a file name related to an issue/pull request would be `214.added.md`
  or for a file without corresponding issue `+fixed-pagination-bug.fixed.md`.

  This file can either be created manually with a file name as specified above and the
  changelog text as content or one can use towncrier to create such a file as following:

  ```console
  $ towncrier create -c "Changelog content" 214.added.md
  ```

  When opening a pull request there will be a check to make sure that a news fragment is
  added and it will fail if it is missing.


  To add all content from the `changelog.d/` folder to the changelog file simply run
  ```console
  $ towncrier build --version {version}
  ```
  This will also delete all files in `changelog.d/`.

  To preview what the addition to the changelog file would look like add the flag
  `--draft`. This will not delete any files or change `CHANGELOG.md`. It will only output
  the preview in the terminal.

  A few other helpful flags:
  - `date DATE` - set the date of the release, default is today
  - `keep` - do not delete the files in `changelog.d/`

  More information about [towncrier](https://towncrier.readthedocs.io).


pkgId: 166e8fc8c9b3f9995b2340a62c4fa7cf9beaa2507ba990da951c08142569ab78
name: python-argus-server
arch: src
version: 1.28.0
epoch: 0
release: 1
summary: Argus is an alert aggregator for monitoring systems
url: https://github.com/Uninett/Argus
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argus-server-1.28.0-1.src.rpm
checksum_type: sha256
description:
  [![test badge](https://github.com/Uninett/Argus/actions/workflows/python.yml/badge.svg)](https://github.com/Uninett/Argus/actions)
  [![codecov badge](https://codecov.io/gh/Uninett/Argus/branch/master/graph/badge.svg)](https://codecov.io/gh/Uninett/Argus)
  [![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)
  [![docs badge](https://readthedocs.org/projects/argus-server/badge/?version=latest&style=flat)](http://argus-server.rtfd.io/en/latest/)

  Argus is a platform for aggregating incidents across network management systems, and
  sending notifications to users. Users create notification profiles that define which
  incidents they subscribe to. See [Argus docs](http://argus-server.rtfd.io/en/latest/) for more details.

  This repository hosts the backend built with Django. There is also a
  [REACT SPA frontend](https://github.com/Uninett/Argus-frontend).


  See also the the [Python client library](https://github.com/Uninett/pyargus).



  There are several ways to install Argus.





  * Python 3.8+
  * Django 4.2 or 5.0
  * pip



  * **Redis**
    is recommended if you are going to run the frontend.
    Redis backs the websockets, in order to push realtime updates to the frontend.
  * [Argus-frontend](https://github.com/Uninett/Argus-frontend/)
  * PostgreSQL
  * Docker and Docker Compose to run Argus in Docker



  Dataporten authentication is supported by Argus and can be used to log into
  Argus-frontend.
  Refer to the [Dataporten](https://argus-server.rtfd.io/en/latest/authentication.html#dataporten) section of the documentation to learn
  about Dataporten registration, and how to set it up with Argus.



  You need to have the frontend dependencies installed.

  Either of

  ```
  pip install argus-server[htmx]
  ```

  or

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

  will do it.



  You can also install Argus with `pip` via PyPI. The package name is `argus-server`:
  ```console
  $ pip install argus-server
  ```

  If you are using the PyPI package in production, please note: The file
  `requirements.txt` contains the pinned versions of dependencies that the
  release was tested on. The file `constraints.txt` is for controlling versions
  of sub-dependencies so as to not poison the pyproject.toml.

  To update the dependency lock-files, use `tox`:

  ```console
  $ pip install "tox>=4"
  $ tox run -e upgrade-deps -- -U
  ```

  To upgrade a single dependency, replace the `-U` flag with `-P PACKAGENAME`.

  To install from the lock-file use pip:

  ```console
  $ pip install -c constraints.txt --upgrade -r requirements.txt
  ```

  Now change and adapt [Argus' settings](#settings-in-argus) according to your needs.

  Run the initial Argus setup, and make note of the admin password that is generated:

  ```console
  $ python manage.py initial_setup
  ******************************************************************************

    Created Argus superuser "admin" with password "2S0qJbjVEew0GunL".

     Please change the password via the admin interface.

  ******************************************************************************
  ```

  Then run the Argus API server:

  ```console
  $ python manage.py runserver
  ```



  Download the source code first.
  ```console
  $ git clone https://github.com/Uninett/Argus.git
  $ cd Argus
  ```

  Running Argus with Docker Compose is as simple as
  ```console
  $ docker compose up
  ```

  Run the initial Argus setup, and make note of the admin password that is generated:

  ```console
  $ docker compose exec api django-admin initial_setup
  ******************************************************************************

    Created Argus superuser "admin" with password "ns6bfoKquW12koIP".

     Please change the password via the admin interface.

  ******************************************************************************
  ```


  You will find Argus running at http://localhost:8000/.



  Site-specific settings can either be set using environment variables, using a
  `settings.py` file, or a combination of both.

  For more information on both methods and a list of the settings, consult the
  documentation section on
  [site-specific settings](http://argus-server.rtfd.io/en/latest/site-specific-settings.html).






  You can use Docker Compose to conveniently setup a complete dev environment for Argus,
  including PostgreSQL. Instructions
  [are provided above](#setup-argus-using-docker-compose).

  To do a manual install instead, follow these steps.

  Download the source code first.
  ```console
  $ git clone https://github.com/Uninett/Argus.git
  $ cd Argus
  ```

  We recommend using virtualenv or virtaulenvwrapper to create
  a place to stash Argus' dependencies.

  Create and activate a Python virtual environment.
  ```console
  $ python -m venv venv
  $ source venv/bin/activate
  ```

  Install Argus' requirements into the virtual env.
  ```console
  $ pip install -r requirements-django42.txt
  $ pip install -r requirements/dev.txt
  ```



  Copy the `cmd.sh-template` to `cmd.sh` and make it executable
  ```console
  $ cp cmd.sh-template cmd.sh
  $ chmod u+x cmd.sh
  ```
  Now set the environment variables in the file using an editor.

  Required settings in `cmd.sh` are

  - `DATABASE_URL`,
  - `DJANGO_SETTINGS_MODULE` and
  - `SECRET_KEY`.

  The `DATAPORTEN` variables are optional. Refer to the dataporten section of
  [setting site-specific settings](http://argus-server.rtfd.io/en/latest/site-specific-settings.html) for details.

  `DJANGO_SETTINGS_MODULE` can be set to `argus.site.settings.dev`.

  If you need more complex settings than environment variables and ``cmd.sh`` can provide,
  we recommend having a `localsettings.py` in the same directory as `manage.py` with any
  overrides.

  Refer to the [development notes](http://argus-server.rtfd.io/en/latest/development.html) for further details and
  useful hints on managing Argus in development mode.



  See https://argus-server.erfd.io/en/latest/reference/react-frontend.html



  See http://argus-server.rtfd.io/en/latest/reference/htmx-frontend.html



  Afterwards, run the initial Argus setup and start the server.
  ```console
  $ python manage.py initial_setup
  $ python manage.py runserver
  ```

  You will find Argus running at http://localhost:8000/.



  Argus uses ruff as a source code formatter. Ruff will automatically install
  with the [dev requirements](requirements/dev.txt).

  A pre-commit hook will format new code automatically before committing.
  To enable this pre-commit hook, run

  ```console
  $ pre-commit install
  ```




  Given that Argus is installed and configured as described above,
  this command is the most basic option to run the tests.
  ```console
  $ python manage.py test
  ```

  If you have installed `tox`, the following command will
  test Argus code against several Django versions, several Python versions, and
  automatically compute code coverage.
  ```console
  $ tox
  ```
  An [HTML coverage report](htmlcov/index.html) will be generated.
  Refer to the [tox.ini](tox.ini) file for further options.



  To be able to automatically produce the changelog for a release one file for each
  pull request (also called news fragment) needs to be added to the folder
  `changelog.d/`.

  The name of the file consists of three parts separated by a period:
  1. The identifier: either the issue number (in case the pull request fixes that issue)
  or the pull request number. If we don't want to add a link to the resulting changelog
  entry then a `+` followed by a unique short description.
  2. The type of the change: we use `security`, `removed`, `deprecated`, `added`,
  `changed` and `fixed`.
  3. The file suffix, e.g. `.md`, towncrier does not care which suffix a fragment has.

  So an example for a file name related to an issue/pull request would be `214.added.md`
  or for a file without corresponding issue `+fixed-pagination-bug.fixed.md`.

  This file can either be created manually with a file name as specified above and the
  changelog text as content or one can use towncrier to create such a file as following:

  ```console
  $ towncrier create -c "Changelog content" 214.added.md
  ```

  When opening a pull request there will be a check to make sure that a news fragment is
  added and it will fail if it is missing.


  To add all content from the `changelog.d/` folder to the changelog file simply run
  ```console
  $ towncrier build --version {version}
  ```
  This will also delete all files in `changelog.d/`.

  To preview what the addition to the changelog file would look like add the flag
  `--draft`. This will not delete any files or change `CHANGELOG.md`. It will only output
  the preview in the terminal.

  A few other helpful flags:
  - `date DATE` - set the date of the release, default is today
  - `keep` - do not delete the files in `changelog.d/`

  More information about [towncrier](https://towncrier.readthedocs.io).


pkgId: 40a03b0b31e36420d8cfef2df238a97879ca05bcc09143004983a24354fca51e
name: python-argus-toolbelt
arch: src
version: 6.21.0
epoch: 0
release: 1
summary: A framework for creating interactive commands with Argus' APIs
url: https://mnemonic.io
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argus-toolbelt-6.21.0-1.src.rpm
checksum_type: sha256
description:
  `argus-api` is a CLI client for [mnemonic](https://www.mnemonic.io/)'s Argus API.

  Documentation can be found at: [argus-toolbelt documentation](https://argus-toolbelt.docs.mnemonic.no)



  In order to report issues or request features, please contact Mnemonic's development
  team: [opensource@mnemonic.no](mailto:opensource@mnemonic.no)


pkgId: 3ce190553760851c0108c86fdc56f22ed52273d5503a3ca91ffad01eeb95a95a
name: python-argusclient
arch: src
version: 1.0
epoch: 0
release: 1
summary: Minimal client library for Argus webservice REST API
url: https://github.com/SalesforceEng/argusclient
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-argusclient-1.0-1.src.rpm
checksum_type: sha256
description:
  This is a minimal and thin layer of Python client code on top of the
  Argus webservices REST API. Most of the library API is 1:1 with that of
  REST API so it serves to be more of a convenience than an abstraction.
  This means you still need to be familiar with the underlying REST API to
  be effective. For more information on the REST API and data model, refer
  to the `Argus - User
  Guide <https://github.com/SalesforceEng/Argus/wiki>`__.
  Special thanks to `Demian Brecht <https://github.com/demianbrecht>`__
  for giving a lot of feedback early and helping to shape the API and the
  project.
  You can also browse the Python API documentation online at: `<https://salesforce.github.io/python-argusclient/>`__
  A quick primer to using argusclient
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  Below you will find functional and self-explanatory code that shows how
  to do the following:
  -  Import the relevant pieces from argusclient
  -  Create the main entry point and establish login session
  -  Query for existing namespaces
  -  Create a new namespace
  -  Collect metrics and annotations
  -  Post metrics and annotations
  -  Query for existing dashboards
  -  Update or Create dashboard
  -  Query for existing alerts
  -  Delete alert
  -  Create an alert along with a trigger and a notification
  In addition, also look at the bundled example named
  ``splunk_to_argus.py`` that shows how to extract metrics from Splunk and
  push them to Argus.
  Some package imports and initializations that we use later
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      import sys, os, time, calendar, getpass, logging, random
      import lxml.etree
      from argusclient import *
      from argusclient.dashboardtags import DASHBOARD, CHART, TITLE, METRIC, FLAGS
      logging.basicConfig()
      logging.root.setLevel(logging.INFO)
      logging.getLogger("requests").setLevel(logging.WARN)
      endpoint = "http://localhost:8080/argusws"
      user = "hdara"
      password = None
      tags = { "host": "hdara-wsl" }
      fields = { "user": user }
      curtm = long(calendar.timegm(time.gmtime()))*1000
      ns_name = "hdara-ns"
      ns_access_addl_users = ("hdara",)
      dashboard_name = "hdara.test.dashboard"
      alert_name = "hdara.test.alert"
      scope_name = "hdara"
      metric_name = "test"
      ans = []
  Login to the service and establish session
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      argus = ArgusServiceClient(user,
                                 password or getpass.getpass("SSO password for %s: " % user),
                                 endpoint=endpoint)
      logging.info("Logging in")
      argus.login()
  Check if a namespace exists and create one if missing
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      logging.info("Looking up existing namespace with name: %s", ns_name)
      nss = dict((ns.qualifier, ns) for ns in argus.namespaces.values())
      ns = nss.get(ns_name)
      if not ns:
          logging.info("Creating new namespace with name: %s", ns_name)
          ns = argus.namespaces.add(Namespace(ns_name))
  Generate some random metrics against hdara-ns:hdara:test and mark the start and end with annotations.
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      logging.info("Generating some metric and annotation data for the dashboard")
      m = Metric(scope_name, metric_name, tags=tags, namespace=ns_name)
      for t in xrange(10, 0, -1):
          
          ts = curtm-t*60*1000
          m.datapoints[ts] = random.randint(50, 100)
          if not ans or t == 1:
              ans.append(Annotation("script", "hdara", "test", ts, ts, "generated", tags=tags, fields=dict(event=ans and "start" or "end", **fields)))
  Send metrics and annotations to Argus
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      logging.info("Adding metrics data to Argus")
      am_resp = argus.metrics.add([m]);
      if am_resp.error_count():
          logging.error("Errors reported in metric data: errorCount: %s errorMessages: %s", am_resp.error_count(), am_resp.error_messages())
      logging.info("Adding annotation data to Argus")
      an_resp = argus.annotations.add(ans)
      if an_resp.error_count():
          logging.error("Errors reported in annotation data: errorCount: %s errorMessages: %s", an_resp.error_count(), an_resp.error_messages())
  Generate dashboard content
  ^^^^^^^^^^^^^^^^^^^^^^^^^^
      mquery = str(MetricQuery(scope_name, metric_name, "sum", tags=tags, stTimeSpec="-1d", enTimeSpec="-0d", namespace=ns_name))
      aquery = str(AnnotationQuery(scope_name, metric_name, "generated", tags=tags, stTimeSpec="-1d", enTimeSpec="-0d"))
      content = lxml.etree.tostring(DASHBOARD(
          CHART(
              TITLE("hdara.test"),
              METRIC(mquery, name="hdara.test.metric"),
              FLAGS(aquery, name="hdara.test.annotation"),
              name="Chart"
              )
      ), method="html")
      dashbobj.content = content
  Update or Create dashboard
  ^^^^^^^^^^^^^^^^^^^^^^^^^^
      logging.info("Looking up existing dashboard with name: %s", dashboard_name)
      dashbobj = argus.dashboards.get_user_dashboard(user, dashboard_name, shared=False)
      if not dashbobj:
          logging.info("Creating new dashboard with name: %s", dashboard_name)
          dashbobj = Dashboard(dashboard_name, content, shared=True, description="A new dashboard")
          dashbobj = argus.dashboards.add(dashbobj)
      else:
          logging.info("Updating dashboard with name: %s id %s", dashboard_name, dashbobj.argus_id)
          dashbobj.content = content
          argus.dashboards.update(dashbobj.argus_id, dashbobj)
      logging.info("Dashboard url: %s", os.path.join(os.path.dirname(endpoint), "argus/#/dashboards", str(dashbobj.argus_id)).replace("-ws", "-ui"))
  Look for an existing alert and delete it so that we can recreate it
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      logging.info("Looking up existing alert with name: %s owned by user: %s", alert_name, user)
      alertobj = argus.alerts.get_user_alert(user, alert_name, shared=False)
      if alertobj:
          logging.info("Deleting existing alert with name: %s id: %s", alert_name, alertobj.argus_id)
          argus.alerts.delete(alertobj.argus_id)
  Finally, create alert with a trigger and a notification
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      logging.info("Creating new alert with alert name: %s", alert_name)
      alertobj = argus.alerts.add(Alert(alert_name, mquery, "* */1 * * *",
                                        trigger=Trigger("hdara.test.trigger", Trigger.GREATER_THAN, 100000, 600000),
                                        notification=Notification("hdara.test.notification", Notification.EMAIL, subscriptions=["hdara@salesforce.com"]),
                                        shared=True))


pkgId: f44c82e3060ce09d50da2f6c0c2685fd9d7719263bf8152b85677fff204a4726
name: python-ariaclient
arch: src
version: 4.0.15
epoch: 0
release: 1
summary: Client side API and simple bot framekwork for fincloud-aria (version 4)
url: https://github.com/fincloud-io/ariaclient
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ariaclient-4.0.15-1.src.rpm
checksum_type: sha256
description:
  1. Ensure that the project version number is correctly updated [src/ariaclient/__init__.py](src/ariaclient/__init__.py)
  2. `pip install -r requirements_dev.txt`      `python -m build`
  3. Then to upload into pyi  `twine upload dist/*`


pkgId: 77975d1501433018827d4d05d1b2eaf813422eda483933d95f45390931ca2ccd
name: python-ariadne
arch: src
version: 0.23.0
epoch: 0
release: 1
summary: Ariadne is a Python library for implementing GraphQL servers.
url: https://ariadnegraphql.org/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ariadne-0.23.0-1.src.rpm
checksum_type: sha256
description:
  [![Ariadne](https://ariadnegraphql.org/img/logo-horizontal-sm.png)](https://ariadnegraphql.org)

  [![Documentation](https://img.shields.io/badge/docs-ariadnegraphql.org-brightgreen.svg)](https://ariadnegraphql.org)
  [![Codecov](https://codecov.io/gh/mirumee/ariadne/branch/master/graph/badge.svg)](https://codecov.io/gh/mirumee/ariadne)

  - - - - -



  Ariadne is a Python library for implementing [GraphQL](http://graphql.github.io/) servers.

  - **Schema-first:** Ariadne enables Python developers to use schema-first approach to the API implementation. This is the leading approach used by the GraphQL community and supported by dozens of frontend and backend developer tools, examples, and learning resources. Ariadne makes all of this immediately available to you and other members of your team.
  - **Simple:** Ariadne offers small, consistent and easy to memorize API that lets developers focus on business problems, not the boilerplate.
  - **Open:** Ariadne was designed to be modular and open for customization. If you are missing or unhappy with something, extend or easily swap with your own.

  Documentation is available [here](https://ariadnegraphql.org).




  - Simple, quick to learn and easy to memorize API.
  - Compatibility with GraphQL.js version 15.5.1.
  - Queries, mutations and input types.
  - Asynchronous resolvers and query execution.
  - Subscriptions.
  - Custom scalars, enums and schema directives.
  - Unions and interfaces.
  - File uploads.
  - Defining schema using SDL strings.
  - Loading schema from `.graphql`, `.gql`, and `.graphqls` files.
  - WSGI middleware for implementing GraphQL in existing sites.
  - Apollo Tracing and [OpenTracing](http://opentracing.io) extensions for API monitoring.
  - Opt-in automatic resolvers mapping between `camelCase` and `snake_case`, and a `@convert_kwargs_to_snake_case` function decorator for converting `camelCase` kwargs to `snake_case`.
  - Built-in simple synchronous dev server for quick GraphQL experimentation and GraphQL Playground.
  - Support for [Apollo GraphQL extension for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=apollographql.vscode-apollo).
  - GraphQL syntax validation via `gql()` helper function. Also provides colorization if Apollo GraphQL extension is installed.
  - No global state or object registry, support for multiple GraphQL APIs in same codebase with explicit type reuse.
  - Support for `Apollo Federation`.




  Ariadne can be installed with pip:

  ```console
  pip install ariadne
  ```

  Ariadne requires Python 3.7 or higher.




  The following example creates an API defining `Person` type and single query field `people` returning a list of two persons. It also starts a local dev server with [GraphQL Playground](https://github.com/prisma/graphql-playground) available on the `http://127.0.0.1:8000` address.

  Start by installing [uvicorn](http://www.uvicorn.org/), an ASGI server we will use to serve the API:

  ```console
  pip install uvicorn
  ```

  Then create an `example.py` file for your example application:

  ```python
  from ariadne import ObjectType, QueryType, gql, make_executable_schema
  from ariadne.asgi import GraphQL



  type_defs = gql("""
      type Query {
          people: [Person!]!
      }

      type Person {
          firstName: String
          lastName: String
          age: Int
          fullName: String
      }
  """)


  query = QueryType()


  @query.field("people")
  def resolve_people(*_):
      return [
          {"firstName": "John", "lastName": "Doe", "age": 21},
          {"firstName": "Bob", "lastName": "Boberson", "age": 24},
      ]



  person = ObjectType("Person")

  @person.field("fullName")
  def resolve_person_fullname(person, *_):
      return "%s %s" % (person["firstName"], person["lastName"])


  schema = make_executable_schema(type_defs, query, person)


  app = GraphQL(schema, debug=True)
  ```

  Finally run the server:

  ```console
  uvicorn example:app
  ```

  For more guides and examples, please see the [documentation](https://ariadnegraphql.org).




  We are welcoming contributions to Ariadne! If you've found a bug or issue, feel free to use [GitHub issues](https://github.com/mirumee/ariadne/issues). If you have any questions or feedback, don't hesitate to catch us on [GitHub discussions](https://github.com/mirumee/ariadne/discussions/).

  For guidance and instructions, please see [CONTRIBUTING.md](CONTRIBUTING.md).

  Website and the docs have their own GitHub repository: [mirumee/ariadne-website](https://github.com/mirumee/ariadne-website)

  Also make sure you follow [@AriadneGraphQL](https://twitter.com/AriadneGraphQL) on Twitter for latest updates, news and random musings!

  **Crafted with ❤️ by [Mirumee Software](http://mirumee.com)**
  hello@mirumee.com

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Mirumee Labs 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 copyright holder 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: 983233d3d4dd0b0db80f300a06142d0c47e82eacd11188ced468cd0cc67d6057
name: python-ariadne-django
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: ariadne_django is a python library for integrating django with ariadne.
url: https://github.com/reset-button/ariadne_django
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ariadne-django-0.3.0-1.src.rpm
checksum_type: sha256
description:
  ![Build Status](https://github.com/reset-button/ariadne_django/actions/workflows/main.yml/badge.svg)
  [![Codecov](https://codecov.io/gh/reset-button/ariadne_django/branch/main/graph/badge.svg)](https://codecov.io/gh/reset-button/ariadne_django)



  We're looking for a new maintainer, the folks that previously worked on this are off to new pastures and have very limited availability.



  Ariadne is a Python library for implementing [GraphQL](http://graphql.github.io/) servers.

  - **Schema-first:** Ariadne enables Python developers to use schema-first approach to the API implementation. This is the leading approach used by the GraphQL community and supported by dozens of frontend and backend developer tools, examples, and learning resources. Ariadne makes all of this immediately available to your and other members of your team.
  - **Simple:** Ariadne offers small, consistent and easy to memorize API that lets developers focus on business problems, not the boilerplate.
  - **Open:** Ariadne was designed to be modular and open for customization. If you are missing or unhappy with something, extend or easily swap with your own.

  Documentation is available [here](https://ariadnegraphql.org).



  ariadne_django is designed to make integrating Ariadne with Django simpler.
  This project splits the existing code from Ariadne's 0.12 release (with enthusiastic permission from Mirumee), decoupling the release of django-specific enhancements for Ariadne from the main ariadne release cycle.
  This allows us to be responsive to the needs of both Django and Ariadne.



  This project is committed to maintaining Ariadne's schema-first approach.  We may offer tooling that simplifies the mapping of Django models to schema types (or similar), but we won't require its usage.
  This project does not require Django REST Framework, but will provide features leveraging common DRF tools (e.g. serializers) that provide significant functionality and performance enhancements beyond Django Forms.





  Install via pip:

  `python -m pip install ariadne_django`



  Add ariadne_django to your project's INSTALLED_APPS setting (usually located in settings.py):

  ```
  INSTALLED_APPS = [
      ...
      "ariadne_django",
  ]
  ```

  The Ariadne app provides a Django template for GraphQL Playground. Make sure that your Django project is configured to load templates from application directories. This can be done by checking if APP_DIRS option located in TEMPLATES setting is set to True:

  ```
  TEMPLATES = [
      {
          ...,
          'APP_DIRS': True,
          ...
      },
  ]
  ```



  Create a Python module somewhere in your project that will define the executable schema. It may be schema module living right next to your settings and urls:

  ```

  from ariadne import QueryType, make_executable_schema

  type_defs = """
      type Query {
          hello: String!
      }
  """

  query = QueryType()

  @query.field("hello")
  def resolve_hello(*_):
      return "Hello world!"

  schema = make_executable_schema(type_defs, query)
  ```



  Add a GraphQL view to your project's urls.py:

  ```
  from ariadne_django.views import GraphQLView
  from django.urls import path

  from .schema import schema

  urlpatterns = [
      ...
      path('graphql/', GraphQLView.as_view(schema=schema), name='graphql'),
  ]
  ```

  GraphQLView.as_view() takes mostly the same options that graphql does, but with some differences:
  - debug option is not available and it's set to the value of settings.DEBUG
  - Django GraphQL view supports extra option specific to it: playground_options, a dict of GraphQL Playground options that should be used.




  Ariadne's ASGI application can be used together with Django Channels to implement an asynchronous GraphQL API with features like subscriptions:

  ```
  from ariadne.asgi import GraphQL
  from channels.http import AsgiHandler
  from channels.routing import URLRouter
  from django.urls import path, re_path


  schema = ...


  application = URLRouter([
      path("graphql/", GraphQL(schema, debug=True)),
      re_path(r"", AsgiHandler),
  ])
  ```

  At the moment, Django ORM doesn't support asynchronous query execution and there is noticeable performance loss when using it for database access in asynchronous resolvers.

  To get around this, you can use an asynchronous ORM such as Gino for database queries in your resolvers.



  Inside your project, replace all references to ariadne.contrib.django with ariadne_django.

  ```
  find {path_to_your_project} -type f -name \*.py -exec sed -i 's/ariadne\.contrib\.django/ariadne_django/g' {} \;
  ```



  1. Clone the project
  1. Setup virtualenv
  1. Make changes
  1. Run tests, etc. locally
  1. Create PR



  With sincere thanks to Mirumee, who crafted the original code of this module and ariadne with <3.


pkgId: 2c9f928ab31b762e840bde3b10b414bfe646d371a6bbce0855812006dc24fb04
name: python-ariadne-extended
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Ariadne contrib library for working with Django and GraphQL
url: https://github.com/patriotresearch/ariadne-extended
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ariadne-extended-0.2.5-1.src.rpm
checksum_type: sha256
description:
  Ariadne comes with a few contrib modules to support integration with Django. This module acts as an additional Django contrib module to reduce some of the boilerplate when integrating with Django.

  It copies and follows some of the conventions defined in Django Rest Framework, effort will be made to provide API compatibility with certain DRF extension modules that are relevant.

  The overall goal is to provide often re-used modules and GrpahQL schema, so one doesn't have to re-create them per project.



  * Pagination classes
  * Permissions classes
  * Serializer classes ( may not removed and made generic )
  * Throttling
  * django-filters filter backend



  **2.2.*, 3.0.\***




  auto schema, resolver and types loader

  Searches for `types` and `resolvers` modules as well as any `.graphql` files defined within any installed Django application.

  Once found they can be used to build the final schema and resolver solution for your ariadne application.


  Schema, types and resolvers for the graphql `Payload` interface.

  Currently the `FieldErrors` are highly coupled to Django rest framework field validation exceptions.


  Rename to relay_pagination maybe?

  Contains the `PageInfo` graphql type and `Connection` interface for utilizing cursor based pagination.

  TODO: Should we provide a input type for cursor pagination instead of just copying pagination args info paginate-able list fields??


  Filter backend interface to pass filter arguments to django-filter.


  ABC for Class Based Resolvers and model resolvers that utilize DRF serializers for saving data. This is likely to change in the future.


  DRF UUID field scalar for use with models that may use a UUID as their primary key, or other UUID fields.





  Adds resolvers, schema and types that can be utilized to query the any waffle flags, samples and switches.



  - [ ] Get rid of dependency on DRF?
  - [ ] Investigate the need for a serializer ( nested data reliance? )
  - [x] Organize code into multiple Django apps to select desired componentry
  - [ ] Documentation and examples
  - [ ] Better support of lists of enums when used with django-filters ( currently expects comma sep list string, not a list of enums from input field resolver )
  - [x] License and make public
  - [ ] Deployment automation
  - [ ] Mixins are highly coupled to serializers, should they still be?


pkgId: d5ffac734e94988793a23f90bae11dbe06f8cdca25155974fd737317e04ba1c8
name: python-ariadne-extensions
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Set of scripts and helper utilities to extend Ariadne GraphQL library
url: https://github.com/aleszoulek/ariadne-extensions
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ariadne-extensions-0.1.7-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/pantheon-systems/ariadne-extensions.svg?branch=master)](https://travis-ci.org/pantheon-systems/ariadne-extensions)
  [![Coverage Status](https://coveralls.io/repos/github/pantheon-systems/ariadne-extensions/badge.svg?branch=master)](https://coveralls.io/github/pantheon-systems/ariadne-extensions?branch=master)

  Set of scripts and helper utilities to extend [Ariadne GraphQL library](https://github.com/mirumee/ariadne)



  `pip install ariadne-extensions`






  Support for [Federation Specification](https://www.apollographql.com/docs/apollo-server/federation/federation-spec/)



  1. Generate federation schema types and directives (`_Any`, `_FieldSet`, ...)
  1. Implements `{_service{sdl}}` query
  1. Detects boundary types and generates `_Entities` union
  1. Implements resolve reference helpers for boundary types queried over `{_entities}` query (`resolve_reference` and `resolve_references` decorators)






  `FederatedManager` is a class responsible for creating and executable schema that complies with Federation Specification. Similar to what `make_executable_schema` does with ordinary schema file.

  Create a FederatedManager instance passing in path to your schema file and QueryType instance. Manager needs to query_type to register `_entities` and `_service` resolvers.

  ``` python
  query_type = QueryType()
  manager = federation.FederatedManager(
      schema_sdl_file='/some/path/schema.graphql',
      query=query_type,
  )
  ```

  Register any other `ObjectType`s and resolvers by either calling and `add_types` method, or by extending `manager.types` list.

  ``` python
  photo_type = ObjectType('Photo')
  thumbnail_type = ObjectType('Thumbnail')

  manager.add_types(photo_type, thumbnail_type)
  manager.types.append(snake_case_fallback_resolvers)
  ```

  Finally, get a combiled schema. This compiled schema will extend types defined in '/some/path/schema.graphql' with directives, types and queries, that required by Federation Specification protocol.

  ``` python
  schema = manager.get_schema()
  ```




  If you are using GraphQL Federation, your service schema probably implements some so called "boundary objects". That's where `FederatedObjectType` is useful.

  `FederatedObjectType` implements `resolve_reference` and `resolve_references` decorator. Those are used to register functions, that will be called when a federation gateway calls `{_entities{}}` query.

  Let's say `User` is a boundary type, with a single `id` key. You need to implement a function, that will accept a dictionary of keys (`{'id': ...} in our example`) and return a `User` instance.
  FederatedManager will call this function for every `_entities([{__typename: 'User', id: ...}])` query.

  ``` python
  user_type = federation.FederatedObjectType('User')

  @user_type.resolve_reference
  def resolve_user_reference(representation, obj, info):
      user_id = representation.get('id')
      return get_user_by_id(user_id)
  ```

  `FederatedObjectType` extends Ariadne's `ObjectType`. You can still use the `field` decorator, `set_alias` method and others as in regular `ObjectType`, and others.

  ``` python
  @user_type.field('name')
  def resolve_billing_account(obj, *_, id):
      return f'{obj.first_name} {obj_last_name}'
  ```

  Don't forget to add `user_type` to our manager.

  ``` python
  manager.add_types(user_type)
  ```




  ```
  type User @key(fields: "id") @extends {
      id: ID! @external
      photos: [Photo]!
  }

  type Photo {
      id: ID!
      url: String!
      description: String
  }
  ```

  ``` python
  from os.path import dirname, join
  from ariadne import QueryType, ObjectType, snake_case_fallback_resolvers

  from ariadne_extensions import federation

  query_type = QueryType()
  manager = federation.FederatedManager(
      schema_sdl_file=join(dirname(__file__), 'schema.graphql'),
      query=query_type,
  )

  user_type = federation.FederatedObjectType('User')
  photo_type = ObjectType('Photo')

  @user_type.resolve_reference
  def resolve_user_reference(representation, obj, info):
      user_id = representation.get('id')
      return get_user_by_id(user_id)

  @user_type.field('name')
  def resolve_billing_account(obj, *_, id):
      return f'{obj.first_name} {obj_last_name}'

  manager.add_types(user_type, photo_type)
  manager.add_types(snake_case_fallback_resolvers)

  schema = manager.get_schema()

  ```


pkgId: e17f070c73bf33e547ad183251566c887a18fa6116256c594c946119f862771e
name: python-ariadne-graphql-modules
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Ariadne toolkit for defining GraphQL schemas in modular fashion.
url: https://ariadnegraphql.org/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ariadne-graphql-modules-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [![Ariadne](https://ariadnegraphql.org/img/logo-horizontal-sm.png)](https://ariadnegraphql.org)

  [![Build Status](https://github.com/mirumee/ariadne-graphql-modules/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mirumee/ariadne-graphql-modules/actions)

  - - - - -



  Ariadne package for implementing Ariadne GraphQL schemas using modular approach.

  For reasoning behind this work, please see [this GitHub discussion](https://github.com/mirumee/ariadne/issues/306).

  See [API reference](./REFERENCE.md) file for documentation.




  Ariadne GraphQL Modules can be installed using pip:

  ```console
  pip install ariadne-graphql-modules
  ```

  Ariadne 0.22 or later is required for library to work.






  ```python
  from datetime import date

  from ariadne.asgi import GraphQL
  from ariadne_graphql_modules import ObjectType, gql, make_executable_schema


  class Query(ObjectType):
      __schema__ = gql(
          """
          type Query {
              message: String!
              year: Int!
          }
          """
      )

      @staticmethod
      def resolve_message(*_):
          return "Hello world!"

      @staticmethod
      def resolve_year(*_):
          return date.today().year


  schema = make_executable_schema(Query)
  app = GraphQL(schema=schema, debug=True)
  ```




  If `__schema__` string contains other type, its definition should be provided via `__requires__` attribute:

  ```python
  from typing import List, Optional

  from ariadne.asgi import GraphQL
  from ariadne_graphql_modules import ObjectType, gql, make_executable_schema

  from my_app.users import User, get_user, get_last_users


  class UserType(ObjectType):
      __schema__ = gql(
          """
          type User {
              id: ID!
              name: String!
              email: String
          }
          """
      )

      @staticmethod
      def resolve_email(user: User, info):
          if info.context["is_admin"]:
              return user.email

          return None


  class UsersQueries(ObjectType):
      __schema__ = gql(
          """
          type Query {
              user(id: ID!): User
              users: [User!]!
          }
          """
      )
      __requires__ = [UserType]

      @staticmethod
      def resolve_user(*_, id: string) -> Optional[User]:
          return get_user(id=id)

      @staticmethod
      def resolve_users(*_, id: string) -> List[User]:
          return get_last_users()




  schema = make_executable_schema(UsersQueries)
  app = GraphQL(schema=schema, debug=True)
  ```




  Optionally dependencies can be declared as deferred so they can be provided directly to `make_executable_schema`:

  ```python
  from typing import List, Optional

  from ariadne.asgi import GraphQL
  from ariadne_graphql_modules import DeferredType, ObjectType, gql, make_executable_schema

  from my_app.users import User, get_user, get_last_users


  class UserType(ObjectType):
      __schema__ = gql(
          """
          type User {
              id: ID!
              name: String!
              email: String
          }
          """
      )

      @staticmethod
      def resolve_email(user: User, info):
          if info.context["is_admin"]:
              return user.email

          return None


  class UsersQueries(ObjectType):
      __schema__ = gql(
          """
          type Query {
              user(id: ID!): User
              users: [User!]!
          }
          """
      )
      __requires__ = [DeferredType("User")]

      @staticmethod
      def resolve_user(*_, id: string) -> Optional[User]:
          return get_user(id=id)

      @staticmethod
      def resolve_users(*_, id: string) -> List[User]:
          return get_last_users()


  schema = make_executable_schema(UserType, UsersQueries)
  app = GraphQL(schema=schema, debug=True)
  ```






  Use `__aliases__ = convert_case` to automatically set aliases for fields that convert case

  ```python
  from ariadne_graphql_modules import ObjectType, convert_case, gql


  class UserType(ObjectType):
      __schema__ = gql(
          """
          type User {
              id: ID!
              fullName: String!
          }
          """
      )
      __aliases__ = convert_case
  ```




  Use `__fields_args__ = convert_case` on type to automatically convert field arguments to python case in resolver kwargs:

  ```python
  from ariadne_graphql_modules import MutationType, convert_case, gql

  from my_app import create_user


  class UserRegisterMutation(MutationType):
      __schema__ = gql(
          """
          type Mutation {
              registerUser(fullName: String!, email: String!): Boolean!
          }
          """
      )
      __fields_args__ = convert_case

      @staticmethod
      async def resolve_mutation(*_, full_name: str, email: str):
          user = await create_user(
              full_name=full_name,
              email=email,
          )
          return bool(user)
  ```




  Use `__args__ = convert_case` on type to automatically convert input fields to python case in resolver kwargs:

  ```python
  from ariadne_graphql_modules import InputType, MutationType, convert_case, gql

  from my_app import create_user


  class UserRegisterInput(InputType):
      __schema__ = gql(
          """
          input UserRegisterInput {
              fullName: String!
              email: String!
          }
          """
      )
      __args__ = convert_case


  class UserRegisterMutation(MutationType):
      __schema__ = gql(
          """
          type Mutation {
              registerUser(input: UserRegisterInput!): Boolean!
          }
          """
      )
      __requires__ = [UserRegisterInput]

      @staticmethod
      async def resolve_mutation(*_, input: dict):
          user = await create_user(
              full_name=input["full_name"],
              email=input["email"],
          )
          return bool(user)
  ```




  `Query`, `Mutation` and `Subscription` types are automatically merged into one by `make_executable_schema`:

  ```python
  from datetime import date

  from ariadne.asgi import GraphQL
  from ariadne_graphql_modules import ObjectType, gql, make_executable_schema


  class YearQuery(ObjectType):
      __schema__ = gql(
          """
          type Query {
              year: Int!
          }
          """
      )

      @staticmethod
      def resolve_year(*_):
          return date.today().year


  class MessageQuery(ObjectType):
      __schema__ = gql(
          """
          type Query {
              message: String!
          }
          """
      )

      @staticmethod
      def resolve_message(*_):
          return "Hello world!"


  schema = make_executable_schema(YearQuery, MessageQuery)
  app = GraphQL(schema=schema, debug=True)
  ```

  Final schema will contain single `Query` type thats result of merged tupes:

  ```graphql
  type Query {
      message: String!
      year: Int!
  }
  ```

  Fields on final type will be ordered alphabetically.




  Ariadne GraphQL Modules support combining old and new approaches to schema definition.

  See [moving guide](./MOVING.md) for examples and details.




  We are welcoming contributions to Ariadne GraphQL Modules! If you've found a bug or issue, feel free to use [GitHub issues](https://github.com/mirumee/ariadne/issues). If you have any questions or feedback, please let us know via [GitHub discussions](https://github.com/mirumee/ariadne/discussions/).

  Also make sure you follow [@AriadneGraphQL](https://twitter.com/AriadneGraphQL) on Twitter for latest updates, news and random musings!

  **Crafted with ❤️ by [Mirumee Software](http://mirumee.com)**
  hello@mirumee.com

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Mirumee Labs 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 copyright holder 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: d8ef3c6f36ea1c9ed770487098b24e94b046f706cc1e8d08b5c5ba8e59923534
name: python-ariane_procos
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Ariane Plugin ProcOS
url: https://github.com/echinopsii/net.echinopsii.ariane.community.plugin.procos.git
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ariane_procos-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Ariane Plugin PROCOS map your operating process interactions and more.Where you can get more informations :    + http://ariane.echinopsii.net   + http://confluence.echinopsii.net/confluence/display/AD/Ariane+Documentation+Home   + IRC on freenode #ariane.echinopsii


pkgId: 13e3bafc84e037034fe14e55994c6822a4ede2aa78af883992a882897a8d072a
name: python-aridity
arch: src
version: 78
epoch: 0
release: 1
summary: DRY config and template system, easily extensible with Python
url: https://pypi.org/project/aridity/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aridity-78-1.src.rpm
checksum_type: sha256
description:
  DRY config and template system, easily extensible with Python


  * Keys are paths to avoid concatenation
  * It's never necessary to repeat a value
  * Minimal syntax for surprise-free authoring
  * Evaluation lazy and influenced by context
  * Strongly (dynamically) typed values
  * Central defaulting rather than at call sites
  * Templating using same syntax as expressions
  * Easy to correctly quote/escape values in templates
  * Extensibility via user-defined functions
  * Easy tasks are easy, hard tasks are possible
  * Many applications can share one user config
  * Principle of least astonishment driven design
  * Don't make users jump through hoops


  * Environment variables are too crude to configure non-trivial apps, and maybe even trivial apps in the cloud
      * They do not support nested data or lists, without some encoding scheme implemented in app code or a lib
      * Multiple bespoke encoding schemes in the system are an error-prone maintenance burden worth avoiding
  * Testing code that queries the environment directly comes with a big risk of leaking state between tests
  * Often tools/libraries must be configured using config files
      * Support for config file interpolation is not enough to stay DRY, and comes with a different set of gotchas per tool
      * In particular Helm/Terraform have their own ways of sharing config between envs
  * aridity is a general purpose solution for all the above, also see [soak](https://pypi.org/project/soak/)


  * Normally you pass around a Config object, and application code can get data out via attribute access e.g. config.foo.bar
      * Here config.foo is also a Config object, a child scope of config named foo
      * The passing around can be taken care of by a dependency injection container such as [diapyr](https://pypi.org/project/diapyr/)
  * Every Config has an associated ConfigCtrl on which Python API such as processtemplate is available
      * Use negation to get ConfigCtrl when you have a Config e.g. (-config).processtemplate(...)
      * Use the node attribute to get Config when you have a ConfigCtrl, this is a rare situation in practice
  * When unit testing a class or function that expects a Config object, you can use SimpleNamespace to mock one


  * Config files have the extension .arid and templates .aridt
  * A template is simply a file-sized aridity expression
      * Conventionally the template processor sets " to the appropriate quote function for the file format, e.g. jsonquote for JSON/YAML
  * Instead of adding Python objects to the config in main, it's tidier to use aridity's pyref function to achieve this
  * When some value needs to be constructed using concatenation, consider whether it would be more tasteful to do this in the config


  * Sometimes we want to deploy a change, but something in production isn't ready for that change
  * A feature switch allows deployment to production in this case
  * Add a boolean to the base config (conventionally root.arid) e.g. foo enabled = true
      * This value should be the configuration that we eventually want in all environments
  * In production config, override with foo enabled = false
  * In the code, read config.foo.enabled and enable the change based on this boolean
  * The above can now be deployed to all environments, and is not a blocker for other changes
  * Later when production is ready for it, it's a 1 line change to remove the override from production config


  ```
  : Until aridity gets support for comments, you can use the colon directive to ignore data.
  : Directives MUST be separated from data by whitespace, and are typically punctuation.

  : Here's the equals directive:
  foo = bar
  : This does what you'd expect - assign the string value bar to foo.
  : Observe that bar isn't quoted, values in aridity are normally barewords.
  : foo is actually a path of length 1, path components are whitespace-separated:
  this is a path = this is a value
  : Any existing assignment can be overridden:
  foo = baz
  this is a path = this is different

  : Internal whitespace in values is preserved (leading and trailing whitespace is not):
  two sentences = Some like 2 spaces.  After a full stop.

  : You can use indentation to avoid typing a common path prefix multiple times:
  app1 feature1
      data1 = value1
      data2 = value2
  app2
      feature1 data = value3
      feature2
          data1 = value4
          data2 = value5
  : Exactly the same effect without using indentation:
  app1 feature1 data1 = value1
  app1 feature1 data2 = value2
  app2 feature1 data = value3
  app2 feature2 data1 = value4
  app2 feature2 data2 = value5

  : The right hand side of an equals is actually an expression.
  : In an expression, a dollar sign with brackets can be used to refer to another path:
  has value
      bar = $(foo)
      value3 = $(app2 feature1 data)
  : Round brackets and square brackets have exactly the same effect:
  also has value bar = $[foo]
  : Values can be concatenated:
  two bars
      without spacing = $(foo)$(foo)
      with one space  = $(foo) $(foo)
      with 2 spaces   = $(foo)  $(foo)
  : A few paths are predefined in every new context, such as:
  home directory = $(~)

  : To get a literal dollar there is a special form for quoting:
  financial report = $'(We lost $100 on Friday.)
  : Unlike in older versions, nested brackets (if any) do not end the special form early:
  behaviour
      expected = $'[Lunch cost $20 (worth it though).]
      same     = $'(Lunch cost $20 (worth it though).)
  : Consequently, unbalanced brackets of the same kind as used by the special form must be avoided:
  interval
      lower = $'[The interval ][$'[0, 1) includes 0 but not 1.]
      upper = $'(The interval )($'(0, 1] includes 1 but not 0.)

  : Another special form can be used to preserve leading/trailing whitespace:
  padded bars = $.( $(foo) $(foo) )
  : Brackets can span multiple lines:
  bar per line
      without final newline = $.($(foo)
  $(foo))
      with final newline = $.($(foo)
  $(foo)
  )

  : Evaluation is lazy, the expression is what is actually (and eagerly) assigned to the path:
  no problem = $(this path will get a value later)
  : If your use-case demands it, you can force eager evaluation:
  bar even if foo changes later := $(foo)

  : When evaluating a path the local scope is examined first, then its parents if path not found:
  host
      short path = nope
      guest short path = yep
      should be nope = $(short path)
      guest should be yep = $(short path)
  does not work = $(short path)

  : Use the dot directive to include config from another file:
  . /path/to/other/config.arid
  : Thus you can factor out any config that's common to multiple deployments, and override as needed.
  : It's possible (but maybe not so useful) to include under a non-trivial path:
  other stuff . /path/to/other/config.arid
  : There is no default context for relative paths, you must set cwd up-front as inclusion is not lazy:
  cwd = /path/to
  . other/config.arid

  : Text between dollar and open bracket (that isn't a special form) is a function name.
  : A useful function predefined in every new context is the platform slash:
  path = $/($(~) Desktop report.txt)
  : Unlike most functions, / can also be used (less legibly) as a value:
  path = $(~)$(/)Desktop$(/)report.txt
  : All functions are first class objects that can be assigned and overridden in the usual ways:
  slash := $(/)
  / = something else
  path = $slash($(~) Desktop report.txt)

  : Simple lists can be created using the plus equals convenience directive.
  : Indentation means you don't have to repeat the directive for every list element:
  years +=
      2018
      2019
  years += 2020
  : A predefined join function takes a list and a separator and does what you'd expect:
  copyright = $join($(years) $.(, ))
  : Observe that functions typically take values not identifiers, so you have to 'get' explicitly.
  : Lists are just a special case of nested scopes, which are much more powerful:
  person
      $.(The Guardians) year = 2018
      Greta year = 2019
  summary = Person of the Year was $join($map($(person) $.($label() in $(year))) $.(, )).
  : Here the predefined label function gives you access to the last path component of a list element.
  ```


  * A template is simply an expression in a file, that may be quite large
  * These are typically used to create config files for other languages e.g. YAML, HCL
      * Note that literal dollar signs must be quoted as above, everything else is safe
  * A processtemplate script is provided for basic processing
  ```
  processtemplate app.json.aridt <config.arid >app.json
  ```
  * Conventionally the `"` path is set to the most useful escape function for the target format
      * Brackets can be elided in function composition e.g. `$"$(key)` is the same as `$"($(key))`




  Print given config (with optional path in config) as shell snippet.


  Interactive REPL.


  Process the given template to stdout using config from stdin.



  <a id="aridity.config"></a>



  <a id="aridity.config.ForeignScopeException"></a>



  ```python
  class ForeignScopeException(Exception)
  ```

  The operation required a scope at precisely the given path.

  <a id="aridity.config.ConfigCtrl"></a>



  ```python
  class ConfigCtrl()
  ```

  High level scope API.

  <a id="aridity.config.ConfigCtrl.r"></a>



  ```python
  @property
  def r()
  ```

  Get config object for reading, i.e. missing scopes will error.

  <a id="aridity.config.ConfigCtrl.w"></a>



  ```python
  @property
  def w()
  ```

  Get config object for writing, i.e. missing scopes will be created.

  <a id="aridity.config.ConfigCtrl.loadappconfig"></a>



  ```python
  def loadappconfig(mainfunction,
                    moduleresource,
                    encoding='ascii',
                    settingsoptional=False)
  ```

  Using app name as prefix load config from the given resource, apply user settings, and return config object for app. Context module for loading resource and the app name are deduced from `mainfunction`, or these can be provided as a tuple. Set `settingsoptional` to suppress the usual error if ~/.settings.arid does not exist.

  <a id="aridity.config.ConfigCtrl.load"></a>



  ```python
  def load(pathorstream)
  ```

  Execute config from the given path or stream.

  <a id="aridity.config.ConfigCtrl.execute"></a>



  ```python
  def execute(text)
  ```

  Execute given config text.

  <a id="aridity.config.ConfigCtrl.__iter__"></a>



  ```python
  def __iter__()
  ```

  Yield keys and values.

  <a id="aridity.config.ConfigCtrl.processtemplate"></a>



  ```python
  def processtemplate(frompathorstream, topathorstream)
  ```

  Evaluate expression from path/stream and write result to path/stream.

  <a id="aridity.config.RConfig"></a>



  ```python
  class RConfig(Parabject)
  ```

  <a id="aridity.config.RConfig.__iter__"></a>



  ```python
  def __iter__()
  ```

  Yield values only. Iterate over `-self` for keys and values.

  <a id="aridity.directives"></a>



  <a id="aridity.directives.Colon"></a>



  ```python
  @_directive
  class Colon()
  ```

  Ignore rest of logical line.

  <a id="aridity.directives.Source"></a>



  ```python
  @_directive
  class Source()
  ```

  Include path or resource at prefix.

  <a id="aridity.directives.Equals"></a>



  ```python
  @_directive
  class Equals()
  ```

  Assign expression to path.

  <a id="aridity.directives.ColonEquals"></a>



  ```python
  @_directive
  class ColonEquals()
  ```

  Evaluate expression and assign result to path.

  <a id="aridity.directives.PlusEquals"></a>



  ```python
  @_directive
  class PlusEquals()
  ```

  Assign expression to prefix plus an opaque key, i.e. add to list.

  <a id="aridity.functions"></a>



  <a id="aridity.functions.Functions"></a>



  ```python
  class Functions()
  ```

  <a id="aridity.functions.Functions.screenstr"></a>



  ```python
  def screenstr(scope, resolvable)
  ```

  GNU Screen string literal.

  <a id="aridity.functions.Functions.scstr"></a>



  ```python
  def scstr(scope, resolvable)
  ```

  SuperCollider string literal.

  <a id="aridity.functions.Functions.hclstr"></a>



  ```python
  def hclstr(scope, resolvable)
  ```

  HashiCorp configuration language string literal.

  <a id="aridity.functions.Functions.groovystr"></a>



  ```python
  def groovystr(scope, resolvable)
  ```

  Groovy string literal.

  <a id="aridity.functions.Functions.pystr"></a>



  ```python
  def pystr(scope, resolvable)
  ```

  Python literal.

  <a id="aridity.functions.Functions.shstr"></a>



  ```python
  def shstr(scope, resolvable)
  ```

  Shell string literal.

  <a id="aridity.functions.Functions.jsonquote"></a>



  ```python
  def jsonquote(scope, resolvable)
  ```

  JSON literal, also suitable for YAML.

  <a id="aridity.functions.Functions.xmlattr"></a>



  ```python
  def xmlattr(scope, resolvable)
  ```

  XML attribute literal (including quotes).

  <a id="aridity.functions.Functions.xmltext"></a>



  ```python
  def xmltext(scope, resolvable)
  ```

  XML content, suggest assigning this to & with xmlattr assigned to " as is convention.

  <a id="aridity.functions.Functions.tomlquote"></a>



  ```python
  def tomlquote(scope, resolvable)
  ```

  TOML string literal.

  <a id="aridity.functions.Functions.urlquote"></a>



  ```python
  def urlquote(scope, resolvable)
  ```

  Percent-encode all reserved characters.

  <a id="aridity.functions.Functions.map"></a>



  ```python
  def map(scope, objsresolvable, *args)
  ```

  If given 1 arg, evaluate it against every scope in `objsresolvable` and return that list.
  If given 2 args, the first is a variable name to which each scope is temporarily assigned.
  If given 3 args, the first two are variable names for scope key and scope respectively.

  <a id="aridity.functions.Functions.join"></a>



  ```python
  def join(scope, resolvables, *args)
  ```

  Concatenate the given list, using optional separator. Frequently used with `map`.

  <a id="aridity.functions.Functions.str"></a>



  ```python
  def str(scope, resolvable)
  ```

  Coerce to string.

  <a id="aridity.functions.Functions.list"></a>



  ```python
  def list(scope, *resolvables)
  ```

  Create a list.

  <a id="aridity.functions.Functions.try_"></a>



  ```python
  @realname('try')
  def try_(scope, *resolvables)
  ```

  Attempt to evaluate each resolvable, returning the first that succeeds.

  <a id="aridity.functions.Functions.hereslash"></a>



  ```python
  @realname('./')
  def hereslash(scope, *resolvables)
  ```

  Join the given path components with the directory of the current resource.

  <a id="aridity.functions.Functions.readfile"></a>



  ```python
  def readfile(scope, resolvable)
  ```

  Include the content of the given path.

  <a id="aridity.functions.Functions.processtemplate"></a>



  ```python
  def processtemplate(scope, resolvable)
  ```

  Evaluate the content of the given path as an expression.

  <a id="aridity.functions.Functions.pyref"></a>



  ```python
  def pyref(scope, moduleresolvable, qualnameresolvable)
  ```

  Python object in given module with given qualified name. Module may be relative to current resource, in which case assignment with `:=` is normally necessary. Typically used to import functions.

  <a id="aridity.functions.Functions.pyres"></a>



  ```python
  def pyres(scope, packageresolvable, nameresolvable, encoding=Text('ascii'))
  ```

  Python resource for inclusion with `.` directive.

  <a id="aridity.grammar"></a>



  <a id="aridity.keyring"></a>



  <a id="aridity.keyring.gpg"></a>



  ```python
  def gpg(scope, resolvable)
  ```

  Use gpg to decrypt the given base64-encoded blob.

  <a id="aridity.model"></a>



  <a id="aridity.model.Resolvable"></a>



  ```python
  class Resolvable(Struct)
  ```

  <a id="aridity.model.Resolvable.resolve"></a>



  ```python
  def resolve(scope)
  ```

  Evaluate this expression against the given scope.

  <a id="aridity.model.wrap"></a>



  ```python
  def wrap(value)
  ```

  Attempt to wrap the given value in a model object of the most specific type.

  <a id="aridity.scope"></a>



  <a id="aridity.scope.AbstractScope"></a>



  ```python
  class AbstractScope(Resolvable)
  ```

  <a id="aridity.scope.AbstractScope.resolved"></a>



  ```python
  def resolved(*path, **kwargs)
  ```

  Follow the given path to get an expression, evaluate it (resolving any paths it requires, recursively), and return the resulting model object.

  <a id="aridity.scope.Slash"></a>



  ```python
  class Slash(Text, Function)
  ```

  As text, the platform slash. As function, join args using that slash, starting with the last absolute path (or using all args if all relative).

  <a id="aridity.util"></a>



  <a id="aridity.util.openresource"></a>



  ```python
  def openresource(package_or_name, resource_name, encoding='ascii')
  ```

  Like `pkg_resources.resource_stream` but text mode.

  <a id="aridity.util.solo"></a>



  ```python
  def solo(v)
  ```

  Assert exactly one object in the given sequence and return it.

  <a id="parabject"></a>



  <a id="parabject.register"></a>



  ```python
  def register(obj, paracls)
  ```

  Instantiate paracls, set `obj` to be the regular object associated with the new parabject, and return the parabject.

  <a id="parabject.dereference"></a>



  ```python
  def dereference(parabject)
  ```

  Get the regular object associated with `parabject` or raise UnknownParabjectException.

  <a id="parabject.Parabject"></a>



  ```python
  class Parabject(object)
  ```

  Subclasses typically implement `__getattr__` for dynamic behaviour on attribute access.

  <a id="parabject.Parabject.__neg__"></a>



  ```python
  def __neg__()
  ```

  Dereference this parabject.


pkgId: 99d88f818ef321ebd458a1d9e75d29d0ef1ba18e8fba2338465a98bed230b1b6
name: python-arikaim
arch: src
version: 0.5.30
epoch: 0
release: 1
summary: Arikaim services server
url: https://github.com/arikaim/arikaim-services-server.git
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arikaim-0.5.30-1.src.rpm
checksum_type: sha256
description:
    * [Arikaim CMS](https://github.com/arikaim/arikaim)




  ```sh

  pip install arikaim

  ```





  ```sh

  arikaim-server run

  ```



  ```sh

  arikaim-server config create

  ```


pkgId: 0d910b659122832c27085f92ddf2edd411a167b07edc41a3e2dcdb1475f6f808
name: python-arikaim-client
arch: src
version: 1.0.18
epoch: 0
release: 1
summary: Arikaim CMS api client
url: https://github.com/arikaim/api-client-py
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arikaim-client-1.0.18-1.src.rpm
checksum_type: sha256
description:
  ![version: 1.0.0](https://img.shields.io/github/release/arikaim/api-client-py.svg)
  ![license: MIT](https://img.shields.io/badge/License-MIT-blue.svg)


  This repo is part of  [Arikaim CMS](http://arikaim.com)  project.




  ```sh
  pip install arikaim-client
  ```



  ```python

  from arikaim.client.client import ArikaimClient

  client = ArikaimClient(host,apiKey)

  data = {
      request data fields  key: value
  }

  response = client.request(method,url,data)

  print(response.status)
  print(response.to_dictonary())



  client.add_header({ 'key': 'value' })



  response = client.post(url,data)


  response = client.get(url)


  response = client.put(url,data)


  ```


pkgId: 7db26398f46569a4da85bff72cf815dc3eb5325e0526c060884d97ba37e032b6
name: python-arikaim-client
arch: src
version: 1.0.19
epoch: 0
release: 1
summary: Arikaim CMS api client
url: https://github.com/arikaim/api-client-py
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arikaim-client-1.0.19-1.src.rpm
checksum_type: sha256
description:
  ![version: 1.0.0](https://img.shields.io/github/release/arikaim/api-client-py.svg)
  ![license: MIT](https://img.shields.io/badge/License-MIT-blue.svg)


  This repo is part of  [Arikaim CMS](http://arikaim.com)  project.




  ```sh
  pip install arikaim-client
  ```



  ```python

  from arikaim.client import ArikaimClient

  client = ArikaimClient(host,apiKey)

  data = {
      request data fields  key: value
  }

  response = client.request(method,url,data)

  print(response.status)
  print(response.to_dictonary())



  client.add_header({ 'key': 'value' })



  response = client.post(url,data)


  response = client.get(url)


  response = client.put(url,data)



  client.save_ecoded_file(response,field_name, file_name)


  client.upload(path, file_name, field_name, data, method = POST)

  ```


pkgId: c47bf34e89fa3df9cc74b515959b079f190a7fd946142f866b16d04da0162a08
name: python-arinc429
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: ARINC 429 Protocol Implementation
url: https://github.com/jaimebw/arinc429
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arinc429-0.1.2-1.src.rpm
checksum_type: sha256
description:
  ```bash
  pip install arinc429
  ```


  ```python
  from arinc429 import Encoder
  a429 = Encoder()
  det= {
          "label":0o205,
          "value":100,
          "ssm": 0x03,
          "sdi":0,
          "encoding":"BNR"
          }
  a429.encode(**det)
  word = a429.word # uint32_t word
  bin_vals = a429.bword # binary word

  a429 = Encoder()
  w1= {
          "label":0o205,
          "value":100,
          "ssm": 0x03,
          "sdi":0,
          "msb":29,
          "lsb":12
          "encoding":"BNR"
          }
  w2= {
          "label":0o205, # Same label as before
          "value":1, # 1 or 0 as it is DSC
          "msb":11, # We dont care about lsb
          "encoding":"DSC"
          }
  a429.encode(**det)
  a429.encode(**w2)
  word = a429.word # uint32_t word


  ```
  This API is subject to change.

  If you want to encode another value using the same encoder, you need to reset the encoder before.
  ```python
  from arinc429 import Encoder
  a429 = Encoder()
  det= {
          "label":0o205,
          "value":100,
          "ssm": 0x03,
          "sdi":0,
          "encoding":"BNR"
          }
  a429.encode(**det)
  det2= {
          "label":0o206,
          "value":100,
          "ssm": 0x03,
          "sdi":0,
          "encoding":"BNR"
          }
  a429.reset() # If you dont do this, it will raise an exception
  a429.encode(**det)
  ```
  In case you wan to encode a DSC value into a BNR word, you can do it like this:
  ```python
  from arinc429 import Encoder
  a429 = Encoder()
  det= {
          "label":0o205,
          "value":100,
          "ssm": 0x03,
          "sdi":0,
          "encoding":"BNR",
          "msb":28,
          }
  a429.add_dsc(1,29) # Add a DSC value to the word
  ```
  The encoder takes care so you dont shoot your foot while encoding and loosing information,
  it wont let you encode something into a value that is already being used.

  If you were to try use a different msb in the add_dsc method, it would raise an exception as all the bits are already being used.

  This wont apply to multiple DSC values, so you can rewrite the DSC values




  There is a container class that allows you to easily work with the Arinc429 words.
  ```python
  from arinc429 import Arinc429Word

  word = Arinc429Word(
      byte1=0x00,
      byte2=0x20,
      byte3=0x00,
      byte4=0xe1
  )
  ```
  It accepts multiple input formats. For more info, look at the code.



  * [x] Encode BNR
  * [x] Encode BCD
  * [ ] Encode DSC
  * [ ] Raw encoding ( label + value)
  * [ ] Mixed encoding (DSC + BNR)

  * [X] Decode BNR
  * [ ] Decode rest of stuff

  * [ ] Implement in C

  I dont really follow a specific roadmap, I just add features as I need them.



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



  As for docs, I think the API is pretty simple and self-explanatory. If you have any questions, feel free to ask.



  * v0.1.2 - Added BCD, DSC, BNR + DSC encoding
  * v0.1.1 - Added BNR encoding
  * v0.1.0 - Initial release (encode BNR)






  This library provides comprehensive support for encoding and decoding ARINC 429 data words. ARINC 429 is a widely used avionics data bus specification that defines how avionics systems communicate in commercial aircraft.



  The library currently supports or plans to support the following encoding formats:

  - Binary (BNR)
  - Binary Coded Decimal (BCD)
  - Discrete (DSC)
  - Hybrid formats (e.g., BNR + DSC combinations)
  - Raw encoding (custom label + value pairs)



  The library is designed to be flexible and extensible, allowing for:

  - Standard ARINC 429 word formats
  - Custom data encoding schemes
  - Direct manipulation of label and data fields
  - Support for various SSM (Sign/Status Matrix) configurations

  For specific encoding requirements or custom implementations, please refer to the examples section above.


pkgId: 845b910639f7a1ab1c3425268286c0a899d43efdabe94b699b6a43d53b92de0b
name: python-arise
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Running Bitcoin and peripherals via Terminal User Interface
url: https://github.com/krutt/arise
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arise-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![Bitcoin-only](https://img.shields.io/badge/bitcoin-only-FF9900?logo=bitcoin)](https://twentyone.world)
  [![Docker](https://img.shields.io/badge/docker-2496ED?&logo=docker&logoColor=white)](https://hub.docker.com)
  [![Top](https://img.shields.io/github/languages/top/krutt/arise)](https://github.com/krutt/arise)
  [![Languages](https://img.shields.io/github/languages/count/krutt/arise)](https://github.com/krutt/arise)
  [![Size](https://img.shields.io/github/repo-size/krutt/arise)](https://github.com/krutt/arise)
  [![Last commit](https://img.shields.io/github/last-commit/krutt/arise/master)](https://github.com/krutt/arise)

  [![Arise Banner](static/arise-banner.svg)](https://github.com/krutt/arise/blob/master/static/arise-banner.svg)



  * python (3.8+)
  * pip
  * docker



  You can use `arise` simply by installing via `pip` on your Terminal.

  ```sh
  pip install arise
  ```
  <details>
  <summary>Sample output when running install command</summary>

  ![Sample Pip Install](https://github.com/krutt/arise/blob/master/static/pip-install.gif)

  </details>

  And build required images with `build` command. The following shows you how to build a `Testnet4`
  Bitcoin-Core node as well as [electrs](https://github.com/aekasitt/electrs),
  [mempool](https://github.com/mempool/mempool) and [mutiny-web](https://github.com/MutinyWallet/mutiny-web)

  ```sh
  arise build --testnet4 --electrs --mempool --mutiny-web
  ```

  <details>
  <summary>Sample output when running build command</summary>

  ![Sample Arise Build](https://github.com/krutt/arise/blob/master/static/arise-build.gif)

  </details>

  The initial build may take some time as it is downloading source codes from different repositories
  and interfacing with `Docker Daemon` to build according to flagged requirements. Once the build process
  completes, you can begin deploying local network with peripherals as such:

  ```sh
  arise deploy --testnet4 --with-electrs --with-mempool --with-mutiny-web
  ```

  <details>
  <summary>Sample output when running deploy command</summary>

  ![Sample Arise Deploy](https://github.com/krutt/arise/blob/master/static/arise-deploy.gif)

  </details>

  You will have docker containers running in the backend, ready to be interfaced by your local
  environment applications you are developing.



  Arise not only facilitates the deployment of intermingling [Bitcoin](https://twentyone.world) services
  but allows you to view Node's Blockchain Information, Mempool Information, Peripheral Details and etc.

  In order to view relevant metrics, launch the dashboard using the following command.

  ```sh
  arise dashboard
  ```

  <details>
  <summary>Sample output when running dashboard command</summary>

  ![Sample Arise Dashboard](https://github.com/krutt/arise/blob/master/static/arise-dashboard.gif)

  </details>



  To be determined



  1. [ปฐวี - Patavi](https://www.f0nt.com/release/sov-patavi) font by [uvSOV - Worawut Thanawatanawanich](fb.com/worawut.thanawatanawanich)
  2. [Florent Galon](https://flo.rent) for flame animation used as Tusk's HellFire.
  3. [Avinash Vytla](https://github.com/SnippetsDevelop) for breaking down Florent's process on [YouTube](https://youtu.be/RP_x_F7m1UI)



  You may run into this setback when first running this project. This is a
  [docker-py](https://github.com/docker/docker-py/issues/3059) issue widely known as of October 2022.

  ```python
  docker.errors.DockerException:
    Error while fetching server API version: (
      'Connection aborted.', FileNotFoundError(
        2, 'No such file or directory'
      )
    )
  ```

  See the following issue for Mac OSX troubleshooting.
  [docker from_env and pull is broken on mac](https://github.com/docker/docker-py/issues/3059#issuecomment-1294369344)
  Recommended fix is to run the following command:

  ```sh
  sudo ln -s "$HOME/.docker/run/docker.sock" /var/run/docker.sock
  ```



  This project is licensed under the terms of the MIT license.


pkgId: 4d68e69fd87e0a8f741b7606aa590e01b0759d1502f4d90e3cbfb654f13053b5
name: python-arise
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Running Bitcoin and peripherals via Terminal User Interface
url: https://pypi.org/project/arise/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arise-0.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Bitcoin-only](https://img.shields.io/badge/bitcoin-only-FF9900?logo=bitcoin)](https://twentyone.world)
  [![Docker](https://img.shields.io/badge/docker-2496ED?&logo=docker&logoColor=white)](https://hub.docker.com)
  [![Top](https://img.shields.io/github/languages/top/krutt/arise)](https://github.com/krutt/arise)
  [![Languages](https://img.shields.io/github/languages/count/krutt/arise)](https://github.com/krutt/arise)
  [![Size](https://img.shields.io/github/repo-size/krutt/arise)](https://github.com/krutt/arise)
  [![Last commit](https://img.shields.io/github/last-commit/krutt/arise/master)](https://github.com/krutt/arise)

  [![Arise Banner](static/arise-banner.svg)](https://github.com/krutt/arise/blob/master/static/arise-banner.svg)



  You can use `arise` simply by installing via `pip` on your Terminal.

  ```sh
  pip install arise
  ```
  <details>
    <summary> Sample output when running install command </summary>

  ![Sample Pip Install](https://github.com/krutt/arise/blob/master/static/pip-install.gif)

  </details>

  And build required images with `build` command. The following shows you how to build a `Testnet`
  Bitcoin-Core node as well as [electrs](https://github.com/aekasitt/electrs),
  [mempool](https://github.com/mempool/mempool) and [mutiny-web](https://github.com/MutinyWallet/mutiny-web)

  ```sh
  arise build --testnet --electrs --mempool --mutiny-web
  ```

  <details>
    <summary> Sample output when running build command </summary>

  ![Sample Arise Build](https://github.com/krutt/arise/blob/master/static/arise-build.gif)

  </details>

  The initial build may take some time as it is downloading source codes from different repositories
  and interfacing with `Docker Daemon` to build according to flagged requirements. Once the build process
  completes, you can begin deploying local network with peripherals as such:

  ```sh
  arise deploy --testnet --with-electrs --with-mempool --with-mutiny-web
  ```

  <details>
  <summary>Sample output when running deploy command</summary>

  ![Sample Arise Deploy](https://github.com/krutt/arise/blob/master/static/arise-deploy.gif)


  </details>

  You will have docker containers running in the backend, ready to be interfaced by your local
  environment applications you are developing.



  Arise not only facilitates the deployment of intermingling [Bitcoin](https://twentyone.world) services
  but allows you to view Node's Blockchain Information, Mempool Information, Peripheral Details and etc.

  In order to view relevant metrics, launch the dashboard using the following command.

  ```sh
  arise dashboard
  ```

  <details>
    <summary> Sample output when running dashboard command </summary>

  ![Sample Arise Dashboard](https://github.com/krutt/arise/blob/master/static/arise-dashboard.gif)
  </details>





  * [python](https://www.python.org) version 3.8 and above
  * [uv](https://docs.astral.sh/uv)
  * [docker](https://www.docker.com)



  The following guide walks through setting up your local working environment using `pyenv`
  as Python version manager and `uv` as Python package manager. If you do not have `pyenv`
  installed, run the following command.

  <details>
    <summary> Install using Homebrew (Darwin) </summary>

    ```sh
    brew install pyenv --head
    ```
  </details>

  <details>
    <summary> Install using standalone installer (Darwin and Linux) </summary>

    ```sh
    curl https://pyenv.run | bash
    ```
  </details>

  If you do not have `uv` installed, run the following command.

  <details>
    <summary> Install using Homebrew (Darwin) </summary>

    ```sh
    brew install uv
    ```
  </details>

  <details>
    <summary> Install using standalone installer (Darwin and Linux) </summary>

    ```sh
    curl -LsSf https://astral.sh/uv/install.sh | sh
    ```
  </details>


  Once you have `pyenv` Python version manager installed, you can
  install any version of Python above version 3.8 for this project.
  The following commands help you set up and activate a Python virtual
  environment where `uv` can download project dependencies from the `PyPI`
  open-sourced registry defined under `pyproject.toml` file.

  <details>
    <summary> Set up environment and synchronize project dependencies </summary>

    ```sh
    pyenv shell 3.11.9
    uv venv  --python-preference system
    source .venv/bin/activate
    uv sync --dev
    ```
  </details>

  Now you have the entire project set-up and ready to be tinkered with. Try out the
  standard `arise` command which brings up a help menu.

  <details>
    <summary> Launch Arise Help </summary>

    ```sh
    $ arise
    >  Usage: arise [OPTIONS] COMMAND [ARGS]...
    >
    >   arise
    >
    > Options:
    >   --help  Show this message and exit.
    >
    > Commands:
    >   auth       Persist authentications in desired run-control file.
    >   build      Build peripheral images for the desired cluster.
    >   clean      Remove all active "arise-*" containers, drop network.
    >   dashboard  Dashboard for checking current state of images deployed.
    >   deploy     Deploy cluster.
    >   pull       Pull core and peripheral images from GitHub container registry
    ```
  </details>



  1. [Dutch Golden Age Prints and Paintings](https://picryl.com/media/soldaat-die-zijn-roer-met-beide-handen-rechtop-voor-zich-vasthoudt-nr-20-ca-1c5eb2) - Rijksmuseum, Public Domain Marked.
  2. [ปฐวี - Patavi](https://www.f0nt.com/release/sov-patavi) font by [uvSOV - Worawut Thanawatanawanich](fb.com/worawut.thanawatanawanich)
  3. [Florent Galon](https://flo.rent) for flame animation used as Tusk's HellFire.
  4. [Avinash Vytla](https://github.com/SnippetsDevelop) for breaking down Florent's process on [YouTube](https://youtu.be/RP_x_F7m1UI)



  You may run into this setback when first running this project. This is a
  [docker-py](https://github.com/docker/docker-py/issues/3059) issue widely known as of October 2022.

  ```python
  docker.errors.DockerException:
    Error while fetching server API version: (
      'Connection aborted.', FileNotFoundError(
        2, 'No such file or directory'
      )
    )
  ```

  See the following issue for Mac OSX troubleshooting.
  [docker from_env and pull is broken on mac](https://github.com/docker/docker-py/issues/3059#issuecomment-1294369344)
  Recommended fix is to run the following command:

  ```sh
  sudo ln -s "$HOME/.docker/run/docker.sock" /var/run/docker.sock
  ```



  This project is licensed under the terms of the MIT license.


pkgId: 82225ee77bac7f09575f4860d58f51cf18b8ed819bb29891c2d2c4b04e403698
name: python-arise
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Running Bitcoin and peripherals via Terminal User Interface
url: https://pypi.org/project/arise/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arise-0.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Bitcoin-only](https://img.shields.io/badge/bitcoin-only-FF9900.svg?logo=bitcoin)](https://twentyone.world)
  [![Docker](https://img.shields.io/badge/docker-2496ED?&logo=docker&logoColor=white)](https://hub.docker.com)
  [![Documentation](https://img.shields.io/badge/pdoc-555?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAkUExURUdwTJHtkZDtkI/vj2rOYFXBQn3deZDukDuzAHDTaFrES4HhfmcEZqoAAAAHdFJOUwCAv0Df788Wv3t3AAACCElEQVQ4y42UsXKcMBCGuVC4Pc6FJuPGRzLDnK/xnAsKP0IeIU+QLhyFEHoAVlJlNxJHlwbBVY4LyeeXs4BLCnQzCTOAZj+0K+3/iyD4zwvhIIiiey/+iVRB8LnJPJBq6QA8eeBRuI8R8UFKTYbc7QGqQRIAOa++KKAD6LW4nQMFwgIB7gMlLaPQz8GVMlhxjD2AoKVcSeKl2jCAyq2K/5yBsiINRqSx+QwUcmhgFNmXOWivzO2CZsWTlyrl2U69qPmMjUi0pBqreY0bvi8BGGHzVaVKJnWHi2o5bwlhOI4JGF9yzeuTPua+5qoHEHvfDAvF398qPz70vboRl4DV8vESCC3HqSfsAAotkNf0sY1HhnR+AZTQruzrBXAHLLe/h9HDtIRwFa+v3XvL4bX8NXpvrLTDb31tImdezvO7dgipAYTOmhyYXAYptOvNuPVR99Ry24BieJlqEX8bdzhUWlBo3JQTMExZ//X7BNplmCgN4t3FFdecnUHJcHLi6ogfEurCujdlMwK38AMItd/FETp0TD2vi6nvW3AHYkje1VmcKJ6humyn46hB1ebkqPwhsYkJs8+jmLYp2Z5AgwkfnlRLPR7BsBTYUH3M7pEVRAMcT2dXbbWLM6d/SEFi6pKayVU75z2Oh3FKoKt7Lv/IkRw6M4mJXKrerP8aII6vz8MVxvsv//gNfQBIOvQNeKr0GQAAAABJRU5ErkJggg==)](https://krutt.github.io/arise)
  [![Languages](https://img.shields.io/github/languages/count/krutt/arise)](https://github.com/krutt/arise)
  [![Last commit](https://img.shields.io/github/last-commit/krutt/arise/master)](https://github.com/krutt/arise)
  [![Size](https://img.shields.io/github/repo-size/krutt/arise)](https://github.com/krutt/arise)
  [![Top](https://img.shields.io/github/languages/top/krutt/arise)](https://github.com/krutt/arise)

  [![Arise Banner](static/arise-banner.svg)](https://github.com/krutt/arise/blob/master/static/arise-banner.svg)



  You can use `arise` simply by installing via `pip` on your Terminal.

  ```sh
  pip install arise
  ```
  <details>
    <summary> Sample output when running install command </summary>

  ![Sample Pip Install](https://github.com/krutt/arise/blob/master/static/pip-install.gif)

  </details>

  And build required images with `build` command. The following shows you how to build a `Testnet`
  Bitcoin-Core node as well as [electrs](https://github.com/aekasitt/electrs),
  [mempool](https://github.com/mempool/mempool) and [mutiny-web](https://github.com/MutinyWallet/mutiny-web)

  ```sh
  arise build --testnet --electrs --mempool --mutiny-web
  ```

  <details>
    <summary> Sample output when running build command </summary>

  ![Sample Arise Build](https://github.com/krutt/arise/blob/master/static/arise-build.gif)

  </details>

  The initial build may take some time as it is downloading source codes from different repositories
  and interfacing with `Docker Daemon` to build according to flagged requirements. Once the build process
  completes, you can begin deploying local network with peripherals as such:

  ```sh
  arise deploy --testnet --with-electrs --with-mempool --with-mutiny-web
  ```

  <details>
  <summary>Sample output when running deploy command</summary>

  ![Sample Arise Deploy](https://github.com/krutt/arise/blob/master/static/arise-deploy.gif)


  </details>

  You will have docker containers running in the backend, ready to be interfaced by your local
  environment applications you are developing.



  Arise not only facilitates the deployment of intermingling [Bitcoin](https://twentyone.world) services
  but allows you to view Node's Blockchain Information, Mempool Information, Peripheral Details and etc.

  In order to view relevant metrics, launch the dashboard using the following command.

  ```sh
  arise dashboard
  ```

  <details>
    <summary> Sample output when running dashboard command </summary>

  ![Sample Arise Dashboard](https://github.com/krutt/arise/blob/master/static/arise-dashboard.gif)
  </details>





  * [python](https://www.python.org) version 3.8 and above
  * [uv](https://docs.astral.sh/uv)
  * [docker](https://www.docker.com)



  The following guide walks through setting up your local working environment using `pyenv`
  as Python version manager and `uv` as Python package manager. If you do not have `pyenv`
  installed, run the following command.

  <details>
    <summary> Install using Homebrew (Darwin) </summary>

    ```sh
    brew install pyenv --head
    ```
  </details>

  <details>
    <summary> Install using standalone installer (Darwin and Linux) </summary>

    ```sh
    curl https://pyenv.run | bash
    ```
  </details>

  If you do not have `uv` installed, run the following command.

  <details>
    <summary> Install using Homebrew (Darwin) </summary>

    ```sh
    brew install uv
    ```
  </details>

  <details>
    <summary> Install using standalone installer (Darwin and Linux) </summary>

    ```sh
    curl -LsSf https://astral.sh/uv/install.sh | sh
    ```
  </details>


  Once you have `pyenv` Python version manager installed, you can
  install any version of Python above version 3.8 for this project.
  The following commands help you set up and activate a Python virtual
  environment where `uv` can download project dependencies from the `PyPI`
  open-sourced registry defined under `pyproject.toml` file.

  <details>
    <summary> Set up environment and synchronize project dependencies </summary>

    ```sh
    pyenv shell 3.11.9
    uv venv  --python-preference system
    source .venv/bin/activate
    uv sync --dev
    ```
  </details>

  Now you have the entire project set-up and ready to be tinkered with. Try out the
  standard `arise` command which brings up a help menu.

  <details>
    <summary> Launch Arise Help </summary>

    ```sh
    $ arise
    >  Usage: arise [OPTIONS] COMMAND [ARGS]...
    >
    >   arise
    >
    > Options:
    >   --help  Show this message and exit.
    >
    > Commands:
    >   auth       Persist authentications in desired run-control file.
    >   build      Build peripheral images for the desired cluster.
    >   clean      Remove all active "arise-*" containers, drop network.
    >   dashboard  Dashboard for checking current state of images deployed.
    >   deploy     Deploy cluster.
    >   pull       Pull core and peripheral images from GitHub container registry
    ```
  </details>



  * **0.1.0** Cloned useful and useless things from [aesir](https://github.com/krutt/aesir)
  * **0.1.1** Remove visual janks from progress bars
  * **0.1.2** Establish new yaml formats and typings
  * **0.1.3** Attempt to make `-testnet4` flag work on bitcoin daemon
  * **0.1.4** Experiment with c compilers for faster build-times
  * **0.1.5** Add peripheral images `arise-elctrs`, `arise-mempoopl` and `arise-mutiny-wallet`
  * **0.1.6** Pretend launching electrs on `testnet4` is easy by using custom `electrs` repository
  * **0.1.7** Separate middleware deployment and add delay for `postgres` setup time
  * **0.1.8** Experiment with cookie authentications between peripheral images
  * **0.1.9** Enable intranet between containers and authenticate using cookie
  * **0.2.0** Attribute animation tutoral and typeface in README markdown
  * **0.2.1** Drop `testnet4` hacky implementation and custom `electrs` repository; Not worth it.
  * **0.2.2** Attribute public domain art, persist authentications, drop `poetry` and use `uv`
  * **0.2.3** Use GitHub workflows to setup GitHub Pages application for documentation



  1. [Dutch Golden Age Prints and Paintings](https://picryl.com/media/soldaat-die-zijn-roer-met-beide-handen-rechtop-voor-zich-vasthoudt-nr-20-ca-1c5eb2) - Rijksmuseum, Public Domain Marked.
  2. [ปฐวี - Patavi](https://www.f0nt.com/release/sov-patavi) font by [uvSOV - Worawut Thanawatanawanich](fb.com/worawut.thanawatanawanich)
  3. [Florent Galon](https://flo.rent) for flame animation used as Tusk's HellFire.
  4. [Avinash Vytla](https://github.com/SnippetsDevelop) for breaking down Florent's process on [YouTube](https://youtu.be/RP_x_F7m1UI)



  You may run into this setback when first running this project. This is a
  [docker-py](https://github.com/docker/docker-py/issues/3059) issue widely known as of October 2022.

  ```python
  docker.errors.DockerException:
    Error while fetching server API version: (
      'Connection aborted.', FileNotFoundError(
        2, 'No such file or directory'
      )
    )
  ```

  See the following issue for Mac OSX troubleshooting.
  [docker from_env and pull is broken on mac](https://github.com/docker/docker-py/issues/3059#issuecomment-1294369344)
  Recommended fix is to run the following command:

  ```sh
  sudo ln -s "$HOME/.docker/run/docker.sock" /var/run/docker.sock
  ```



  This project is licensed under the terms of the MIT license.


pkgId: c9fc5000939c1628c0949c686643229b98696c6a9b4dbd2cd6e71d14e3a08e13
name: python-ariston
arch: src
version: 0.19.6
epoch: 0
release: 1
summary: Ariston module
url: https://pypi.org/project/ariston/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ariston-0.19.6-1.src.rpm
checksum_type: sha256
description:
  [![CodeQL](https://github.com/fustom/python-ariston-api/actions/workflows/codeql.yml/badge.svg)](https://github.com/fustom/python-ariston-api/actions/workflows/codeql.yml) [![Upload Python Package](https://github.com/fustom/python-ariston-api/actions/workflows/python-publish.yml/badge.svg)](https://github.com/fustom/python-ariston-api/actions/workflows/python-publish.yml)


  A Python module for controlling Ariston devices with cloud polling.
  The following devices are currently supported:
  - Ariston Alteas One 24
  - Ariston Velis Evo
  - Ariston Velis Lux
  - Ariston Lydos Hybrid
  - Ariston Genus One
  - Ariston Nuos Split
  - Ariston Thision S
  - Chaffoteaux INOA S 24


  Use pip3 to install the latest version of this module.
  ```
  pip3 install ariston
  ```


  First, open Python 3 and import ariston module.
  ```
  python3
  ```
  ```python3
  import ariston
  ```

  Discover devices if you dont know your gateway id. You can skip this step.
  ```python3
  raw_devices = ariston.discover("username", "password")
  ```
  For example the gateway id for your first device.
  ```python3
   raw_devices[0]['gw']
  ```
  Get your device
  ```python3
  device = ariston.hello("username", "password", "gateway", is_metric, "location")
  ```
  [Go use your device section](#use-your-device)

  ```python3
  raw_devices = await ariston.async_discover("username", "password")
  device = await ariston.async_hello("username", "password", "gateway", is_metric, "location")
  ```
  [Go use your device section](#use-your-device)

  First, open Python 3 and import Ariston class from this module.
  ```
  python3
  ```
  ```python3
  from ariston import Ariston
  ```
  Create a new Ariston instance
  ```python3
  ariston = Ariston()
  ```
  Now let's try some functions


  The cloud requests are asynchronous, so if you call them from a synchronous function or not even from function, you should use asyncio.
  ```python3
  import asyncio
  ```

  Sync
  ```python3
  asyncio.run(ariston.async_connect("username", "password"))
  ```
  Async
  ```python3
  await ariston.async_connect("username", "password")
  ```
  - username: Your ariston cloud username.
  - password: Your ariston cloud password.


  Use this function to discover devices. You can skip this step if you already know the gateway id.

  Sync
  ```python3
  devices = asyncio.run(ariston.async_discover())
  ```
  Async
  ```python3
  devices = await ariston.async_discover()
  ```


  Use this function to create the device object.

  Sync
  ```python3
  device = asyncio.run(ariston.async_hello("gateway", is_metric, "location"))
  ```
  Async
  ```python3
  device = await ariston.async_hello("gateway", is_metric, "location")
  ```
  - gateway: You can find the value in the returned discover dictionary name 'gw'
  - is_metric: Optional. True or False. True means metric, False means imperial. Only works with Galevo (Alteas One, Genus One, etc) system. Default is True.
  - language_tag: Optional. Check https://en.wikipedia.org/wiki/IETF_language_tag Only works with Galevo (Alteas One, Genus One, etc) system. Default is "en-US".



  Sync
  ```python3
  device.get_features()
  ```
  Async
  ```python3
  await device.async_get_features()
  ```

  Sync
  ```python3
  device.update_state()
  ```
  Async
  ```python3
  await device.async_update_state()
  ```

  Sync
  ```python3
  device.update_energy()
  ```
  Async
  ```python3
  await device.async_update_energy()
  ```


