# packages

pkgId: 1a04ed1065ebeaa82ce6bd003e4f3141923f0ef2e9ea6b4a06d7eeac5f739b0a
name: python-rasa-pro-help
arch: noarch
version: 3.11.1
epoch: 0
release: 1
summary: Development documents and examples for rasa-pro
url: https://rasa.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rasa-pro-3.11.1-1.src.rpm
location_href: Packages/python-rasa-pro-help-3.11.1-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">Rasa Pro</h1>

  <div align="center">

  [![Build Status](https://github.com/RasaHQ/rasa-private/workflows/Continuous%20Integration/badge.svg)](https://github.com/RasaHQ/rasa-private/actions)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=RasaHQ_rasa&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=RasaHQ_rasa)
  [![Documentation Status](https://img.shields.io/badge/docs-stable-brightgreen.svg)](https://rasa.com/docs/rasa-pro/)

  </div>

  <hr />


  Rasa Pro is a framework for building scalable, dynamic conversational AI assistants that integrate large language models (LLMs) to enable more contextually aware and agentic interactions. Whether you’re new to conversational AI or an experienced developer, Rasa Pro offers enhanced flexibility, control, and performance for mission-critical applications.

  Building on the foundation of Rasa Open Source, Rasa Pro adds advanced features like CALM (Conversational AI with Language Models) and Dialogue Understanding (DU), which enable developers to shift from traditional intent-driven systems to LLM-based agents. This allows for more robust, responsive interactions that adhere strictly to business logic, while reducing risks like prompt injection and minimizing hallucinations.

  **Key Features:**

  - **Flows for Business Logic:** Easily define business logic through Flows, a simplified way to describe how your AI assistant should handle conversations. Flows help streamline the development process, focusing on key tasks and reducing the complexity involved in managing conversations.
  - **Automatic Conversation Repair:** Ensure seamless interactions by automatically handling interruptions or unexpected inputs. Developers have full control to customize these repairs based on specific use cases.
  - **Customizable and Open:** Fully customizable code that allows developers to modify Rasa Pro to meet specific requirements, ensuring flexibility and adaptability to various conversational AI needs.
  - **Robustness and Control:** Maintain strict adherence to business logic, preventing unwanted behaviors like prompt injection and hallucinations, leading to more reliable responses and secure interactions.
  - **Built-in Security:** Safeguard sensitive data, control access, and ensure secure deployment, essential for production environments that demand high levels of security and compliance.



  A [free developer license](https://rasa.com/docs/rasa-pro/developer-edition/) is available so you can explore and get to know Rasa Pro. For small production deployments, the Extended Developer License allows you to take your assistant live in a limited capacity. A paid license is required for larger-scale production use, but all code is visible and can be customized as needed.

  To get started right now, you can

  `pip install rasa-pro`

  Check out our

  - [Rasa-pro Quickstart](https://rasa.com/docs/rasa-pro/installation/quickstart/),
  - [Conversational AI with Language Models (CALM) conceptual rundown](https://rasa.com/docs/rasa-pro/calm/),
  - [Rasa Pro / CALM tutorial](https://rasa.com/docs/rasa-pro/tutorial), and
  - [Rasa pro changelog](https://rasa.com/docs/rasa/rasa-pro-changelog/)

  for more. Also feel free to reach out to us on the [Rasa forum](https://forum.rasa.com/).


pkgId: 572c7bccb049a0590701b38bdeae7b04f086efa5a35b1076601a758be2e5fd5f
name: python-rasa-vier-cvg-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for rasa-vier-cvg
url: https://cognitivevoice.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rasa-vier-cvg-1.4.0-1.src.rpm
location_href: Packages/python-rasa-vier-cvg-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Rasa is the leading open-source conversational AI platform that enables both individual developers and large enterprises to build superior AI assistants and chatbots. Rasa provides the infrastructure and tools needed to build the outstanding tools and transform the way customers communicate with businesses. Rasa can be deeply customized down to levels not possible with other platforms due to the open sourced architecture and machine learning.

  Rasa is used by millions of developers and small teams to program enterprise conversational AI applications.

  Rasa is available in two editions: *Rasa Open Source* (free) and *Rasa Enterprise* (commercial). Both editions can be used to build voicebots with CVG.

  [VIER Cognitive Voice Gateway (CVG)](https://cognitivevoice.io/docs) enables access to telephony, speech-to-text (STT), text-to-speech (TTS) and contact center integration for chatbots built with Rasa. I.e. CVG makes your chatbot to a voicebot handling phone calls.

  To build voice bots using Rasa and CVG, you need an account in CVG and a Rasa installation.



  Rasa can be hosted anywhere: in the cloud, On-Prem or in any data center. Migrations between hosting solutions can be performed at any stage.

  Many organizations developing chatbots and voicebots with Rasa start with Rasa Open Source On-Prem. An [installation guide](https://rasa.com/docs/rasa/installation/installing-rasa-open-source) is provided by Rasa. Rasa also provides a Playground that can be used to develop bots without requiring an On-Prem installation.

  To install Rasa Enterprise, use the [installation guide](https://rasa.com/docs/rasa-enterprise/installation-and-setup/installation-guide) provided by Rasa.



  The Rasa integration with CVG is done with a new channel for Rasa provided in this repo.
  It implements all the CVG APIs relevant for bots to provide CVGs full power to you as a Rasa developer.

  The easiest way to install this package is through PyPI.

  ```
  pip install rasa-vier-cvg
  ```



  If you are using Rasa on Docker and you don't want to build a derived image, you can also download the [channel source](https://github.com/VIER-CognitiveVoice/rasa-vier-cvg/) and bind-mount the package into a `rasa/rasa`-base container with a volume definition like this:

  ```
  ./rasa_vier_cvg:/opt/venv/lib/python3.10/site-packages/rasa_vier_cvg
  ```



  Add the following content to `credentials.yml`:

  ```
  rasa_vier_cvg.CVGInput:
    token: "CHOOSE_YOUR_TOKEN"
    blocking_endpoints: false
  ```
  You can generate the token yourself. For example with any password generator.

  This channel will be used for communication with CVG.
  The Bot token is required so that Rasa can verify that CVG is communicating with your Rasa Bot.

  The optional `blocking_endpoints` option allows to disable blocking CVG's request while processing the user message.
  For compatibility reasons this option defaults to `true`, but we recommend setting it to `false`. The `/session` request is unaffected by this option and always blocks.



  If you do not yet have an account for CVG please contact us at [info@vier.ai](mailto:info@vier.ai).

  ![conversational-ai-rasa](https://user-images.githubusercontent.com/42033366/192627897-cc2ec42e-0bf4-4c91-bcf9-242a6077b609.PNG)

  To configure the connection between your Rasa bot and [CVG](https://cognitivevoice.io) just select Rasa as the bot template, enter your Rasa URL (e.g. `https://rasa.example.org/webhooks/vier-cvg`) and your token, as set in credentials.yaml, in the CVG project settings.

  ![Configuring a Rasa project in CVG](https://github.com/VIER-CognitiveVoice/rasa-vier-cvg/blob/master/CVG-UI-configuring-a-rasa-project.png)





  Every message and intent sent by CVG will have a metadata-field called `cvg_body`. This field will always contain the JSON sent by CVG to the Rasa channel.
  In the following sections, the term "metadata" will refer to this `cvg_body` field.

  Normal spoken inputs from the user as well as DTMF inputs will be transmitted as text inputs to Rasa. All other CVG events will trigger specific intents as described below.
  All messages and intents will have CVG's dialog ID as the `sender_id` field.

  Text inputs follow [this specification](https://cognitivevoice.io/specs/?urls.primaryName=Bot%20API%20%28Client%29#/bot/message). An example for the text input metadata would be:

  ```json
  {
    "dialogId": "09e59647-5c77-4c02-a1c5-7fb2b47060f1",
    "projectContext": {
      "projectToken": "d30b1c38-b2fd-39c8-bec2-b268871338b0",
      "resellerToken": "ed4aff6d-c6f8-4ac9-ab67-d072ef45d9a0"
    },
    "timestamp": 1535546718115,
    "type": "SPEECH",
    "text": "Hello!",
    "confidence": 100,
    "vendor": "GOOGLE",
    "language": "en-US",
    "callback": "https://cognitivevoice.io/v1"
  }
  ```

  Voice and DTMF inputs can be differentiated using the `type` field, which would be `SPEECH` for voice and `DTMF` for DTMF tones.


  Here is a list of the intents triggered by CVG for certain events:

  * `cvg_session`: This intent is triggered once (after a new call has been established) before anything else to allow the bot to respond e.g. with a greeting. Metadata is defined by [this specification](https://cognitivevoice.io/specs/?urls.primaryName=Bot%20API%20%28Client%29#/bot/session)
  * `cvg_terminated`: This intent is triggered once the conversation has been terminated by the user. Metadata is specified [here](https://cognitivevoice.io/specs/?urls.primaryName=Bot%20API%20%28Client%29#/bot/terminated).
  * `cvg_inactivity`: This intent is triggered once the inactivity timeout has been triggered due to a lack of user input. Metadata is specified [here](https://cognitivevoice.io/specs/?urls.primaryName=Bot%20API%20%28Client%29#/bot/inactivity).
  * `cvg_recording`: This intent is triggered once the recording status changes. Metadata is specified [here](https://cognitivevoice.io/specs/?urls.primaryName=Bot%20API%20%28Client%29#/bot/answer).
  * `cvg_answer_number`, `cvg_answer_multiplechoice` and `cvg_answer_timeout`: These intents are triggered once a prompt (see next section) of type `Number` or `MultipleChoice` complete are timeout. Metadata is specified [here](https://cognitivevoice.io/specs/?urls.primaryName=Bot%20API%20%28Client%29#/bot/answer).
  * `cvg_outbound_success`: The success result of `forward` or `bridge` (see next section). It signals that the outgoing call has been successfully established. Metadata is specified by the response objects of the matching operations from the [Call API](https://cognitivevoice.io/specs/?urls.primaryName=Call%20API#/call/forward).
  * `cvg_outbound_failure`: The failure result of `forward` or `bridge` (see next section). It signals that the outgoing call could not be established and provides some details as to why. Metadata is specified by the response objects of the matching operations from the [Call API](https://cognitivevoice.io/specs/?urls.primaryName=Call%20API#/call/forward).
    Depending on the exact reason (check out the `OutboundCallFailure` model in the
    [API specification](https://cognitivevoice.io/specs/?urls.primaryName=Call%20API) for all possible reasons) there might not
    be a `ringStartTimestamp` and the `ringTime` could be zero.




  The output channel for CVG supports `text_message`s and `custom_json`.

  Text messages will be translated into [Say](https://cognitivevoice.io/specs/?urls.primaryName=Call%20API#/call/say)-commands.

  Every other command supported by the channel must be triggered by using custom JSON. The key for the custom JSON messages is an encoding of CVG's API endpoints and follows this schema:

  ```
  cvg_<path with underscores instead of slashes>
  ```

  So for example in order to use the [/call/play](https://cognitivevoice.io/specs/?urls.primaryName=Call%20API#/call/play) endpoint you would use `cvg_call_play` as the key, for [/call/transcription/switch](https://cognitivevoice.io/specs/?urls.primaryName=Call%20API#/call/switchTranscription) it would be `cvg_call_transcription_switch` and so on.

  The JSON values will be used as-is as the request-body for the API call, so refer to the API documentations, most commonly the [Call API](/specs/?urls.primaryName=Call%20API) for specifics.
  The only exception to this is, that the dialog ID (`sender_id`) which is automatically injected into the payloads as necessary.

  Currently all operation documented in the [Call API](https://cognitivevoice.io/specs/?urls.primaryName=Call%20API) as well as dialog_delete and dialog_data are implemented.

  In case you want to call an API endpoint which is a bit more complex like `/call/forward` or something that is currently not implemented in this channel, you can use simply make the request manually using python.



  After setting up your Rasa Installation and configuring the CVG Project, let's create a simple Rasa Bot together.
  Create a new folder and generate the default bot:
  ```
  rasa init
  ```
  The bot is ready to be tested. Make sure you expose it in a way CVG can reach it, and configure the CVG channel.

  You can start the Rasa bot using `rasa run`. Make sure, you run `rasa train` after modifying the bot.

  Please paste the following intents into your `domain.yml`. See below, on how the intent section should look like. They are explained [above](#communication), but don't worry about that yet.
  ```
  intents:
    - greet
    - goodbye
    - affirm
    - deny
    - mood_great
    - mood_unhappy
    - bot_challenge

    - cvg_outbound_success
    - cvg_outbound_failure
    - cvg_session
    - cvg_answer_multiplechoice # you can remove cvg_answer_*, if you don't use the /call/prompt feature.
    - cvg_answer_number
    - cvg_answer_timeout
    - cvg_message
    - cvg_inactivity
    - cvg_terminated
    - cvg_recording
  ```


  To end the call / hang up after it said "Bye", you can modify the `utter_goodbye` message in the `domain.yml` like this:
  ```
    utter_goodbye:
    - text: "Bye"
      custom:
        cvg_call_drop:
  ```

  To forward the caller to an agent, you can modify `utter_iamabot` like this:
  ```
    utter_iamabot:
    - text: "I am a bot, powered by Rasa. But I will gladly forward you to a human."
      custom:
        cvg_call_forward:
          destinationNumber: "+4969907362380"
  ```




  Please reference the Rasa documentation, on how to create and call a custom action.
  This example will use the default Rasa action server, which you can start with `rasa run actions`

  ```
  class ActionPrintCvgBody(Action):

      def name(self) -> Text:
          return "action_print_cvg_body" # The action name which you can use in your domain.yml

      def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
          try:
            cvg_body = None
            for e in tracker.events[::-1]: # The loop will find the last message from the user
              if e["event"] == "user":
                cvg_body = e["metadata"]["cvg_body"]
                break
            print("Found cvg_body: ", cvg_body) # After we found the last message from the user and stored the CVG response body in cvg_body, we can print it
          except KeyError as e:
            print("Failed to read cvg_body: ", e) # The last user message did not contain the cvg_body.
            
          finally:
            return []
  ```



  You may already notice that the bot immediately says something after calling. That is because we haven't told Rasa yet how to handle the `cvg_session` intent.
  That intent is triggered when [/session](https://cognitivevoice.io/specs/?urls.primaryName=Bot%20API%20(Client)#/bot/session) in the [Bot API](https://cognitivevoice.io/specs/?urls.primaryName=Bot%20API%20(Client)) is called.

  In your `stories.yml` replace the intent `greet` with `cvg_session`:
  ```diff
    steps:
  -   - intent: greet
  +   - or:
  +    - intent: greet
  +    - intent: cvg_session
  ```
  Make sure to do that with all 3 stories and run `rasa train` before starting the Rasa bot.

  To extract more information from the message inside an action, please read about [Events](#from-cvg-to-rasa-events) above.

  The intents `cvg_outbound_success` and `cvg_outbound_failure` are relevant if you want to forward or bridge a call.
  You could do something like this in your `domain.yml`:
  ```
    utter_outbound_failure:
    - text: "Unfortunatly, the outbound call failed."
  ```
  and in your `rules.yml`:
  ```
  - rule: Handle outbound call failure
    steps:
    - intent: cvg_outbound_failure
    - action: utter_outbound_failure
  ```

  This will inform the user about outbound call failures.
  To handle the `cvg_outbound_success` intent, you can create an action, but we cannot say something to a call that has already been forwarded.


  If you want to use the `/call/prompt` feature to prompt for a number, you can create the prompt and responses in your `domain.yml`:
  ```
    utter_prompt:
      - custom:
        cvg_call_prompt:
          text: Please provide 3 Numbers
          timeout: 10000
          type:
            name: Number
            maxDigits: 3
            submitInputs:
              - DTMF_#

    utter_prompt_answer_number:
    - text: "You can access the result of the prompt inside a custom action."

    utter_prompt_timeout:
    - text: "You did not provide an answer, the prompt timed out"
  ```
  For how the write such an action, see [below](#use-an-action-to-extract-information-from-cvg).

  And add the following rules inside your `data/rules.yml`:
  ```
  - rule: Handle prompt timeout
    steps:
    - intent: cvg_answer_timeout
    - action: utter_prompt_timeout

  - rule: Handle prompt answer
    steps:
    - intent: cvg_answer_number
    - action: utter_prompt_answer_number
  ```




  We provide a demo voicebot built with Rasa and CVG on [GitHub](https://github.com/VIER-CognitiveVoice/rasa-meter-reading-bot/). We also run this voicebot, so you can simply get a first impression. For more information, visit our [GitHub project](https://github.com/VIER-CognitiveVoice/rasa-meter-reading-bot/).


  - When CVG sends an event to Rasa, this channel will generate the intent (as specified [above](#from-rasa-to-cvg-commands))
    - The intent's metadata will contain the body sent by CVG as specified in the [Bot API](https://cognitivevoice.io/specs/?urls.primaryName=Bot%20API%20(Client))
  - When you utter a text message, or a [Custom Response](https://rasa.com/docs/rasa/responses/#custom-output-payloads), we pass the content of the payload to CVG after adding the `dialog_id`


pkgId: d17ab64a625576ba01931702b20cb54f82cc505d5544ed30cec3c1a3f3bfdf4c
name: python-raster-tools-help
arch: noarch
version: 0.9.6
epoch: 0
release: 1
summary: Development documents and examples for raster-tools
url: https://github.com/UM-RMRS/raster_tools
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-raster-tools-0.9.6-1.src.rpm
location_href: Packages/python-raster-tools-help-0.9.6-1.noarch.rpm
checksum_type: sha256
description:
  Raster Tools is a python package that facilitates a wide range of spatial,
  statistical, machine learning analyses using delayed and automated parallel
  processing. Our library focuses on significantly reducing processing time and
  storage space associated with analyzing large spatial datasets while also
  introducing new spatial, statistical, machine learning concepts into an
  easy-to-use python based API.

  ![image.gif](./notebooks/images/animatedRMRS2.gif)


  - [How to Contribute](./CONTRIBUTING.md)
  - [Documentation](https://um-rmrs.github.io/raster_tools/)
  - [Notebooks & Tutorials](./notebooks/README.md)
  - [PyPi link](https://pypi.org/project/raster-tools/)
  - [Installation](./notebooks/install_raster_tools.md)


  - [dask](https://dask.org/)
  - [dask_image](https://image.dask.org/en/latest/)
  - [dask-geopandas](https://dask-geopandas.readthedocs.io/en/stable/)
  - [geopandas](https://geopandas.org/en/stable/)
  - [numba](https://numba.pydata.org/)
  - [odc-geo](https://odc-geo.readthedocs.io/en/latest/)
  - [rasterio](https://rasterio.readthedocs.io/en/latest/)
  - [rioxarray](https://corteva.github.io/rioxarray/stable/)
  - [shapely 2](https://shapely.readthedocs.io/en/stable/)
  - [xarray](https://xarray.pydata.org/en/stable/)


pkgId: a79a98026dd2b4cb1527efb29acac904c7bd0e148a0e2fc001e9626446c42504
name: python-rateLimitedQueues-help
arch: noarch
version: 0.0.3.post1
epoch: 0
release: 1
summary: Development documents and examples for rateLimitedQueues
url: https://github.com/BhaskarPanja93/rateLimitedQueues
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rateLimitedQueues-0.0.3.post1-1.src.rpm
location_href: Packages/python-rateLimitedQueues-help-0.0.3.post1-1.noarch.rpm
checksum_type: sha256
description:
  ```pip install rateLimitedQueues --upgrade```




  <br>To install:
  ```
  pip install rateLimitedQueues --upgrade
  pip3 install rateLimitedQueues --upgrade
  python -m pip install rateLimitedQueues --upgrade
  python3 -m pip install rateLimitedQueues --upgrade
  ```



  ```
  from rateLimitedQueues import RateLimitedQueues

  rateLimiter = RateLimitedQueues()

  def mainFunction(n, *args, **kwargs):
      sleep(1)
      print(args, kwargs)

  def postFunction(*args, **kwargs):
      sleep(1)
      print(args, kwargs)

  for i in range(10):
      rateLimiter.queueAction(mainFunction=mainFunction, executeMainInThread=True, executePostInThread=True,
      postFunction=postFunction, postArgs=(i,), postKwArgs={i: i**2}, n=i)

  ```


pkgId: 131fb756a43ddd6174f3537a164d702d7c32e6425dcc682bb5e03bf964856543
name: python-ratinabox-help
arch: noarch
version: 1.15.2
epoch: 0
release: 1
summary: Development documents and examples for ratinabox
url: https://pypi.org/project/ratinabox/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ratinabox-1.15.2-1.src.rpm
location_href: Packages/python-ratinabox-help-1.15.2-1.noarch.rpm
checksum_type: sha256
description:
  `RatInABox` (see [paper](https://elifesciences.org/articles/85274)) is a toolkit for generating synthetic behaviour and neural data for spatially and/or velocity selective cell types in complex continuous environments.

  [**Install**](#installing-and-importing) | [**Demos**](#get-started) | [**Features**](#feature-run-down) | [**Contributions and Questions**](#contribute) | [**Cite**](#cite)


  With `RatInABox` you can:

  * **Generate realistic trajectories** for rats exploring complex 1 and 2D environments under a smooth random policy, an external control signal, or your own trajectory data.
  * **Generate artificial neuronal data** for various location- or velocity-selective cells found in the brain (e.g., but not limited to, Hippocampal cell types), or build your own more complex cell types.
  * **Build and train complex multi-layer networks** of cells, powered by data generated with `RatInABox`.


  <img src=".images/readme/ratinabox.gif" width=850>

  `RatInABox` is an open source project welcoming [contributions](#contribute). If you use `RatInABox` please [cite](#cite) the paper and consider giving this repository a star ☆. It contains three classes:

  1. `Environment()`📦: The environment/maze (or "box") that the agent lives in. 1- or 2-dimensional.
  2. `Agent()`      🐀: The agent (or "rat") moving around the `Environment`.
  3. `Neurons()`    🧠: A population of neurons with firing rates determined by the state (position and velocity) of the `Agent`. Make your own or use one of our premade cell types including:
      * `PlaceCells()`
      * `GridCells()`
      * `BoundaryVectorCells()` (egocentric or allocentric)
      * `ObjectVectorCells()`
      * `VelocityCells()`
      * `SpeedCells()`
      * `FieldOfViewNeurons()` (egocentric encoding of what the `Agent` can see)
      * `RandomSpatialNeurons()`
      * `HeadDirectionCells()`
      * `FeedForwardLayer()` (a generic class analagous to a feedforward layer in a deep neural network)
      * `NeuralNetworkNeurons()` (a generic class analagous to a deep neural network)
      * `SuccessorFeatures()`
      * ...

  The top animation shows an example use case: an `Agent` randomly explores a 2D `Environment` with a wall. Three populations of `Neurons` (`PlaceCells`, `GridCells`, `BoundaryVectorCells`) fire according to the receptive fields shown. All data is saved into the history for downstream use. `RatInABox` is fully continuous in space; this means that position and neural firing rates are calculated rapidly online with float precision rather than pre-calculated over a discretised mesh. `RatInABox` is flexibly discretised in time; `dt` can be set by the user (defaulting to 10 ms) depending on requirements.



  * **Non-specific**: Trajectories can be randomly generated, imported, or adaptively controlled making `RatInABox` a powerful engine for many tasks involving continuous motion (e.g. control theory or [reinforcement learning](#policy-control)).
  * **Biological**:   Simulate large populations of spatially and/or velocity modulated cell types. Neurons can be rate based or spiking. The random motion model is fitted to match real rodent motion.
  * **Flexible**:     Simulate environments in 1D or 2D with arbitrarily wall, boundary and hole arrangements.  Combine premade or bespoke `Neurons` classes into arbitrary deep networks (examples given).
  * **Fast**:         Simulating 1 minute of exploration in a 2D environment with 100 place cells (dt=10 ms) take just 2 seconds on a laptop (no GPU needed).
  * **Precise**:      No more prediscretised positions, tabular state spaces, or jerky movement policies. It's all continuous.
  * **Easy**:         Sensible default parameters mean you can have realisitic simulation data to work with in <10 lines of code.
  * **Visual**        Plot or animate trajectories, firing rate timeseries', spike rasters, receptive fields, heat maps, velocity histograms...using the plotting functions ([summarised here](./demos/list_of_plotting_fuctions.md)).

  <!--

  A new wrapper contributed by [@SynapticSage](https://github.com/SynapticSage) allows `RatInABox` to natively support OpenAI's [`gymnasium`](https://gymnasium.farama.org) API for standardised and multiagent reinforment learning. This can be used to flexibly integrate `RatInABox` with other RL libraries such as Stable-Baselines3 etc. and to build non-trivial tasks with objectives and time dependent rewards. Check it out [here](https://github.com/RatInABox-Lab/RatInABox/blob/main/ratinabox/contribs/TaskEnv_example_files/TaskEnvironment_basics.md). -->


  Many [demos](./demos/) are provided. Reading through the [example scripts](#example-scripts) (one simple and one extensive, duplicated at the bottom of the readme) these should be enough to get started. We also provide numerous interactive jupyter scripts as more in-depth case studies; for example one where `RatInABox` is used for [reinforcement learning](./demos/reinforcement_learning_example.ipynb), another for [neural decoding](./demos/decoding_position_example.ipynb) of position from firing rate. Jupyter scripts reproducing all figures in the [paper](./demos/paper_figures.ipynb) and [readme](./demos/readme_figures.ipynb) are also provided. All [demos](./demos/) can be run on Google Colab [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](./demos/)


  **Requirements** are minimal (`python3`, `numpy`, `scipy` and `matplotlib`, listed in `setup.cfg`) and will be installed automatically.

  **Install** the latest, stable version using `pip` at the command line with
  ```console
  $ pip install ratinabox
  ```
  Alternatively, in particular if you would like to develop `RatInABox` code or if you want the bleeding edge (may occasioanlly break), install from this repo using
  ```console
  $ git clone --depth 1 https://github.com/RatInABox-Lab/RatInABox.git
  $ cd RatInABox
  $ pip install -e .
  ```
  n.b. the "editable" `-e` handle means changes made to your clone will be reflected when you next import `RatInABox` into your code.

  **Import** into your python project with
  ```python
  import ratinabox
  from ratinabox.Environment import Environment
  from ratinabox.Agent import Agent
  from ratinabox.Neurons import PlaceCells, GridCells #...
  ```


  Here is a list of features loosely organised into those pertaining to

  (i) the [`Environment`](#i-environment-features)
  * [Adding walls](#walls)
  * [Complex Environments: Polygons, curves and holes](#complex-environments-polygons-curves-and-holes)
  * [Objects](#objects)
  * [Boundary conditions](#boundary-conditions)
  * [1- or 2-dimensions](#1--or-2-dimensions)

  (ii) the [`Agent`](#ii-agent-features)
  * [Random motion](#random-motion-model)
  * [Importing trajectories](#importing-trajectories)
  * [Policy control](#policy-control)
  * [Wall repelling](#wall-repelling)
  * [Multiple Agents](#multiple-agents)
  * [Advanced `Agent` classes](#advanced-agent-classes)

  (iii) the [`Neurons`](#iii-neurons-features).
  * [Cell types](#multiple-cell-types)
  * [Noise](#noise)
  * [Spikes vs rates](#spiking)
  * [Plotting rate maps](#rate-maps)
  * [Place cell models](#place-cell-models)
  * [Place cell geometry](#geometry-of-placecells)
  * [Grid cell models](#grid-cell-models)
  * [Egocentric encodings](#egocentric-encodings)
  * [Reinforcement learning and successor features](#reinforcement-learning-and-successor-features)
  * [Deep neural networks](#neurons-as-function-approximators)
  * [Create your own `Neuron` types](#creating-your-own-neuron-types)

  (iv) [Figures and animations plotting](#iv-figures-and-animations)

  Specific details can be found in the [paper](https://www.biorxiv.org/content/10.1101/2022.08.10.503541v3).





  Arbitrarily add walls to the environment to produce arbitrarily complex mazes:
  ```python
  Environment.add_wall([[x0,y0],[x1,y1]])
  ```
  Here are some easy to make examples.

  <img src=".images/readme/walls.png" width=1000>



  By default, `Environments` in RatInABox are square (or rectangular if `aspect != 1`). It is possible to create arbitrary environment shapes using the `"boundary"` parameter at initialisation.

  You can also add holes to the `Environment` using the `"holes"` parameter at initialisation. When sampling positions from the Environment (e.g. at initialisation), holes won't be included.

  Any curved environments can be made by creating a boundary of many small walls (use sparingly, walls may slow down computations, particular for wall-responsive representations, e.g. boundary vector cells.)

  ```python

  Env = Environment(params={
      'boundary':[[0,-0.2],[0,0.2],[1.5,0.5],[1.5,-0.5]],
      })


  Env = Environment(params={
      'aspect':1.8,
      'holes' : [[[0.2,0.2],[0.8,0.2],[0.8,0.8],[0.2,0.8]],
                 [[1,0.2],[1.6,0.2],[1.6,0.8],[1,0.8]]],
      })


  Env = Environment(params = {
      'boundary':[[0.5*np.cos(t),0.5*np.sin(t)] for t in np.linspace(0,2*np.pi,100)],
      })
  ```

  <img src=".images/readme/complex_envs.png" width=1000>



  `Environment`s can contain objects. These are used by `ObjectVectorCells` as visual cues but in theory you can hijack these to respresent many things in your `Environment` (reward ports, goal locations etc.). Objects have a `type` and a `position`
  Objects are defined by a list of points and a position. Objects can be used as visual cues (e.g. for `ObjectVectorCells`) or as obstacles (e.g. for `BoundaryVectorCells`).

  ```python
  Envirnoment.add_object(object=[0.3,0.3],type=0)
  Envirnoment.add_object(object=[0.7,0.3],type=0)
  Envirnoment.add_object(object=[0.5,0.7],type=1)
  ```
  <img src=".images/readme/objects.png" width=300>



  Boundary conditions (for default square/rectangular environments) can be "periodic" or "solid". Place cells and the motion of the Agent will respect these boundaries accordingly.
  ```python
  Env = Environment(
      params = {'boundary_conditions':'periodic'} #or 'solid' (default)
  )
  ```

  <img src=".images/readme/boundary_conditions.png" width=500>


  `RatInABox` supports 1- or 2-dimensional `Environment`s. Almost all applicable features and plotting functions work in both. The following figure shows 1 minute of exploration of an `Agent` in a 1D environment with periodic boundary conditions spanned by 10 place cells.
  ```python
  Env = Environment(
      params = {'dimensionality':'1D'} #or '2D' (default)
  )
  ```

  <img src=".images/readme/one_dimension.png" width=500>






  By defaut the `Agent` follows a random motion policy.  Random motion is stochastic but smooth. The speed (and rotational speed, if in 2D) of an Agent take constrained random walks governed by Ornstein-Uhlenbeck processes. You can change the means, variance and coherence times of these processes to control the shape of the trajectory. Default parameters are fit to real rat locomotion data from Sargolini et al. (2006):

  <img src=".images/readme/riab_vs_sargolini.gif" width=500>

  The default parameters can be changed to obtain different style trajectories. The following set of trajectories were generated by modifying the rotational speed parameter `Agent.rotational_velocity_std`:

  ```python
  Agent.speed_mean = 0.08 #m/s
  Agent.speed_coherence_time = 0.7
  Agent.rotation_velocity_std = 120 * np.pi/180 #radians
  Agent.rotational_velocity_coherence_time = 0.08
  ```

  <img src=".images/readme/motion_model.png" width=800>



  `RatInABox` supports importing external trajectory data (rather than using the in built random motion policy). Imported data can be of low temporal resolution. It will be smoothly upsampled using a cubic splines interpolation technique. We provide a 10 minute trajectory from the open-source data set of Sargolini et al. (2006) ready to import. In the following figure blue shows (low resolution) trajectory data imported into an `Agent` and purple shows the smoothly upsampled trajectory taken by the `Agent` during exploration.
  ```python
  Agent.import_trajectory(dataset='sargolini')

  Agent.import_trajectory(times=array_of_times,
                          positions=array_of_positions)

  ```

  <img src=".images/readme/imported_trajectory.png" width=200>


  By default the movement policy is an random and uncontrolled (e.g. displayed above). It is possible, however, to manually pass a "drift_velocity" to the Agent on each `Agent.update()` step. This 'closes the loop' allowing, for example, Actor-Critic systems to control the Agent policy. As a demonstration that this method can be used to control the agent's movement we set a radial drift velocity to encourage circular motion. We also use RatInABox to perform a simple model-free RL task and find a reward hidden behind a wall (the full script is given as an example script [here](./demos/reinforcement_learning_example.ipynb))
  ```python
  Agent.update(drift_velocity=drift_velocity)
  ```

  <img src=".images/readme/motion.gif" width=600>


  Under the random motion policy, walls in the environment mildly "repel" the `Agent`. Coupled with the finite turning speed this replicates an effect (known as thigmotaxis, sometimes linked to anxiety) where the `Agent` is biased to over-explore near walls and corners (as shown in these heatmaps) matching real rodent behaviour. It can be turned up or down with the `thigmotaxis` parameter.
  ```python
  Αgent.thigmotaxis = 0.8 #1 = high thigmotaxis (left plot), 0 = low (right)
  ```

  <img src=".images/readme/wall_repel.png" width=900>


  There is nothing to stop multiple `Agent`s being added to the same `Environment`. When plotting/animating trajectories set the kwarg `plot_all_agents=True` to visualise all `Agent`s simultaneously.

  The following animation shows three `Agent`s in an `Environment`. Drift velocities are set so that `Agent`s weally locally attract one another creating "interactive" behaviour.

  <img src=".images/readme/multi_agents.gif" width=350>



  One can make more advanced Agent classes, for example `ThetaSequenceAgent()` where the position "sweeps" (blue) over the position of an underlying true (regular) `Agent()` (purple), highly reminiscent of theta sequences observed when one decodes position from the hippocampal populaton code on sub-theta (10 Hz) timescales. This class can be found in the [`contribs`](./ratinabox/contribs/) directory.

  <img src=".images/readme/theta_sequences.gif" width=350>





  We provide a list of premade `Neurons` subclasses. These include (but are not limited to):

  * `PlaceCells`
  * `GridCells`
  * `BoundaryVectorCells` (can be egocentric or allocentric)
  * `ObjectVectorCells` (can be used as visual cues, i.e. only fire when `Agent` is looking towards them) (can be egocentric or allocentric)
  * `HeadDirectionCells`
  * `VelocityCells`
  * `SpeedCells`
  * `RandomSpatialNeurons` - smooth but random spatially tuned neurons
  * `FeedForwardLayer` - calculates activated weighted sum of inputs from a provide list of input `Neurons` layers.
  * `FieldOfViewNeurons` - Egocentric encoding of what the `Agent` can see
  * `NeuralNetworkNeurons` - Maps inputs from a user provided list of input `Neurons` through a user-provided `pytorch` neural network. Can be used to create arbitrary and learnable representations.

  `FeedForwardLayer` and `NeuralNetworkNeurons` deserves special mention. Instead of its firing rate being determined explicitly by the state of the `Agent` it summates synaptic inputs from a provided list of input layers (which can be any `Neurons` subclass). This layer is the building block for how more complex networks can be studied using `RatInABox`. `NeuralNetworkNeurons` is the same except instead of linearly summating it passes inputs through any arbitrary deep neural network.



  Use the `Neurons.noise_std` and `Neurons.noise_coherence_time` parameters to control the amount of noise (Hz) and autocorrelation timescale of the noise (seconds). For example (work with all `Neurons` classes, not just `PlaceCells`):

  ```python
  PCs = PlaceCells(Ag,params={
      'noise_std':0.1, #defaults to 0 i.e. no noise
      'noise_coherence_time':0.5, #autocorrelation timescale of additive noise vector
  })
  ```

  <img src=".images/readme/noise.png" width="1000">


  All neurons are rate based. However, at each update spikes are sampled as though neurons were Poisson neurons. These are stored in `Neurons.history['spikes']`. The max and min firing rates can be set with `Neurons.max_fr` and  `Neurons.min_fr`.
  ```
  Neurons.plot_ratemap(spikes=True)
  ```

  <img src=".images/readme/spikes.png" width="1000">



  `PlaceCells`, `GridCells` and allocentric `BoundaryVectorCells` (among others) have firing rates which depend exclusively on the position of the agent. These rate maps can be displayed by querying their firing rate at an array of positions spanning the environment, then plotting. This process is done for you using the function `Neurons.plot_rate_map()`.

  More generally, however, cells firing is not only determined by position but potentially other factors (e.g. velocity, or historical effects if the layer is part of a recurrent network). In these cases the above method of plotting rate maps will necessarily fail. A more robust way to display the receptive field is to plot a heatmap of the positions of the Agent has visited where each positions contribution to a bin is weighted by the firing rate observed at that position. Over time, as coverage become complete, the firing fields become visible.
  ```
  Neurons.plot_rate_map() #attempts to plot "ground truth" rate map
  Neurons.plot_rate_map(method="history") #plots rate map by firing-rate-weighted position heatmap
  ```

  <img src=".images/readme/rate_map.png" width=600>




  Place cells come in multiple types (given by `params['description']`), or it would be easy to write your own:
  * `"gaussian"`: normal gaussian place cell
  * `"gaussian_threshold"`: gaussian thresholded at 1 sigma
  * `"diff_of_gaussians"`: gaussian(sigma) - gaussian(1.5 sigma)
  * `"top_hat"`: circular receptive field, max firing rate within, min firing rate otherwise
  * `"one_hot"`: the closest place cell to any given location is established. This and only this cell fires.

  This last place cell type, `"one_hot"` is particularly useful as it essentially rediscretises space and tabularises the state space (gridworld again). This can be used to  contrast and compare learning algorithms acting over continuous vs discrete state spaces. This figure compares the 5 place cell models for population of 9 place cells (top left shows centres of place cells, and in all cases the `"widths"` parameters is set to  0.2 m, or irrelevant in the case of `"one_hot"`s)

  <img src=".images/readme/placecellmodels.png" width=800>

  These place cells (with the exception of `"one_hot"`s) can all be made to phase precess by instead initialising them with the `PhasePrecessingPlaceCells()` class currently residing in the `contribs` folder. This figure shows example output data.

  <img src=".images/readme/phaseprecession.png" width=500>



  Choose how you want `PlaceCells` to interact with walls in the `Environment`. We provide three types of geometries.

  <img src=".images/readme/wall_geometry.png" width=900>


  The default grid cell model is a _rectified sum of three cosines_ (see paper) with an additional parameter controlling the field-width : gri spacing ratio. There is also a _shifted cosine_ model. And analagous models are defined in 1D as well.

  <img src=".images/readme/grid_geometry.png" width=600>


  By default 30 grid cells are samples in evenly sized `"modules"` of increasing gridscale and orientation and offsets are `"uniform"` random between 0 and 2 $\pi$.

  To initialise non-default grid cells users specify their (i) `params['gridscale']`, (ii) `params['orientation']` and (iii) `params['phase_offset']`. These can be handed in as either:
  - lists/arrays: in which case they are set to these _exact_ values, one per cell)
  - tuples: in which case the values inside the tuples define the parameters of a distribution (the string defined by params['<param>_distribution']) from which the parameters are sampled.

  ```python
  GCs = GridCells(Ag,
                  params = {
                      "n": 30,
                      "gridscale_distribution": "modules",
                      "gridscale": (0.3, 0.5, 0.8),
                      "orientation_distribution": "modules",
                      "orientation": (0, 0.1, 0.2), #radians
                      "phase_offset_distribution": "uniform",
                      "phase_offset": (0, 2 * np.pi), #degrees
                      "description": "rectified_cosines",
                      "width_ratio":4/(3*np.sqrt(3)),
                  })
  ```

  <img src=".images/readme/gridcells_default.png" width=600>





  Most `RatInABox` cell classes are allocentric (e.g. `PlaceCells`, `GridCells` etc. do not depend on the agents point of view) not egocentric. `BoundaryVectorCells` (BVCs) and `ObjectVectorCells` (OVCs) can be either. `FieldOfViewNeurons` exploit this by arranging sets of egocentric BVC or OVCs to tile to agents local field of view creating a comprehensive egocentric encoding of what boundaries or objects the agent can 'see' from it's current point of view. A custom plotting function displays the tiling and the firing rates as shown below. With an adequately defined field of view these can make, for example, "whisker cells".

  ```python
  FoV_BVCs = FieldOfViewBVCs(Ag)
  FoV_OVCs = FieldOfViewOVCs(Ag)
  BVCs_whiskers = FieldOfViewBVCs(Ag,params={
          "distance_range": [0.01, 0.2],
          "angle_range": [
              75,
              105,
          ],
          "spatial_resolution": 0.02,  # resolution of each OVC tiling FoV
          "cell_arrangement": "uniform_manifold",

  })
  ```

  <img src=".images/readme/field_of_view.gif" width=600>


  A dedicated `Neurons` class called `SuccessorFeatures` learns the successor features for a given feature set under the current policy. See [this demo](./demos/successor_features_example.ipynb) for more info.
  <img src=".images/demos/SF_development.gif" width=600>

  `SuccessorFeatures` are a specific instance of a more general class of neurons called `ValueNeuron`s which learn value function for any reward density under the `Agent`s motion policy. This can be used to do reinforcement learning tasks such as finding rewards hidden behind walls etc as shown in [this demo](./demos/reinforcement_learning_example.ipynb).

  We also have a working examples of an actor critic algorithm using deep neural networks [here](./demos/actor_critic_example.ipynb)

  Finally, we are working on a dedicated subpackage -- (`RATS`: RL Agent Toolkit and Simulator) -- to host all this RL stuff and more so keep  an eye out.



  Perhaps you want to generate really complex cell types (more complex than just `PlaceCells`, `GridCells` etc.). No problem. For this we provide two `Neurons` subclass useful for constructing complex Neuron types. For these classes instead of firing rates being determined explicitly by the state of the `Agent`, they recieve inputs from one or many other `RatInABox.Neurons` classes and pass these inputs through a function to calculate the firing rate.

  * `FeedForwardLayer` linearly sums their inputs with a set of weights.
  * `NeuralNetworkNeurons` are more general, they pass their inputs through a user-provided deep neural network (for this we use `pytorch`).

  <img src=".images/readme/functionapproximators.gif" width=800>


  Both of these classes can be used as the building block for constructing complex multilayer networks of `Neurons` (e.g. `FeedForwardLayers` are `RatInABox.Neurons` in their own right so can be used as inputs to other `FeedForwardLayers`). Their parameters can be accessed and set (or "trained") to create neurons with complex receptive fields. In the case of `DeepNeuralNetwork` neurons the firing rate attached to the computational graph is stored so gradients can be taken. Examples can be found [here (deep learning with `NeuralNewtworkNeurons`)](./demos/deel_learning_example.ipynb) as well as [here (path integration)](./demos/path_integration_example.ipynb), [here (reinforcement learning)](./demos/reinforcement_learning_example.ipynb), [here (successor features)](./demos/successor_features_example.ipynb) and [here (actor critic deep RL)](./demos/actor_critic_example.ipynb).




  We encourage users to create their own subclasses of `Neurons`. This is easy to do, see comments in the `Neurons` class within the [code](./ratinabox/Neurons.py) for explanation. By forming these classes from the parent `Neurons` class, the plotting and analysis features described above remain available to these bespoke Neuron types.


  `RatInABox` is built to be highly visual. It is easy to plot or animate data and save these plots/animations. Here are some tips


  * `ratinabox.figure_directory` a global variable specifying the directory into which figures/animations will be saved
  * `ratinabox.utils.save_figure(fig,fig_name)` saves a figure (or animation) into a dated folder within the figure directory  as both `".svg"` and `".png"` (`".mp4"` or `".gif"`). The current time will be appended to the `fig_name` so you won't ever overwrite.



  * Setting `ratinabox.autosave_plots = True` means RatInABox figure will be automatically saved in the figure directory without having to indvidually call the `utils` function above.


  * `ratinabox.stylize_plots()` this call sets some global matplotlib rcParams to make plots look pretty/exactly like they do in this repo



  The most important plotting functions are (see source code for the available arguments/kwargs):

  ```python
  Environment.plot_environment() #visualises current environment with walls and objects
  Agent.plot_trajectory() #plots trajectory
  Agent.animate_trajectory() #animate trajectory
  Neurons.plot_rate_map() # plots the rate map of the neurons at all positions
  Neurons.plot_rate_timeseries() # plots activities of the neurons over time
  Neurons.animate_rate_timeseries() # animates the activity of the neurons over time
  ```

  Most plotting functions accept `fig` and `ax` as optional arguments and if passed will plot ontop of these. This can be used to make comolex or multipanel figures. For a comprehensive list of plotting functions see [here](./demos/list_of_plotting_fuctions.md).


  In the folder called [demos](./demos/) we provide numerous script and demos which will help when learning `RatInABox`. In approximate order of complexity, these include:
  * [simple_example.ipynb](./demos/simple_example.ipynb): a very simple tutorial for importing RiaB, initialising an Environment, Agent and some PlaceCells, running a brief simulation and outputting some data. Code copied here for convenience.
  ```python
  import ratinabox #IMPORT
  from ratinabox.Environment import Environment
  from ratinabox.Agent import Agent
  from ratinabox.Neurons import *

  Env = Environment()
  Ag = Agent(Env)
  PCs = PlaceCells(Ag)

  for i in range(int(20/Ag.dt)):
      Ag.update()
      PCs.update()

  print(Ag.history['pos'][:10])
  print(PCs.history['firingrate'][:10])
  fig, ax = Ag.plot_trajectory()
  fig, ax = PCs.plot_rate_timeseries()
  ```
  * [extensive_example.ipynb](./demos/extensive_example.ipynb): a more involved tutorial. More complex enivornment, more complex cell types and more complex plots are used.
  * [list_of_plotting_functions.md](./demos/list_of_plotting_fuctions.md): All the types of plots available for are listed and explained.
  * [readme_figures.ipynb](./demos/readme_figures.ipynb): (Almost) all plots/animations shown in the root readme are produced from this script (plus some minor formatting done afterwards in powerpoint).
  * [paper_figures.ipynb](./demos/paper_figures.ipynb): (Almost) all plots/animations shown in the paper are produced from this script (plus some major formatting done afterwards in powerpoint).
  * [decoding_position_example.ipynb](./demos/decoding_position_example.ipynb): Postion is decoded from neural data generated with RatInABox. Place cells, grid cell and boundary vector cells are compared.
  * [conjunctive_gridcells_example.ipynb](./demos/conjunctive_gridcells_example.ipynb): `GridCells` and `HeadDirectionCells` are minimally combined useing `FeedForwardLayer` to create head-direction-selective grid cells (aka. conjunctive cells).
  * [splitter_cells_example.ipynb](./demos/splitter_cells_example.ipynb): A simple simultaion demonstrating how `Splittre` cell data could be create in a figure-8 maze.
  * [deep_learning_example.ipynb](./deep_learning_example.ipynb): Here we showcase `NeuralNetworkNeurons` a class of `Neurons` which has a small neural network embedded inside. We train them to take grid cells as inputs and output an arbitrary function  as their rate map.
  * [reinforcement_learning_example.ipynb](./demos/reinforcement_learning_example.ipynb): RatInABox is use to construct, train and visualise a small two-layer network capable of model free reinforcement learning in order to find a reward hidden behind a wall.
  * [actor_critic_example.ipynb](./demos/actor_critic_example.ipynb): RatInABox is use to implement the actor critic algorithm using deep neural networks.
  * [successor_features_example.ipynb](./successor_features_example.ipynb): RatInABox is use to learn and visualise successor features under random and biased motion policies.
  * [path_integration_example.ipynb](./demos/path_integration_example.ipynb): RatInABox is use to construct, train and visualise a large multi-layer network capable of learning a "ring attractor" capable of path integrating a position estimate using only velocity inputs.


  `RatInABox` is open source project and we actively encourage  all contributions from example bug fixes to documentation or new cell types. Feel free to make a pull request (you will need to fork the repository first) or raise and issue.

  We have a dedicated [contribs](./ratinabox/contribs/) directory where you can safely add awesome scripts and new `Neurons` classes etc.

  Questions? Just ask! Ideally via opening an issue so others can see the answer too.

  Thanks to all contributors so far:
  ![GitHub Contributors Image](https://contrib.rocks/image?repo=RatInABox-Lab/RatInABox)



  If you use `RatInABox` in your research or educational material, please cite the work as follows:

  Bibtex:
  ```
  @article{George2024,
    title = {RatInABox,  a toolkit for modelling locomotion and neuronal activity in continuous environments},
    volume = {13},
    ISSN = {2050-084X},
    url = {http://dx.doi.org/10.7554/eLife.85274},
    DOI = {10.7554/elife.85274},
    journal = {eLife},
    publisher = {eLife Sciences Publications,  Ltd},
    author = {George,  Tom M and Rastogi,  Mehul and de Cothi,  William and Clopath,  Claudia and Stachenfeld,  Kimberly and Barry,  Caswell},
    year = {2024},
    month = feb
  }
  ```

  Formatted:
  ```
  Tom M George, Mehul Rastogi, William de Cothi, Claudia Clopath, Kimberly Stachenfeld, Caswell Barry. "RatInABox, a toolkit for modelling locomotion and neuronal activity in continuous environments" (2024), eLife, https://doi.org/10.7554/eLife.85274 .
  ```
  The research paper corresponding to the above citation can be found [here](https://elifesciences.org/articles/85274).


pkgId: 5931a24d97abf637a6d3b6afb54f14e5cec63b3e1f447be190947b30312f65cb
name: python-rbgame-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for rbgame
url: https://pypi.org/project/rbgame/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rbgame-0.0.1-1.src.rpm
location_href: Packages/python-rbgame-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  This library simulates the process of a board game. The goal of the simulation is to predict the game
  process statistics depending on various parameters. From this, we can conclude which parameters are
  desirable to set in order to play effectively in a real game.
  For more detail, read the documention in `here <https://robotic-board-game.readthedocs.io/en/latest/>`_.

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


pkgId: 4b68e52d07ca38639d0f365628ae999f78ea188d53f16ab8f98af6c884d46bbb
name: python-rc-connectivity-check-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for rc-connectivity-check
url: https://pypi.org/project/rc-connectivity-check/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rc-connectivity-check-0.1.5-1.src.rpm
location_href: Packages/python-rc-connectivity-check-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  This PIP package measures the latencies to various hosts and provides statistics such as failure rates and latencies.



  ```bash
  pip install rc_connectivity_check
  ```


  Just run `rc-connectivity-check`

  Also accepts an optional `--timeout` flag to increase request timeouts:
  ```
  usage: checker.py [-h] [--timeout TIMEOUT]

  RevenueCat Connectivity Check tool

  options:
    -h, --help         show this help message and exit
    --timeout TIMEOUT  Request timeout, in seconds (default: 5)
  ```

  Example output (simulating an error):
  ```
  $ rc-connectivity-check
  Finding client Public IP...
  Client Public IP: 1.2.3.4

  Resolving hostnames...
  * www.revenuecat.com: Resolved ok
    - 18.154.22.73
    - 18.154.22.30
    - 18.154.22.107
    - 18.154.22.26
  * app.revenuecat.com: Resolved ok
    - 108.157.109.77
    - 108.157.109.6
    - 108.157.109.82
    - 108.157.109.103
  * api.revenuecat.com: Resolved ok
    - 34.196.186.56
    - 52.22.245.243
    - 3.208.129.96
    - 54.163.59.173
    - 3.214.67.56
    - 3.223.26.133
    - <broken_id>

  Connectivity check...
  ERROR: Failed to connect to api.revenuecat.com at <broken_ip>: (<urllib3.connection.HTTPSConnection object at 0x105e60b90>, 'Connection to <broken_ip> timed out. (connect timeout=5)')
  ERROR: Failed to connect to api.revenuecat.com at <broken_ip>: (<urllib3.connection.HTTPConnection object at 0x105e611c0>, 'Connection to <broken_ip> timed out. (connect timeout=5)')
  [...]
  ERROR: Failed to connect to api.revenuecat.com at <broken_ip>: (<urllib3.connection.HTTPSConnection object at 0x105e60440>, 'Connection to <broken_ip> timed out. (connect timeout=5)')
  ERROR: Failed to connect to api.revenuecat.com at <broken_ip>: (<urllib3.connection.HTTPSConnection object at 0x105e78ef0>, 'Connection to <broken_ip> timed out. (connect timeout=5)')

  Results for http://www.revenuecat.com:
    - 18.154.22.30: OK
      Latencies (min/max/avg): 16.6ms / 20.0ms / 16.6ms
    - 18.154.22.73: OK
      Latencies (min/max/avg): 17.5ms / 20.8ms / 17.5ms
    - 18.154.22.26: OK
      Latencies (min/max/avg): 17.4ms / 20.1ms / 17.4ms
    - 18.154.22.107: OK
      Latencies (min/max/avg): 17.7ms / 24.1ms / 17.7ms

  Results for http://app.revenuecat.com:
    - 108.157.109.77: OK
      Latencies (min/max/avg): 17.1ms / 21.8ms / 17.1ms
    - 108.157.109.6: OK
      Latencies (min/max/avg): 18.3ms / 22.6ms / 18.3ms
    - 108.157.109.82: OK
      Latencies (min/max/avg): 19.0ms / 23.6ms / 19.0ms
    - 108.157.109.103: OK
      Latencies (min/max/avg): 18.9ms / 25.7ms / 18.9ms

  Results for https://app.revenuecat.com:
    - 108.157.109.6: OK
      Latencies (min/max/avg): 36.7ms / 42.8ms / 36.7ms
    - 108.157.109.82: OK
      Latencies (min/max/avg): 34.4ms / 44.4ms / 34.4ms
    - 108.157.109.103: OK
      Latencies (min/max/avg): 35.8ms / 43.1ms / 35.8ms
    - 108.157.109.77: OK
      Latencies (min/max/avg): 60.9ms / 277.5ms / 60.9ms

  Results for https://www.revenuecat.com:
    - 18.154.22.26: OK
      Latencies (min/max/avg): 46.9ms / 154.1ms / 46.9ms
    - 18.154.22.30: OK
      Latencies (min/max/avg): 47.6ms / 154.1ms / 47.6ms
    - 18.154.22.107: OK
      Latencies (min/max/avg): 48.0ms / 148.6ms / 48.0ms
    - 18.154.22.73: OK
      Latencies (min/max/avg): 50.7ms / 154.0ms / 50.7ms

  Results for http://api.revenuecat.com:
    - 34.196.186.56: OK
      Latencies (min/max/avg): 182.3ms / 190.7ms / 182.3ms
    - 52.22.245.243: OK
      Latencies (min/max/avg): 175.9ms / 178.9ms / 175.9ms
    - 54.163.59.173: OK
      Latencies (min/max/avg): 176.3ms / 195.9ms / 176.3ms
    - 3.208.129.96: OK
      Latencies (min/max/avg): 181.0ms / 191.7ms / 181.0ms
    - 3.214.67.56: OK
      Latencies (min/max/avg): 178.3ms / 186.5ms / 178.3ms
    - 3.223.26.133: OK
      Latencies (min/max/avg): 170.9ms / 177.1ms / 170.9ms
    - <broken_ip>: FAILURES [10/10]
      Latencies (min/max/avg): 5004.7ms / 5007.9ms / 5004.7ms

  Results for https://api.revenuecat.com:
    - 34.196.186.56: OK
      Latencies (min/max/avg): 361.0ms / 378.4ms / 361.0ms
    - 52.22.245.243: OK
      Latencies (min/max/avg): 363.8ms / 388.3ms / 363.8ms
    - 54.163.59.173: OK
      Latencies (min/max/avg): 365.8ms / 376.5ms / 365.8ms
    - 3.208.129.96: OK
      Latencies (min/max/avg): 371.7ms / 404.5ms / 371.7ms
    - 3.214.67.56: OK
      Latencies (min/max/avg): 369.5ms / 392.8ms / 369.5ms
    - 3.223.26.133: OK
      Latencies (min/max/avg): 369.6ms / 388.6ms / 369.6ms
    - <broken_ip>: FAILURES [10/10]
      Latencies (min/max/avg): 5006.7ms / 5012.6ms / 5006.7ms

  There were some connectivity failures!
  Please help us investigate by following the next steps:

  1: Check network routes:
    - Install mtr:
      - macOS: brew install mtr
      - Ubuntu: sudo apt-get install mtr
    - Run mtr using the following command:
      sudo mtr --report -n --tcp --port=443 --gracetime=5 --timeout=5 <broken_ip>

  2: Capture network traffic while running this script:
    - In one terminal run:
      - On macOS, over WIFI:
        tcpdump -i en0 -w rc_connectivity_check.pcap -s 0 tcp and port 80
      - On macOS, over ethernet:
        tcpdump -i en1 -w rc_connectivity_check.pcap -s 0 tcp and port 80
      - On linux, find the interface name with ifconfig and use:
        tcpdump -i <INTERFACE> -w rc_connectivity_check.pcap -s 0 tcp and port 80
    - In another terminal, run this script again:
      rc-connectivity-check
    - Once completed, stop the tcpdump process with `Ctrl+C`
    - Send the resulting rc_connectivity_check.pcap file to RevenueCat support
  ```


pkgId: 6045a06aa232588fc4b95da7c060aeff4a6b5e990ee0e52bec2c797b1493686e
name: python-rcd-dev-kit-help
arch: noarch
version: 2.5.14
epoch: 0
release: 1
summary: Development documents and examples for rcd-dev-kit
url: https://github.com/Tekkare/rcd-dev-kit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rcd-dev-kit-2.5.14-1.src.rpm
location_href: Packages/python-rcd-dev-kit-help-2.5.14-1.noarch.rpm
checksum_type: sha256
description:
  We've developed `rcd-dev-kit` to facilitate the manipulation and interaction with the OIP ecosystem.



  ```bash
  pip install rcd-dev-kit
  ```


  We've divided our functions in four main modules:
  - [database_manager](./src/rcd_dev_kit/database_manager)
      - Classes:
          - [GcloudOperator()](./src/rcd_dev_kit/database_manager/gcloud_operator.py)
          - MysqlOperator()
          - ElasticsearchOperator()
          - RedshiftOperator()
          - SnowflakeOperator()
          - S3Operator()
      - Main Functions:
          - index_json_bulk()
          - index_json()
          - index_json_bulk_parallel()
          - [send_to_redshift()](./src/rcd_dev_kit/database_manager/redshift_operator.py)
          - read_from_redshift()
          - [send_metadata_to_redshift()](./src/rcd_dev_kit/database_manager/redshift_operator.py)
          - find_tables_by_column_name()
          - migrate_metadata_from_redshift()
          - upload_raw_s3()
          - download_raw_s3()
          - [upload_to_gcloud()](./src/rcd_dev_kit/database_manager/gcloud_operator.py)
          - [download_from_gcloud()](./src/rcd_dev_kit/database_manager/gcloud_operator.py)

  - [dataclass_manager](./src/rcd_dev_kit/dataclass_manager)
      - Classes:
          - RawDataFile()

  - [decorator_manager](./src/rcd_dev_kit/decorator_manager)
      - Main Functions:
          - timeit()
          - debug()

  - [file_manager](./src/rcd_dev_kit/file_manager)
      - Classes:
          - FileOperator()
          - [FileDownloader()](./src/rcd_dev_kit/file_manager/file_downloader.py)
      - Main Functions:
          - detect_path()
          - detect_all_files()
          - write_df_to_json_parallel()
          - download_excel()
          - download_csv()
          - download_pdf()
          - download_zip()

  - [pandas_manager](./src/rcd_dev_kit/pandas_manager)
      - Main Functions:
          - strip_all_text_column()
          - check_na()
          - check_duplication()
          - check_quality_table_names()
          - normalize_date_column()
          - detect_aws_type()

  - [sql_utils](./src/rcd_dev_kit/sql_utils)
      - Main Functions:
          - convert_to_snowflake_syntax()
          - correct_sql_system_variables_syntax()


  Since some of the functions deal with database connections(S3, Redshift, Snowflake, GCP, Elasticsearch, ...), we must
  be careful to sensitive information. Thus, to use the functions correctly we must have a `.env` file following
  the `.env.example` template.


  Any questions or suggestions?
  Please contact package maintainer.


  Refer to book https://py-pkgs.org/01-introduction for best practices


  This package is using poetry for pkg management, it must be installed locally if you are maintaining the package.
  For developing and test the pkg locally, you must run `poetry install`.

  **This git repository has an automated CI/CD process** found on the git worflow: [main.yml](.github/workflows/main.yml). It means that once all modifications have been made, a Pull Request to main will trigger a serie of actions:
  - Install Package: `poetry install`
  - Run Unitary Tests: `poetry run pytest -v tests/ --cov=rcd_dev_kit --cov-report=xml`
  - Build Package: `poetry build`
  - Publish Package in PyPI: `poetry publish`
  - Install Package from PyPI: `pip install rcd_dev_kit`
  - Send a Teams message with the new available version: Git Image `toko-bifrost/ms-teams-deploy-card@master`.


  Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.


  `rcd_dev_kit` was created by RCD. It is licensed under the terms of the MIT license.


  `rcd_dev_kit` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).



  [![Top contributors](https://images.repography.com/38594109/daviibf/rcd-dev-kit/top-contributors/HnXXnUSGHxL47D8CGGmXE5g5nBhf2-iL3DAPxGcfUQg/6SSkjzuhw9SDmQVgkklseoZkiLprWCMi_Pcey2Qyx1g_table.svg)](https://github.com/daviibf/rcd-dev-kit/graphs/contributors)


  [![Timeline graph](https://images.repography.com/38594109/daviibf/rcd-dev-kit/recent-activity/HnXXnUSGHxL47D8CGGmXE5g5nBhf2-iL3DAPxGcfUQg/6SSkjzuhw9SDmQVgkklseoZkiLprWCMi_Pcey2Qyx1g_timeline.svg)](https://github.com/daviibf/rcd-dev-kit/commits)
  [![Trending topics](https://images.repography.com/38594109/daviibf/rcd-dev-kit/recent-activity/HnXXnUSGHxL47D8CGGmXE5g5nBhf2-iL3DAPxGcfUQg/6SSkjzuhw9SDmQVgkklseoZkiLprWCMi_Pcey2Qyx1g_words.svg)](https://github.com/daviibf/rcd-dev-kit/commits)
  [![Top contributors](https://images.repography.com/38594109/daviibf/rcd-dev-kit/recent-activity/HnXXnUSGHxL47D8CGGmXE5g5nBhf2-iL3DAPxGcfUQg/6SSkjzuhw9SDmQVgkklseoZkiLprWCMi_Pcey2Qyx1g_users.svg)](https://github.com/daviibf/rcd-dev-kit/graphs/contributors)
  [![Activity map](https://images.repography.com/38594109/daviibf/rcd-dev-kit/recent-activity/HnXXnUSGHxL47D8CGGmXE5g5nBhf2-iL3DAPxGcfUQg/6SSkjzuhw9SDmQVgkklseoZkiLprWCMi_Pcey2Qyx1g_map.svg)](https://github.com/daviibf/rcd-dev-kit/commits)


pkgId: f814f7895da0b02c007329709d80aebda8d3c17fbfdc5b4ece8e8b6f993a87e5
name: python-rclip-help
arch: noarch
version: 1.11.0
epoch: 0
release: 1
summary: Development documents and examples for rclip
url: https://github.com/yurijmikhalevich/rclip
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rclip-1.11.0-1.src.rpm
location_href: Packages/python-rclip-help-1.11.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
  [![All Contributors](https://img.shields.io/badge/all_contributors-3-orange.svg?style=flat-square)](#contributors-)
  <!-- ALL-CONTRIBUTORS-BADGE:END -->

  [[Blog]](https://mikhalevi.ch/rclip-an-ai-powered-command-line-photo-search-tool/) [[Demo on YouTube]](https://www.youtube.com/watch?v=tAJHXOkHidw) [[Paper]](https://www.thinkmind.org/index.php?view=article&articleid=content_2023_1_20_60011)

  <div align="center">
    <img alt="rclip logo" src="https://raw.githubusercontent.com/yurijmikhalevich/rclip/main/resources/logo-transparent.png" width="600px" />
  </div>

  **rclip** is a command-line photo search tool powered by the awesome OpenAI's [CLIP](https://github.com/openai/CLIP) neural network.





  ```bash
  sudo snap install rclip
  ```

  <details>
    <summary>Alternative options (AppImage and <code>pip</code>)</summary>

    If your Linux distribution doesn't support [snap](https://snapcraft.io/rclip), you can use one of the alternative installation options:

    

    On Linux x86_64, you can install **rclip** as a self-contained executable.

    1. Download the AppImage from the latest [release](https://github.com/yurijmikhalevich/rclip/releases).

    2. Execute the following commands:

    ```bash
    chmod +x <downloaded AppImage filename>
    sudo mv <downloaded AppImage filename> /usr/local/bin/rclip
    ```

    

    ```bash
    pip install --extra-index-url https://download.pytorch.org/whl/cpu rclip
    ```
  </details>



  ```bash
  brew install yurijmikhalevich/tap/rclip
  ```

  <details>
    <summary>Alternative option (<code>pip</code>)</summary>

    ```bash
    pip install rclip
    ```
  </details>



  1. Download the "*.msi" from the latest [release](https://github.com/yurijmikhalevich/rclip/releases).
  2. Install **rclip** by running the installer.

  <details>
    <summary>Alternative option (<code>pip</code>)</summary>

    ```bash
    pip install rclip
    ```
  </details>



  ```bash
  cd photos && rclip "search query"
  ```

  <img alt="rclip usage demo" src="https://raw.githubusercontent.com/yurijmikhalevich/rclip/main/resources/rclip-usage.gif" width="640px" />

  When you run **rclip** for the first time in a particular directory, it will extract features from the photos, which takes time. How long it will take depends on your CPU and the number of pictures you will search through. It took about a day to process 73 thousand photos on my NAS, which runs an old-ish Intel Celeron J3455, 7 minutes to index 50 thousand images on my MacBook with an M1 Max CPU, and three hours to process 1.28 million images on the same MacBook.

  For a detailed demonstration, watch the video: https://www.youtube.com/watch?v=tAJHXOkHidw.



  You can use another image as a query by passing a file path or even an URL to the image file, and **rclip** will find the images most similar to the one you used as a query. If you are referencing a local image via a relative path, you **must** prefix it with `./`. For example:

  ```bash
  cd photos && rclip ./cat.jpg


  cd photos && rclip https://raw.githubusercontent.com/yurijmikhalevich/rclip/main/tests/e2e/images/cat.jpg
  ```

  Check this video out for the image-to-image search demo: https://www.youtube.com/watch?v=1YQZKeCBxWM.



  You can add and subtract image and text queries from each other; here are a few usage examples:

  ```bash
  cd photos && rclip horse + stripes
  cd photos && rclip apple - fruit
  cd photos && rclip "./new york city.jpg" + night
  cd photos && rclip "2:golden retriever" + "./swimming pool.jpg"
  cd photos && rclip "./racing car.jpg" - "2:sports car" + "2:snow"
  ```

  If you want to see how these queries perform when executed on the 1.28 million images ImageNet-1k dataset, check out the demo on YouTube: https://www.youtube.com/watch?v=MsTgYdOpgcQ.



  If you are using either one of [iTerm2](https://iterm2.com/), [Konsole](https://konsole.kde.org/) (version 22.04 and higher), [wezterm](https://wezfurlong.org/wezterm/), [Mintty](https://mintty.github.io/), or [mlterm](https://mlterm.sourceforge.net/) all you need to do is pass `--preview` (or `-p`) argument to **rclip**:

  ```bash
  rclip -p kitty
  ```

  <details>
    <summary>Using a different terminal or viewer</summary>

    If you are using any other terminal or want to view the results in your viewer of choice, you can pass the output of **rclip** to it. For example, on Linux, the command from below will open top-5 results for "kitty" in your default image viewer:

    ```bash
    rclip -f -t 5 kitty | xargs -d '\n' -n 1 xdg-open
    ```

    The `-f` param or `--filepath-only` makes **rclip** print the file paths only, without scores or the header, which makes it ideal to use together with a custom viewer as in the example.

    I prefer to use **feh**'s thumbnail mode to preview multiple results:

    ```bash
    rclip -f -t 5 kitty | feh -f - -t
    ```
  </details>



  https://github.com/yurijmikhalevich/rclip/discussions/new/choose



  This repository follows the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) standard.



  To run **rclip** locally from the source code, you must have [Python](https://www.python.org/downloads/) and [Poetry](https://python-poetry.org/) installed.

  Then do:
  ```bash

  git clone git@github.com:yurijmikhalevich/rclip.git


  cd rclip
  poetry install


  poetry shell
  ```

  If the poetry environment is active, you can use **rclip** locally, as described in the [Usage](#usage) section above.



  Thanks go to these wonderful people and organizations ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ramayer"><img src="https://avatars.githubusercontent.com/u/72320?v=4?s=100" width="100px;" alt="ramayer"/><br /><sub><b>ramayer</b></sub></a><br /><a href="https://github.com/yurijmikhalevich/rclip/commits?author=ramayer" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.caphyon.com"><img src="https://avatars.githubusercontent.com/u/15829334?v=4?s=100" width="100px;" alt="Caphyon"/><br /><sub><b>Caphyon</b></sub></a><br /><a href="#infra-Caphyon" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://abidkhan484.github.io"><img src="https://avatars.githubusercontent.com/u/15053047?v=4?s=100" width="100px;" alt="AbId KhAn"/><br /><sub><b>AbId KhAn</b></sub></a><br /><a href="https://github.com/yurijmikhalevich/rclip/commits?author=abidkhan484" title="Code">💻</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  Thanks to [Caphyon](https://github.com/Caphyon) and Advanced Installer team for generously supplying **rclip** project with the Professional Advanced Installer license for creating the Windows installer.

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind are welcome!



  MIT


pkgId: fec6eddf244ce8d67cfaf32be55ca7d5ff5798ff223ef959ddf7c35e6591c190
name: python-rcplus_alloy_common-help
arch: noarch
version: 7.3.1
epoch: 0
release: 1
summary: Development documents and examples for rcplus_alloy_common
url: https://github.com/alloy-ch/rcplus-alloy-lib-py-common
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rcplus_alloy_common-7.3.1-1.src.rpm
location_href: Packages/python-rcplus_alloy_common-help-7.3.1-1.noarch.rpm
checksum_type: sha256
description:
  Python utilities for RC+/Alloy.
  _**NOTE**_: This Python package is published to PyPI.org as publicly available package.

  ```bash
  pip install -U rcplus-alloy-common
  ```


  TODO

  TODO

  ```bash
  pip install -U rcplus-alloy-common[airflow]
  ```
  TODO

  ```bash
  pip install -U rcplus-alloy-common[aws]
  ```
  TODO

  > [!NOTE]
  > GAM contains only data models definitions now
  ```bash
  pip install -U rcplus-alloy-common[gam]
  ```


pkgId: 2828f11d47deb3619e9db4da5c6b6a7d6d416e2d50f1a3b22dceb861d7a936e5
name: python-rcs-help
arch: noarch
version: 1.0.19
epoch: 0
release: 1
summary: Development documents and examples for rcs
url: https://pypi.org/project/rcs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rcs-1.0.19-1.src.rpm
location_href: Packages/python-rcs-help-1.0.19-1.noarch.rpm
checksum_type: sha256
description:
  [![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen)](https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=https%3A%2F%2Fgithub.com%2Fpinnacle-dev%2Frcs-py)
  [![pypi](https://img.shields.io/pypi/v/rcs)](https://pypi.python.org/pypi/rcs)

  The Pinnacle Python library provides convenient access to the Pinnacle API from Python.



  ```sh
  pip install rcs
  ```



  A full reference for this library is available [here](./reference.md).



  Instantiate and use the client with the following:

  ```python
  from rcs import (
      CompanyContact,
      CompanyDetails,
      Messaging,
      Pinnacle,
      PointOfContact,
  )

  client = Pinnacle(
      api_key="YOUR_API_KEY",
  )
  client.company.register(
      company=CompanyDetails(
          name="name",
          category="Entertainment",
          address="address",
          ein="ein",
          description="description",
          brand_color="brandColor",
          logo_url="logoUrl",
          hero_url="heroUrl",
      ),
      company_contact=CompanyContact(
          primary_website_url="primaryWebsiteUrl",
          primary_website_label="primaryWebsiteLabel",
          primary_phone="primaryPhone",
          primary_phone_label="primaryPhoneLabel",
          primary_email="primaryEmail",
          primary_email_label="primaryEmailLabel",
          privacy_policy_url="privacyPolicyUrl",
          tos_url="tosUrl",
      ),
      messaging=Messaging(
          opt_in="By opting in, you agree to receive messages from Pinnacle, including updates and promotions. Reply “STOP” to unsubscribe. Standard message and data rates may apply.",
          opt_out="Reply with keywords like STOP or UNSUBSCRIBE to opt-out. A confirmation message will be sent, and no further messages will be received unless you re-subscribe.",
          opt_out_keywords=["STOP", "UNSUBSCRIBE"],
          agent_use_case="Pinnacle’s agent assists with product updates, promotions, order tracking, and support. It answers FAQs, provides order updates, and helps with opt-in/out processes. Escalates to live support when needed.",
          expected_agent_responses="General Inquiry: “How can I assist you today?”\nOrder Status: “Provide your order number.”\nOpt-In: “You’re now subscribed!”\nOpt-Out: “You have unsubscribed.”\nEscalation: “Connecting to a live agent.”    \n",
      ),
      point_of_contact=PointOfContact(
          poc_name="pocName",
          poc_title="pocTitle",
          poc_email="pocEmail",
      ),
  )
  ```



  The SDK also exports an `async` client so that you can make non-blocking calls to our API.

  ```python
  import asyncio

  from rcs import (
      AsyncPinnacle,
      CompanyContact,
      CompanyDetails,
      Messaging,
      PointOfContact,
  )

  client = AsyncPinnacle(
      api_key="YOUR_API_KEY",
  )


  async def main() -> None:
      await client.company.register(
          company=CompanyDetails(
              name="name",
              category="Entertainment",
              address="address",
              ein="ein",
              description="description",
              brand_color="brandColor",
              logo_url="logoUrl",
              hero_url="heroUrl",
          ),
          company_contact=CompanyContact(
              primary_website_url="primaryWebsiteUrl",
              primary_website_label="primaryWebsiteLabel",
              primary_phone="primaryPhone",
              primary_phone_label="primaryPhoneLabel",
              primary_email="primaryEmail",
              primary_email_label="primaryEmailLabel",
              privacy_policy_url="privacyPolicyUrl",
              tos_url="tosUrl",
          ),
          messaging=Messaging(
              opt_in="By opting in, you agree to receive messages from Pinnacle, including updates and promotions. Reply “STOP” to unsubscribe. Standard message and data rates may apply.",
              opt_out="Reply with keywords like STOP or UNSUBSCRIBE to opt-out. A confirmation message will be sent, and no further messages will be received unless you re-subscribe.",
              opt_out_keywords=["STOP", "UNSUBSCRIBE"],
              agent_use_case="Pinnacle’s agent assists with product updates, promotions, order tracking, and support. It answers FAQs, provides order updates, and helps with opt-in/out processes. Escalates to live support when needed.",
              expected_agent_responses="General Inquiry: “How can I assist you today?”\nOrder Status: “Provide your order number.”\nOpt-In: “You’re now subscribed!”\nOpt-Out: “You have unsubscribed.”\nEscalation: “Connecting to a live agent.”    \n",
          ),
          point_of_contact=PointOfContact(
              poc_name="pocName",
              poc_title="pocTitle",
              poc_email="pocEmail",
          ),
      )


  asyncio.run(main())
  ```



  When the API returns a non-success status code (4xx or 5xx response), a subclass of the following error
  will be thrown.

  ```python
  from rcs.core.api_error import ApiError

  try:
      client.company.register(...)
  except ApiError as e:
      print(e.status_code)
      print(e.body)
  ```





  The SDK is instrumented with automatic retries with exponential backoff. A request will be retried as long
  as the request is deemed retriable and the number of retry attempts has not grown larger than the configured
  retry limit (default: 2).

  A request is deemed retriable when any of the following HTTP status codes is returned:

  - [408](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) (Timeout)
  - [429](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) (Too Many Requests)
  - [5XX](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500) (Internal Server Errors)

  Use the `max_retries` request option to configure this behavior.

  ```python
  client.company.register(..., request_options={
          "max_retries": 1
      })
      ```



  The SDK defaults to a 60 second timeout. You can configure this with a timeout option at the client or request level.

  ```python

      from rcs import Pinnacle

  client = Pinnacle(
      ...,
      timeout=20.0,
  )


      
      client.company.register(..., request_options={
          "timeout_in_seconds": 1
      })
      ```



  You can override the `httpx` client to customize it for your use-case. Some common use-cases include support for proxies
  and transports.
  ```python
  import httpx
  from rcs import Pinnacle

  client = Pinnacle(
      ...,
      httpx_client=httpx.Client(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```



  While we value open-source contributions to this SDK, this library is generated programmatically.
  Additions made directly to this library would have to be moved over to our generation code,
  otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
  a proof of concept, but know that we will not be able to merge it as-is. We suggest opening
  an issue first to discuss with us!

  On the other hand, contributions to the README are always very welcome!


pkgId: 8b83d550224518ece47d75c7c4030dbb55b5eabcaa605ac7636956c1601e3f97
name: python-rdsa-utils-help
arch: noarch
version: 0.4.4
epoch: 0
release: 1
summary: Development documents and examples for rdsa-utils
url: https://github.com/ONSdigital/rdsa-utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rdsa-utils-0.4.4-1.src.rpm
location_href: Packages/python-rdsa-utils-help-0.4.4-1.noarch.rpm
checksum_type: sha256
description:
  [![Deploy to PyPI](https://github.com/ONSdigital/rdsa-utils/actions/workflows/deploy_pypi.yaml/badge.svg?branch=main)](https://github.com/ONSdigital/rdsa-utils/actions/workflows/deploy_pypi.yaml)
  [![Deploy MkDocs](https://github.com/ONSdigital/rdsa-utils/actions/workflows/deploy_mkdocs.yaml/badge.svg?branch=main)](https://github.com/ONSdigital/rdsa-utils/actions/workflows/deploy_mkdocs.yaml)
  [![PyPI version](https://badge.fury.io/py/rdsa-utils.svg)](https://pypi.org/project/rdsa-utils/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/rdsa-utils.svg)](#)
  [![Code style: 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)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)


  A suite of PySpark, Pandas, and general pipeline utils for **Reproducible Data Science and Analysis (RDSA)** projects.

  The RDSA team sits within the Economic Statistics Change Directorate, and uses cutting-edge data science and engineering skills to produce the next generation of economic statistics. Current priorities include overhauling legacy systems and developing new systems for key statistics. More information about work at RDSA can be found here: [Using Data Science for Next-Gen Statistics](https://dataingovernment.blog.gov.uk/2023/02/14/using-data-science-for-next-gen-statistics/).

  `rdsa-utils` is a Python codebase built with Python 3.8 and higher, and uses `setup.py`, `setup.cfg`, and `pyproject.toml` for dependency management and packaging.



  - Python 3.8 or higher



  `rdsa-utils` is available for installation via [PyPI](https://pypi.org/project/rdsa-utils/) and can also be found on [GitHub Releases](https://github.com/ONSdigital/rdsa-utils/releases) for direct downloads and version history.

  To install via `pip`, simply run:

  ```bash
  pip install rdsa-utils
  ```



  The `rdsa-utils` package is designed to make it easy to work with different platforms like Cloudera Data Platform (CDP) and Google Cloud Platform (GCP), as well as handle general Python tasks. Here's a breakdown of how everything is organised:

  - **General Utilities (Top-Level)**:
    - These are tools you can use for any project, regardless of the platform you're working on. They focus on common Python, PySpark, and Pandas tasks.
    - 📂 **Helpers**: Handy functions that simplify working with Python and PySpark.
    - 📂 **IO**: Functions for handling input and output, like reading configurations or saving results.

  - **Platform-Specific Utilities**:
    - **CDP (Cloudera Data Platform)**:
      - 📂 **Helpers**: Functions that help you work with tools supported by CDP, such as HDFS, Impala, and AWS S3.
      - 📂 **IO**: Input/output functions specifically for CDP, such as managing data and logs in CDP environments.
    - **GCP (Google Cloud Platform)**:
      - 📂 **Helpers**: Functions to help you interact with GCP tools like Google Cloud Storage and BigQuery.
      - 📂 **IO**: Input/output functions for managing data with GCP services.

  This structure keeps the tools for each platform separate, so you can easily find what you need, whether you're working in a cloud environment or on general Python tasks.



  Our documentation is automatically generated using **GitHub Actions** and **MkDocs**. For an in-depth understanding of `rdsa-utils`, how to contribute to `rdsa-utils`, and more, please refer to our [MkDocs-generated documentation](https://onsdigital.github.io/rdsa-utils/).



  While `rdsa-utils` provides essential tools for data processing, it's just one part of the broader development process needed to build and maintain a robust, high-quality codebase. Following best practices and using the right tools are crucial for success.

  We highly recommend checking out the following resources to learn more about creating Reproducible Analytical Pipelines (RAP), which focus on important areas such as version control, modular code development, unit testing, and peer review -- all essential for developing these pipelines:

  - [Reproducible Analytical Pipelines (RAP) Resource](https://analysisfunction.civilservice.gov.uk/support/reproducible-analytical-pipelines/) - This resource offers an overview of Reproducible Analytical Pipelines, covering benefits, case studies, and guidelines on building a RAP. It discusses minimising manual steps, using open source software like R or Python, enhancing quality assurance through peer review, and ensuring auditability with version control. It also addresses challenges and considerations for implementing RAPs, such as data access restrictions or confidentiality, and underscores the importance of collaborative development.

  - [Quality Assurance of Code for Analysis and Research](https://best-practice-and-impact.github.io/qa-of-code-guidance/intro.html) - This book details methods and practices for ensuring high-quality coding in research and analysis, including unit testing and peer reviews.

  - [PySpark Introduction and Training Book](https://best-practice-and-impact.github.io/ons-spark/intro.html) - An introduction to using PySpark for large-scale data processing.



  Unless stated otherwise, the codebase is released under the [MIT License][mit].
  This covers both the codebase and any sample code in the documentation.

  The documentation is [© Crown copyright][copyright] and available under the terms of the [Open Government 3.0][ogl] licence.

  [mit]: LICENSE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/


pkgId: 588ec4d61c92a46612b304017b4cff6ce08bafea7ebcfdd0d86c9090e17869af
name: python-rdt-help
arch: noarch
version: 1.13.1
epoch: 0
release: 1
summary: Development documents and examples for rdt
url: https://pypi.org/project/rdt/
rpm_license: BSL-1.1
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rdt-1.13.1-1.src.rpm
location_href: Packages/python-rdt-help-1.13.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
  <a href="https://datacebo.com"><img align="center" width=40% src="https://github.com/sdv-dev/SDV/blob/stable/docs/images/DataCebo.png"></img></a>
  </div>
  <br/>
  <br/>
  [The Synthetic Data Vault Project](https://sdv.dev) was first created at MIT's [Data to AI Lab](
  https://dai.lids.mit.edu/) in 2016. After 4 years of research and traction with enterprise, we
  created [DataCebo](https://datacebo.com) in 2020 with the goal of growing the project.
  Today, DataCebo is the proud developer of SDV, the largest ecosystem for
  synthetic data generation & evaluation. It is home to multiple libraries that support synthetic
  data, including:
  * 🔄 Data discovery & transformation. Reverse the transforms to reproduce realistic data.
  * 🧠 Multiple machine learning models -- ranging from Copulas to Deep Learning -- to create tabular,
    multi table and time series data.
  * 📊 Measuring quality and privacy of synthetic data, and comparing different synthetic data
    generation models.
  [Get started using the SDV package](https://sdv.dev/SDV/getting_started/install.html) -- a fully
  integrated solution and your one-stop shop for synthetic data. Or, use the standalone libraries
  for specific needs.


pkgId: dd3e52e1ec1960ee35b88a87cbeb2f7677ce83fac1c994b40aac373e490911df
name: python-reCBZ2-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for reCBZ2
url: https://github.com/avalonv/reCBZ
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reCBZ2-0.8.0-1.src.rpm
location_href: Packages/python-reCBZ2-help-0.8.0-1.noarch.rpm
checksum_type: sha256
description:
  **reCBZ2** is a fork of the original reCBZ project, but since it was abandoned, I decided to continue it. The original project was created by `avalonv` and it's a tool to repack comic book archives (.cbz) into more efficient formats, such as WebP, and to convert them into fixed-layout EPUBs. It can also merge multiple files into a single volume, and perform various image operations, such as upscaling, downscaling, and desaturation.



  > Originally, I created this to save disk space. I own a large digital manga library, which unsurprisingly uses a lot of space. This isn't really a problem most of the time, but it limits what I can put on my Kobo e-Reader (which has "only" 32GB of storage). I prefer to keep the original files intact on [Calibre](https://github.com/kovidgoyal/calibre) on my computer, but use this tool to optimize the .cbz files in bulk so they use less space on my Kobo.
  >
  > For example, by repacking with WebP with the default settings, this can cut the size of the first volume of Chainsaw Man from 180MB to just under 96MB, without affecting image quality. Over the 11 published volumes, that amounts to over 1GB saved (which is a lot when you consider many e-Readers still have only 4GB)! And that's without touching the resolution, the size can be further reduced by another 50MB by downscaling to the actual display resolution — easily tripling the amount of manga that can be stored on your device, while maintaining the same perceived quality. Simply put, the amount of pixels in most comics, and the compression used to store those pixels (or lack thereof), is usually overkill for the type of screens *I* read from, and this program attempts to rectify that by doing hundreds of simple but tedious image operations in just a few seconds.
  >
  > This now has a few other tricks up its sleeve which exist mainly to make the process of managing a manga library (a patchwork of individual chapters downloaded from dynastyscans) less frustrating, as well as supporting conversion to EPUBs, as the traditional tool for this, [KCC](https://github.com/ciromattia/kcc), has been unmaintained for some time (and is somewhat fiddly to install on Linux).
  >
  > In short, it can:
  >
  > - Upscale, downscale, desaturate, and convert comic book pages (or images in general).
  >
  > - Convert them to lossy or lossless formats.
  >
  > - Do this automatically to try to reduce disk space.
  >
  > - Combine multiple files into a single contiguous book (transform multiple chapters into a single volume).
  >
  > - Convert CBZ files into fixed-layout EPUBs, with support for most [Kindle](https://github.com/avalonv/reCBZ/wiki/Ebook-profiles#kindle) & [Kobo](https://github.com/avalonv/reCBZ/wiki/Ebook-profiles#kobo) devices.
  >
  > - Make your CPU fan spin really fast.



  Requires [Python  ≥ 3.9](https://www.python.org/downloads/)

  <details>
    <summary>Windows setup</summary>

  If you're on the latest Python version (3.11), you may need to manually install `lxml` first:

      pip install https://download.lfd.uci.edu/pythonlibs/archived/lxml-4.9.0-cp311-cp311-win_amd64.whl
  </details>

  Linux, MacOS, and Windows:

      python -m pip install reCBZ2

  or build from source:

      git clone https://github.com/BelardoA/reCBZ2

      python -m pip install -e reCBZ2




      recbz [options] files

  Accepts a valid .cbz, .epub, or .zip file, or a collection of files. With no arguments passed, it will try to repack the file(s) with slightly more compression.

  The output file(s) will always be saved to the current directory as `filename [reCBZ].extension`, unless **--overwrite** is specified.



  Use `--help` or see the [Wiki](https://github.com/avalonv/reCBZ/wiki) for a list options and ebook [profiles](https://github.com/avalonv/reCBZ/wiki/Ebook-profiles).

  Default values for most options can be modified in `defaults.toml`



  Create a fixed-layout ebook from a standard .cbz file, optimized for a 6" Kindle Paperwhite:

      recbz --epub --profile PW3 'Our Dreams at Dusk.cbz'

  Automatically convert the pages in Blame! v01 and v02 to whichever format uses less space:

      recbz --auto 'Blame! Master Edition v01.cbz' 'Blame! Master Edition v01.cbz'

  To reference many files in the same directory (e.g. a series), you can use a '*'.[^1]
  Merge the contents of all files starting with 'How do We Relationship' into a single file:

      recbz --join 'How do We Relationship'*.cbz

  Rescale and convert all .cbz files on the current folder to high quality, black & white WebPs:

      recbz --size 1440x1920 --bw --convert webp --quality 90 *.cbz



  Generally speaking, the WebP format tends to compress images much more efficiently than both JPEG and PNG, allowing both lossy and lossless methods. This leads to a few noticeable quirks when converting from lossy to lossless and vice versa, which are covered [here](https://developers.google.com/speed/webp/faq#can_a_webp_image_grow_larger_than_its_source_image), but overall, if you're confident your reading software supports it, this almost always translates into less disk usage. Higher compression ratios also tend to affect image quality much less than with JPEG, which makes it better at preserving fine detail in busy images.

  It isn't perfect however: WebP adoption outside of web browsers has been glacial, and it is not universally supported yet, meaning it might not open on older devices and some e-Readers (Kobo) — although [Koreader](https://github.com/koreader/koreader/) allows you to get around this limitation.

  **TL;DR** If you're repacking content for the purpose of sharing with others on the web, it is recommended to avoid this format, as many devices still aren't capable of displaying them.



  Both WinRAR (.cbr) and 7zip (.cb7) are non-standard file compression programs. Undoubtedly they have helped many people compress files on PC, but they are not pre-installed on most operating systems, and thus cannot be opened on most mobile devices and e-Readers without some tinkering. Additionally, WinRAR is a proprietary program which limits official access to Windows, as the name suggests, which makes it annoying for future users that plan to read in other devices, and cannot be bundled with free software (such as this).

  Also, the compression algorithm used to pack images into a comic book archive has a negligible effect on the finished archive size, as the images are already compressed, so even if these programs *can* achieve higher compression ratios than zlib/zip in most cases, they offer little to no advantage for image content.

  **TL;DR** If distributing manga or comics over the web **PLEASE** stick to the standard .cbz format, as it's guaranteed to work on nearly every device. RAR is bad. Stop using RAR for this.

  You can use [7zip](https://www.7-zip.org/) to convert .cbr and .cb7 files to .cbz.



  Thanks to aerkalov for creating [Ebooklib](https://github.com/aerkalov/ebooklib), which allows EPUB conversion.

  KCC, which partly inspired this program.

  [^1]: This is known as [globbing](https://en.wikipedia.org/wiki/Glob_(programming)). On Windows, slashes '/' should be replaced with backslashes '\\'.


pkgId: 9c974fc3eada4d6b3975570be8f8edd224a3389610914073838caa4dd6c0830c
name: python-reach_commons-help
arch: noarch
version: 0.15.1
epoch: 0
release: 1
summary: Development documents and examples for reach_commons
url: https://pypi.org/project/reach_commons/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reach_commons-0.15.1-1.src.rpm
location_href: Packages/python-reach_commons-help-0.15.1-1.noarch.rpm
checksum_type: sha256
description:
  `reach_commons` is a Python library that provides various classes and utilities to assist developers in their projects. This library aims to simplify and streamline processes by offering reusable components that can be easily integrated into various Python applications.



  Install `reach_commons` using pip:

  ```bash
  pip install reach_commons

  from reach_commons.api_client_v2 import ReachApiGatewayV2

  api_gateway = ReachApiGatewayV2(
                          base_url=os.environ["api_gateway_v2_endpoint"],
                          access_token=os.environ["event_processor_token"],
                      )
  response = api_gateway.stripe_create_booking_guarantee(
                          business_id=business_id, booking_price=booking_price
                      )
  {
              "statusCode": stripe_customer.status_code,
              "body": json.dumps(response.json()),
          }


pkgId: 465f33dbc336da563cee3e44392220e265452d430b0ce3d4ab1cbc8dde1133aa
name: python-reaction-utils-help
arch: noarch
version: 1.8.0
epoch: 0
release: 1
summary: Development documents and examples for reaction-utils
url: https://github.com/MolecularAI/reaction_utils/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reaction-utils-1.8.0-1.src.rpm
location_href: Packages/python-reaction-utils-help-1.8.0-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/MolecularAI/reaction_utils)](https://github.com/MolecularAI/reaction_utils/blob/master/LICENSE)
  [![Tests](https://github.com/MolecularAI/reaction_utils/workflows/tests/badge.svg)](https://github.com/MolecularAI/reaction_utils/actions?workflow=tests)
  [![codecov](https://codecov.io/gh/MolecularAI/reaction_utils/branch/main/graph/badge.svg?token=MQE7BDM1N8)](https://codecov.io/gh/MolecularAI/reaction_utils)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)

  Utilities to work with datasets of chemical reactions, reaction templates and template extraction



  Before you begin, ensure you have met the following requirements:

  * Linux OS (or in principle Windows or macOS)

  * You have installed [anaconda](https://www.anaconda.com/) or [miniconda](https://docs.conda.io/en/latest/miniconda.html) with python 3.8

  The tool has been developed and fully tested on a Linux platform, but it is only occassionally tested on Windows and macOS.
  If you find an issue on a Windows or macOS platform, we might be able to fix, but we might just disable that feature on those platforms.






  Setup your python environment and then run

      pip install reaction-utils

  Consult the documentation for further information.

  For some tasks such as atom-mapping with `rxnmapper` you need to setup additional environment and packages, see [here](https://molecularai.github.io/reaction_utils/uspto.html)



  First clone the repository using Git.

  Then execute the following commands in the root of the repository

      conda env create -f env-dev.yml
      conda activate rxn-env
      poetry install --with dev

  the `rxnutils` package is now installed in editable mode.

  Lastly, make sure to install pre-commits that are run on every commit

      pre-commit install



  The package is divided into (currently) three sub-packages:

  * `chem` - chemistry routines like template extraction or reaction cleaning
  * `data` - routines for manipulating various reaction data sources
  * `pipeline` - routines for building and executing simple pipelines for modifying and analyzing reactions
  * `routes` - routines for handling synthesis routes

  The full auto-generated API document is available [here](https://molecularai.github.io/reaction_utils/), and the documentation also provides a few examples on common tasks.





  Tests uses the ``pytest`` package, and is installed by `poetry`

  Run the tests using:

      pytest -v

  The full command with all flags for CI is available through an `invoke` command

      invoke run-tests

   

  The documentation is generated by Sphinx from hand-written tutorials and docstrings

  The HTML documentation can be generated by

      invoke build-docs



  Linting is done preferably with `pylint`.

      invoke run-linting

  Currently we do not use `mypy` to check type annotations, but this will be switched on in the future.



  We welcome contributions, in the form of issues or pull requests.

  If you have a question or want to report a bug, please submit an issue.

  To contribute with code to the project, follow these steps:

  1. Fork this repository.
  2. Create a branch: `git checkout -b <branch_name>`.
  3. Make your changes and commit them: `git commit -m '<commit_message>'`
  4. Push to the remote branch: `git push`
  5. Create the pull request.

  Please use ``black`` package for formatting, and follow ``pep8`` style guide.




  * [@ckannas](https://github.com/ckannas)
  * [@SGenheden](https://www.github.com/SGenheden)
  * [@anniewesterlund](https://www.github.com/anniewesterlund)
  * [@Lakshidaa](https://github.com/Lakshidaa)
  * [@CBA087](https://www.github.com/CBA087)
  * [@EBjerrum](https://www.github.com/EBjerrum)
  * [@A-Thakkar](https://www.github.com/A-Thakkar)

  The contributors have limited time for support questions, but please do not hesitate to submit an issue (see above).



  The software is licensed under the Apache 2.0 license (see LICENSE file), and is free and provided as-is.



  1. Thakkar A, Kogej T, Reymond J-L, et al (2019) Datasets and their influence on the development of computer assisted synthesis planning tools in the pharmaceutical domain. Chem Sci. https://doi.org/10.1039/C9SC04944D

  2. Kannas C, Thakkar A, Bjerrum E, Genheden S (2022) rxnutils – A Cheminformatics Python Library for Manipulating Chemical Reaction Data. ChemRxiv. https://doi.org/10.26434/chemrxiv-2022-wt440-v2


pkgId: 86e3810bb2f054adadefb6db4d3816e4c5cdd16aa932539c7776e3c9a057b433
name: python-reactpy-utils-help
arch: noarch
version: 0.0.30
epoch: 0
release: 1
summary: Development documents and examples for reactpy-utils
url: https://pypi.org/project/reactpy-utils/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reactpy-utils-0.0.30-1.src.rpm
location_href: Packages/python-reactpy-utils-help-0.0.30-1.noarch.rpm
checksum_type: sha256
description:
  <p>
      <a href="https://github.com/stevej2608/reactpy-utils/actions/workflows/test-src.yml">
          <img src="https://github.com/stevej2608/reactpy-utils/actions/workflows/test-src.yml/badge.svg">
      </a>
      <a href="https://pypi.python.org/pypi/reactpy-utils">
          <img src="https://img.shields.io/pypi/v/reactpy-utils.svg?label=PyPI">
      </a>
      <a href="https://github.com/stevej2608/reactpy-utils/blob/main/LICENSE.md">
          <img src="https://img.shields.io/badge/License-MIT-purple.svg">
      </a>
      <a href="https://stevej2608.github.io/reactpy-utils/develop">
          <img src="https://img.shields.io/website?down_message=offline&label=Docs&logo=read%20the%20docs&logoColor=white&up_message=online&url=https%3A%2F%2Fstevej2608.github.io%2Freactpy-utils%2F">
      </a>
  </p>

  The **[reactpy-utils]** project is a collection of utilities and components that target the more obscure aspects
  of website design with [ReactPy].

  The following list gives a flavour of the type of features that are available:

  - [X] Copy to clipboard
  - [X] Set the page title
  - [X] Read/write the Browser local storage
  - [X] Minified JavaScript code templates



  Run the following command to install [reactpy-utils] in your Python environment.

  ```bash linenums="0"
  pip install reactpy-utils
  ```

  More information about this package can be found on [the documentation](https://stevej2608.github.io/reactpy-utils/latest/).



  In order to maintain consistency within the [ReactPy] ecosystem, the Hatch build and GitHub workflow
  configurations and the project documentation layout conform those of the [reactpy-router]. Many thanks to
  all those involved.

  [reactpy-utils]: https://pypi.org/project/reactpy-utils/
  [reactpy-router]: https://github.com/reactive-python/reactpy-router
  [ReactPy]: https://reactpy.dev/docs/index.html


pkgId: 472909bd391b870995569b6f37b13f16b1d0eb6ca044853fdbfef553a8c15ef2
name: python-readalongs-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for readalongs
url: https://github.com/ReadAlongs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-readalongs-1.2.0-1.src.rpm
location_href: Packages/python-readalongs-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/ReadAlongs/Studio/branch/main/graph/badge.svg)](https://codecov.io/gh/ReadAlongs/Studio)
  [![Build Status](https://github.com/readalongs/Studio/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/ReadAlongs/Studio/actions)
  [![PyPI package](https://img.shields.io/pypi/v/readalongs.svg)](https://pypi.org/project/readalongs/)
  [![Deploy web-api](https://img.shields.io/badge/%E2%86%91_Deploy_to-Heroku-7056bf.svg)](https://readalong-studio.herokuapp.com/api/v1/docs)
  [![GitHub license](https://img.shields.io/github/license/ReadAlongs/Studio)](https://github.com/ReadAlongs/Studio/blob/main/LICENSE)
  [![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg)](https://github.com/ReadAlongs/Studio)
  [![Documentation](https://github.com/ReadAlongs/studio/actions/workflows/docs.yml/badge.svg)](https://readalongs.github.io/Studio/)

  > Audiobook alignment for Indigenous languages!

  This library is an end-to-end audio/text aligner. It is meant to be used together with the [ReadAlong-Web-Component](https://github.com/roedoejet/ReadAlong-Web-Component) to interactively visualize the alignment.



  - [ReadAlong-Studio](#readalong-studio)
    - [Table of Contents](#table-of-contents)
    - [Background](#background)
    - [Install](#install)
      - [Dependencies](#installing-dependencies)
      - [Studio itself](#Installing-ReadAlongs-Studio-itself)
      - [Validation](#Verifying-your-installation)
    - [Usage](#usage)
      - [CLI](#cli)
      - [Web API](#web-api)
      - [Studio](#studio-web-application)
      - [Docker](#docker)
    - [Maintainers](#maintainers)
    - [Contributing](#contributing)
      - [Contributors](#contributors)
    - [License](#license)

  See also: [ReadAlong-Studio documentation](https://readalong-studio.readthedocs.io/en/latest/index.html).



  The concept is a web application with a series of stages of
  processing, which ultimately leads to a time-aligned audiobook -
  i.e. a package of:

  - ReadAlong XML file describing text
  - Audio file (WAV or MP3)

  Which can be loaded using the read-along [web component](https://github.com/roedoejet/ReadAlong-Web-Component). See also [Studio Output Realizations](https://readalong-studio.readthedocs.io/en/latest/outputs.html).

  Optionally a book can be generated as a standalone HTML page, XHTML, Praat TextGrid, ELAN Eaf file, as well as WebVTT or SRT subitle formats.

  1. (optional) Pre-segment inputs, consisting of:
     - Single audio file
     - Text with page markings (assume paragraph breaks = pages)
  2. Input pages: each page consists of
     - Image file
     - Audio file
     - Text
  3. Run alignment
  4. View output and download components





  Before you can install the ReadAlong Studio, you will need to install these dependencies:

   - Python, version 3.8 or higher,
   - [FFmpeg](https://ffmpeg.org/),
   - a C compiler,
   - Git (optional, needed to get the current development version).



  First install Homebrew, then use it to install FFmpeg with `brew install ffmpeg`.

  The compiler should already be on your machine.

  Consider Xcode for your XML and text file editor.



  If FFmpeg is not already installed, `<your package manager> install ffmpeg` should add it.

  The compiler should already be there, but run `<your package manager> install gcc` if not.





  The `conda` package manager can install Python 3 and the required compiler automatically for you,
  and simplifies ffmpeg and git installation. We recommend this solution.

  If the Anaconda Terms of Service are compatible with your organization, you can
  use Miniconda3: download and run the latest "Miniconda3 Windows 64-bit"
  installer from https://docs.conda.io/en/latest/miniconda.html.

  Fully open-source alternative, free for all organizations: Miniforge3.
  Download and run the latest "Miniforge3-Windows-x86_64" installer from
  https://github.com/conda-forge/miniforge.

  Either way, you can accept all the default options suggested by the installer.

  Launch an Anaconda Prompt or a Miniforge Prompt (this should be available from
  your Start Menu after installation) and run:

      conda install ffmpeg
      conda install git

  You can then run the pip install and git commands below, and use readalongs, all
  from the Anaconda or Miniforge Prompt.



  If you know what you're doing, you can install the dependencies directly on your machine:

   - Install Python3 for Windows.
   - Install [FFmpeg builds for Windows](https://ffmpeg.zeranoe.com/builds/) ([alternative instructions](https://windowsloop.com/install-ffmpeg-windows-10/)).
   - Install [Visual Studio Build Tools](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2017) (search for "Build Tools", select C++ when prompted).
   - Install Git for Windows (optional).



  To install the latest version of readalongs published to PyPI, you can run a standard pip
  installation: `pip install readalongs`. Be warned, however, that this project is still very active so the published version could be out-of-date. Consider installing the current development version instead.

  To install the current development version, clone the repo and pip install it
  locally:

  ```sh
  $ git clone https://github.com/ReadAlongs/Studio.git
  $ cd Studio
  $ pip install -e .
  ```



  Run `readalongs -h` to confirm that installation was successful.

  If you installed the current development version with Git, you can also run the full test suite:

      cd Studio/test
      python run.py dev

  And you can download our [open samples on GitHub](https://github.com/ReadAlongs/OpenSamples)
  to run your first alignments.



  ReadAlong-Studio can be used either through the command line, a distributed web application or Docker.



  This page lists only the most basic commands.

  For more information about how the command line interface works:
  * Consult the [CLI User Guide](https://readalong-studio.readthedocs.io/en/latest/cli-guide.html).
  * Consult the [CLI Reference](https://readalong-studio.readthedocs.io/en/latest/cli-ref.html).
  * Invoke any CLI command with `-h` or `--help` for usage information. e.g., `readalongs --help`, `readalongs align --help`.



  Basic alignment is done with the following command.

  `readalongs align TEXTFILE WAVFILE OUTPUTNAME`



  This page lists only the most basic commands.

  For more information about how the command line interface works consult the interactive [API Documentation](https://readalong-studio.herokuapp.com/api/v1/docs).

  For information on spinning up your own dev Web API server locally, have a look at [web\_api.py](readalongs/web_api.py), but briefly, if you are running it locally for development, use:

      DEVELOPMENT=1 uvicorn readalongs.web_api:web_api_app --reload

  or

      ./run-web-api.sh

  Note that the production command line for the Web API is defined in [Procfile](Procfile) and documented in [web\_api.py](readalongs/web_api.py).



  To query a list of available languages in the ReadAlong Studio API, send a GET request to https://readalongs-studio.herokuapp.com/api/v1/langs



  This endpoint is a remote procedural call that assembles the data needed to build a readalong using the JavaScript-based [SoundSwallower decoder](https://github.com/ReadAlongs/SoundSwallower). It is an endpoint that accepts POST requests with either plaintext or XML input. Please see the [documentation](https://readalong-studio.herokuapp.com/api/v1/docs) for more information.



  The ReadAlong-Studio web interface is available at https://readalong-studio.mothertongues.org/ and the source code is available here: https://github.com/ReadAlongs/Web-Component



  If you are having trouble installing the package, you can also clone the repo and run the
  studio using Docker.

  Working with in a Docker container has the advantage that no matter what your OS is, and
  what you have installed or configured, you will run on the standard ReadAlong-Studio
  configuration.

  To build the Docker image, run:

      docker build . --tag=readalong-studio

  To run the Flask web app in a Docker container using that image:

      docker run -p 5000:5000 -it readalong-studio

  To run the Flask web app with real-time update:

      docker run -p 5000:5000 -it -v $(pwd):/opt/readalong-studio readalong-studio

  Then you should be able to visit http://localhost:5000/.

  To run the interactive shell with real-time update:

      docker run -p 5000:5000 -it -v $(pwd):/opt/readalong-studio readalong-studio sh

  To run an interactive bash shell, using your local user inside Docker:

      docker run -p 5000:5000 -it -v $(pwd):/opt/readalong-studio -u $(id -u):$(id -g) readalong-studio bash



  [@dhdaines](https://github.com/dhdaines).
  [@littell](https://github.com/littell).
  [@roedoejet](https://github.com/roedoejet).
  [@joanise](https://github.com/joanise).



  Feel free to dive in! [Open an issue](https://github.com/ReadAlongs/Studio/issues/new) or submit PRs.

  This repo follows the [Contributor Covenant](http://contributor-covenant.org/version/1/3/0/) Code of Conduct.

  You can install our standard Git hooks by running these commands in your sandbox:

  ```sh
  pip install -e .[dev]
  pre-commit install
  gitlint install-hook
  ```

  Have a look at [Contributing.md](Contributing.md) for the full details on the
  Conventional Commit messages we prefer, our code formatting conventions, and
  our Git hooks.



  This project exists thanks to all the people who contribute.

  Here is a partial list:
  [@dhdaines](https://github.com/dhdaines).
  [@eddieantonio](https://github.com/eddieantonio).
  [@finguist](https://github.com/finguist).
  [@joanise](https://github.com/joanise).
  [@littell](https://github.com/littell).
  [@roedoejet](https://github.com/roedoejet).

  Project web page: [ReadAlong Studio: Application for Indigenous audiobooks and videos project](https://nrc.canada.ca/en/research-development/research-collaboration/programs/readalong-studio)



  if you use this software in a project of yours and write about it, please cite
  us using the following:

  Littell, P., Joanis, E., Pine, A., Tessier, M., Huggins-Daines, D., & Torkornoo, D. (2022). ReadAlong Studio: Practical Zero-Shot Text-Speech Alignment for Indigenous Language Audiobooks. Proceedings of SIGUL2022 @LREC2022, 23–32.

  ```
  @inproceedings{Littell_ReadAlong_Studio_Practical_2022,
  author = {Littell, Patrick and Joanis, Eric and Pine, Aidan and Tessier, Marc and Huggins-Daines, David and Torkornoo, Delasie},
  booktitle = {Proceedings of SIGUL2022 @LREC2022},
  title = {{ReadAlong Studio: Practical Zero-Shot Text-Speech Alignment for Indigenous Language Audiobooks}},
  year = {2022},
  month = {6},
  pages = {23--32},
  publisher = {European Language Resources Assiciation (ELRA)},
  url = {https://aclanthology.org/2022.sigul-1.4}
  }
  ```

  Aidan Pine, David Huggins-Daines, Eric Joanis, Patrick Littell, Marc Tessier, Delasie Torkornoo, Rebecca Knowles, Roland Kuhn, and Delaney Lothian. 2023. ReadAlong Studio Web Interface for Digital Interactive Storytelling. In Proceedings of the 18th Workshop on Innovative Use of NLP for Building Educational Applications (BEA 2023), pages 163–172, Toronto, Canada. Association for Computational Linguistics.

  ```
  @inproceedings{pine-etal-2023-readalong,
      title = "{R}ead{A}long Studio Web Interface for Digital Interactive Storytelling",
      author = "Pine, Aidan  and  Huggins-Daines, David  and  Joanis, Eric  and  Littell, Patrick  and  Tessier, Marc  and  Torkornoo, Delasie  and  Knowles, Rebecca  and  Kuhn, Roland  and  Lothian, Delaney",
      editor = {Kochmar, Ekaterina  and  Burstein, Jill  and  Horbach, Andrea  and  Laarmann-Quante, Ronja  and  Madnani, Nitin  and  Tack, Ana{\"\i}s  and  Yaneva, Victoria  and  Yuan, Zheng  and  Zesch, Torsten},
      booktitle = "Proceedings of the 18th Workshop on Innovative Use of NLP for Building Educational Applications (BEA 2023)",
      month = jul,
      year = "2023",
      address = "Toronto, Canada",
      publisher = "Association for Computational Linguistics",
      url = "https://aclanthology.org/2023.bea-1.14",
      doi = "10.18653/v1/2023.bea-1.14",
      pages = "163--172",
      abstract = "We develop an interactive web-based user interface for performing textspeech alignment and creating digital interactive read-along audio books that highlight words as they are spoken and allow users to replay individual words when clicked. We build on an existing Python library for zero-shot multilingual textspeech alignment (Littell et al., 2022), extend it by exposing its functionality through a RESTful API, and rewrite the underlying speech recognition engine to run in the browser. The ReadAlong Studio Web App is open-source, user-friendly, prioritizes privacy and data sovereignty, allows for a variety of standard export formats, and is designed to work for the majority of the world{'}s languages.",
  }
  ```



  [MIT](LICENSE) © 2019-2022 David Huggins-Daines and National Research Council Canada


pkgId: f59c321d968d0b07c35bce2facd00ed37c8f897ed9be7c8f802ab983e962c8c1
name: python-readet-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for readet
url: https://github.com/HamedHaddadi/readet
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-readet-0.1.0-1.src.rpm
location_href: Packages/python-readet-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  🚧 _until I prepare a more comprehensive documentation, use this readme to work with the package_ </br>
  ⚠️ If you run this package on a Windows machine, make sure you define the paths to files accordingly. </br>
  ⚠️ this documentation explains how to use the functionalities using a minimal set of inputs and using default arguments. But you can control parameters if you want. I will add the details in the documentation soon.

  readet is a package developed using _LangChain_ for perusing scientific and technical literature. But all tools are applicable to any context. </br>
  Eventhough several functionalities are included in this package, such as multi-agent systems, these modules are used more frequently: </br>
  ➡️ summarizers that are used to summarize a text, mostly pdf files. </br>
  ➡️ RAGs or Retrieval Augmented Generation tools which can be used to ask questions about a document. </br>
  ➡️ prebuilt agents that are used to download papers and patents in bulk. </br>

  here is the current directory tree of the package </br>
  ```console
  readet
  ├── __init__.py
  ├── bots
  │   ├── __init__.py
  │   ├── agents.py
  │   ├── chat_tools.py
  │   ├── components.py
  │   ├── multi_agents.py
  │   └── prebuilt.py
  ├── core
  │   ├── __init__.py
  │   ├── chains.py
  │   ├── knowledge_graphs.py
  │   ├── rags.py
  │   ├── retrievers.py
  │   ├── summarizers.py
  │   └── tools.py
  └── utils
      ├── __init__.py
      ├── docs.py
      ├── io.py
      ├── models.py
      ├── save_load.py
      └── schemas.py
  ```
  👉 __How to install__ </br>
  I recommend setting up a virtual environment with python version 3.10 </br>
  ```console
  conda create -n <name> python=3.10
  ```
  </br>
  Then you can activate the environment using </br>

  ```console
  conda activate <name>
  ```
  </br>
  This will make sure the package dependencies remain inside the virtual environment.
  The package can be installed using
  ```console
  pip3 install readet
  ```
  I also included the _requirements.txt_ file. </br>

  👉 __How to use__ </br>
  This package uses several _API_ s that need API keys. Fortunaletly, all of them are free for a while (or forever if you do not use them too often). Here is the list of APIs </br>
  1️⃣ OpenAI </br>
  2️⃣ Serp API </br>
  3️⃣ Anthropic </br>
  4️⃣ Tavily Search </br>
  5️⃣ LangChain </br>
  6️⃣ Hugging Face </br>
  apply for 1️⃣ to 3️⃣ first. With these APIs you can use utilize most of the functionalities in this package. But it is good to obtain all APIs at some point. </br>
  The easiest way is to define all API keys in a _keys.env_ file and load it in your environment. The keys.env file is structured as </br>
  OPENAI_API_KEY ="<you key>" </br>
  TAVILY_API_KEY="<your key>" </br>
  SERP_API_KEY="<your key>" </br>
  ANTHROPIC_API_KEY ="<your key>" </br>


  👉 __example use case 1__ </br>
  📖 _summarizers_ </br>
  I use the _PlainSummarizer_ as an example: </br>
  First, import necessary functions and classes </br>
  ```python

  from readet.utils.io import load_keys
  load_keys('keys.env')
  from readet.core.summarizers import PlainSummarizers
  ```
  </br>
  Now define parameters: </br>

  ```python


  chat_model = 'openai-gpt-4o-mini'

  temperature = 0

  plain_summarizer = PlainSummarizer(chat_model = chat_model, temperature = temperature)
  ```
  </br>
  Now specify the path to your pdf file and run the summarizer: </br>

  ```python

  pdf_file = '../files/my_file.pdf'
  response = plain_summarizer(pdf_file)
  ```
  </br>
  You can print the response to see the summary </br>
  Also, You may run the callable as much as you want to many pdf files: </br>

  ```python
  pdf_files = ['./my_papers/paper.pdf', './my_patents/patent.pdf']
  responses = {}
  for count,pdf in enumerate(pdf_files):
      responses[f'summary_{count}'] = plain_summarizer(pdf)
  ```
  </br>
  Note that ingesting pdf files may take some time. For a general scientific paper it may take about 12 seconds. Later when I explain RAGs, I will describe a method to store ingested pdf files to avoid spending too much time reading pdf files from scratch. </br>

  👉 __example use case 2__ </br>
  📑 _RAGS_ </br>

  RAGS are used to ask questions about a document. Say you have a pdf file and you want to ask questions about the content without reading it. RAGS ingest the pdf file and store in a database (a vectorstore) and use LLMs to respond to your questions based on what they hold. All RAGs in this package can keep their database on your local computer. So you do not need to add pdf files from scratch all the time. </br>
  readet contains several RAGs but working with all of them is the same. Here is a list </br>
  1️⃣ _PlainRAG_: simple but useful RAG to ask questions about a pdf file </br>
  2️⃣ _RAGWithCitations_: similar to plainRAG, but returns the reference as well (see an example below) </br>
  3️⃣ _AgenticRAG_: RAG with extra checks to make sure the answer is relevant to the context of the document </br>
  4️⃣ _SelfRAG_: RAG with introspection, to avoid hallucination </br>
  5️⃣ _AdaptiveRAG_: RAG that screens the question based on the relevance to the document. If not relevant, it gives an answer by google search. For example, it does not allow you to answer question about salsa dancing from a fluid dynamics text </br>

  I start with the _PlainRAG_ which is the simplest model: </br>
  ```python
  from readet.utils.io import load_keys
  load_keys('keys.env')
  from readet.core.rags import PlainRAG
  ```
  </br>
  You can define a RAG from scratch, or initialize it from saved data. I start from the former case </br>

  ```python
  pdf_file = './my_papers/fluidflow.pdf'

  store_path = './myRAGS'
  rag = PlainRAG(documents = pdf_file, store_path = store_path)
  ```
  </br>
  This will give you a function for asking questions: </br>

  ```python
  rag("who are the authors of this work?")
  rag("what is the relationship between fluid pressure and solid content?")
  ```
  </br>
  Let's start the RAG from the previously saved database (or "vector store"). This will allow you to add new pdf files, or keep asking question from the old files. </br>
  here are parameters that you need to pass to the class: </br>

  ``` python

  new_pdf_file = './my_papers/turbulence.pdf'

  store_path = './myRAGS'

  load_version_number = 'last'
  rag2 = PlainRAG(documents = new_pdf_file, store_path = store_path, load_version_number = load_version_number)
  ```
  </br>
  Now you can ask questions. </br>

  ```python
  rag2("what is the relationship between inertia and viscosity?")
  ```
  </br>

  Let's use _RAGWithCitations_ as well: </br>

  ```python
  from readet.utils.io import load_keys
  load_keys('keys.env')
  from readet.core.rags import RAGWithCitations
  pdf_file = './files/HaddadiMorrisJFM2014.pdf'
  store_path = './RAGStore'
  rag = RAGWithCitations(pdf_file, store_path = store_path)
  rag("what is the relationship between inertia and normal stress?")
  ```
  </br>
  And here is the answer:

  ```console
  'Inertia affects the normal stress in suspensions by influencing the distribution of particles and their interactions under shear flow. As inertia increases, it can lead to higher particle pressure and changes in the normal stress differences, particularly the first normal stress difference (N1), which becomes more negative with increasing inertia and volume fraction. This relationship highlights the complex interplay between inertia and stress in particle-laden fluids, where increased inertia amplifies the effects of excluded volume and alters the stress distribution within the suspension.',
   'Haddadi, H. & Morris, J. F. (2023). Microstructure and Rheology of Finite Inertia Suspensions. J. Fluid Mech.'
  ```
  </br>

  _I use one more example of the AdaptiveRAG and move on to the next example usage. All other RAGs mentioned above work the same_ </br>

  ```python
  from readet.core.rags import AdaptiveRAG
  from readet.utils.io import load_keys
  load_keys('keys.env')


  pdf_file = './files/fluidflow.pdf'
  store_path = './RAGFluid'

  load_version_number = None

  rag = AdaptiveRAG(documents = None, store_path = store_path, load_version_number = 'last')
  rag("what is relationship between Reynolds number and viscosity?")

  ```
  </br>
  And here is the answer: </br>

  ```console
  The Reynolds number (Re) is a dimensionless quantity that characterizes the flow regime in fluid dynamics, influenced by factors such as velocity, characteristic length, and viscosity. Generally, as Re increases, the effects of inertia become more significant compared to viscous forces, which can lead to changes in flow behavior. However, the viscosity itself may not show significant changes with varying Re, as indicated in the context provided.

  ```

  👉 __example use case 3__</br>
  📚 _search and download several papers from Google Scholar and Arxiv_ </br>
  This tool has been a real convenience for me and I hope it helps you as well. I explain how it works. But I included this tool as an agent in a _multi agent_ chat bot and I deploy that chatbot soon. You can use this tool, summary and RAGs to peruse a lot papers. </br>
  ⚠️To use the Download functionality , you need _OpenAI_ and _Serp API_ API keys. Use the links in the first part of this ReadMe document to obtain the API keys. </br>
  ⚠️ ⚠️ To use this agent, prompting is important. Make sure to mention _"search and download"_ if you want the agent to download the files for you. Otherwise, it will output a list of papers and their information and links to download the article. </br>

  ```console
  from readet.utils.io import load_keys
  load_keys('keys.env')
  from readet.bots.prebuilt import Download
  ```
  </br>
  Now you can define the parameters. These parameters are a path to save the downloaded files and maximum number of papers to download. Note that if you connection to the download faces a publisher paywall, the pdf file is not downloaded. But you can use the list of papers that are found to identify those papers and ask some to download it for you. </br>

  ``` python
  save_path = './pdfs'
  max_results = 100
  downloader = Download(save_path = save_path, max_results = max_results)


  download("search and download all papers related to finite inertia suspension flow of ellipsoidal particles")
  ```
  The downloaded files are stored in _save_path_. A '.txt' file containing information of the papers is also stored in the _save_path_ directory </br>
  For example, the first record in this file is : </br>

  ```console
  *******************
  Title: Numerical study of filament suspensions at finite inertia
  Authors: AA Banaei, ME Rosti, L Brandt
  Citation Count: 36
  PDF Link: https://www.cambridge.org/core/services/aop-cambridge-core/content/view/5FA754F237DC68A6721F7C055FA08CEC/S0022112019007948a.pdf/div-class-title-numerical-study-of-filament-suspensions-at-finite-inertia-div.pdf
  ```
  for example, you can send this file to colleagues via email. </br>

  I am continuosly adding more functionalities. Hope this package is useful for your scientific discovery 🤞

rpm_license:
  Copyright (c) 2018 The Python Packaging Authority  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: 025ebd69d45749e60fbdb0081cd4ef656ad81c033b1e979f13ae6a835f0eeb72
name: python-readii-help
arch: noarch
version: 1.21.0
epoch: 0
release: 1
summary: Development documents and examples for readii
url: https://pypi.org/project/readii/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-readii-1.21.0-1.src.rpm
location_href: Packages/python-readii-help-1.21.0-1.noarch.rpm
checksum_type: sha256
description:
  <!--intro-start-->
  [![codecov](https://codecov.io/gh/bhklab/readii/graph/badge.svg?token=obsN5dhXPx)](https://codecov.io/gh/bhklab/readii)
  [![CI-CD](https://github.com/bhklab/readii/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/bhklab/readii/actions/workflows/ci-cd.yml)
  [![CodeFactor](https://www.codefactor.io/repository/github/bhklab/readii/badge)](https://www.codefactor.io/repository/github/bhklab/readii)

  ![GitHub Release](https://img.shields.io/github/v/release/bhklab/readii)
  [![pixi-badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json&style=flat-square)](https://github.com/prefix-dev/pixi)

  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/readii)](https://pypi.org/project/readii/)
  [![PyPI - Version](https://img.shields.io/pypi/v/readii)](https://pypi.org/project/readii/)
  [![PyPI - Format](https://img.shields.io/pypi/format/readii)](https://pypi.org/project/readii/)
  [![Downloads](https://static.pepy.tech/badge/readii)](https://pepy.tech/project/readii)
  [![Docker Pulls](https://img.shields.io/docker/pulls/bhklab/readii)](https://hub.docker.com/r/bhklab/readii)

  **R**adiomic **E**xtraction and **A**nalysis for **DI**COM **I**mages

  A package to extract radiomic features from DICOM CT images.



  ```bash
  $ pip install readii
  ```



  ```bash
  mkdir my_project
  cd my_project
  pixi init
  pixi add --pypi readii
  ```



  ```bash
  conda create -n readii python=3.9
  conda activate readii
  pip install readii
  ```



  `readii` is a tool to perform radiomic feature extraction on DICOM CT images with region of interest (ROI) segmentations as either DICOM SEG or RTSTRUCT.

  ```bash
  $ readii [INPUT DIRECTORY] [OUTPUT DIRECTORY] \
    --roi_names [str] \
    --pyradiomics_setting [str] \
    --negative_controls [str: shuffled_full,shuffled_roi,shuffled_non_roi,randomized_full,randomized_roi,randomized_non_roi,randomized_sampled_full,randomized_sampled_roi, randomized_sampled_non_roi] \
    --parallel [flag]
    --update [flag]
  ```



  Negative controls are applied to one of three masks:

  1. full = voxels in the entire image
  2. roi = just voxels within the specified region of interest (ROI) in the segmentation
  3. non_roi = all voxels except the ROI.

  The three transformations are:

  1. shuffle = shuffle all voxels in the specified mask
  2. randomized = randomly generate new values within the original range within the specified mask
  3. randomized_sampled = randomly sample original values with replacement to get new values within the specified mask



  Please use the following angular commit message format:

  ```text
  <type>(optional scope): short summary in present tense

  (optional body: explains motivation for the change)

  (optional footer: note BREAKING CHANGES here, and issues to be closed)

  ```

  `<type>` refers to the kind of change made and is usually one of:

  - `feat`: A new feature.
  - `fix`: A bug fix.
  - `docs`: Documentation changes.
  - `style`: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc).
  - `refactor`: A code change that neither fixes a bug nor adds a feature.
  - `perf`: A code change that improves performance.
  - `test`: Changes to the test framework.
  - `build`: Changes to the build process or tools.

  `scope` is an optional keyword that provides context for where the change was made. It can be anything relevant to your package or development workflow (e.g., it could be the module or function - name affected by the change).

  Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.



  ```bash
  pixi run -e docs doc-serve
  ```



  `readii` was created by Katy Scott. It is licensed under the terms of the MIT license.

  <!--intro-end-->


pkgId: fc562ec6d4c413a259685b5de1e5e4557277945faf380143dc43bc645ac3c05b
name: python-readme-metrics-help
arch: noarch
version: 3.2.0
epoch: 0
release: 1
summary: Development documents and examples for readme-metrics
url: https://github.com/readmeio/metrics-sdks/tree/main/packages/python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-readme-metrics-3.2.0-1.src.rpm
location_href: Packages/python-readme-metrics-help-3.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://user-images.githubusercontent.com/33762/182927634-2aebeb46-c215-4ac3-9e98-61f931e33583.png" />
  </p>

  <p align="center">
    Track usage of your API and troubleshoot issues faster.
  </p>

  <p align="center">
    <a href="https://pypi.org/project/readme-metrics/"><img src="https://img.shields.io/pypi/v/readme-metrics.svg?style=for-the-badge" alt="Latest release"></a>
    <a href="https://github.com/readmeio/metrics-sdks"><img src="https://img.shields.io/github/actions/workflow/status/readmeio/metrics-sdks/python.yml?branch=main&style=for-the-badge" alt="Build status"></a>
  </p>

  With [ReadMe's Metrics API](https://readme.com/metrics) your team can get deep insights into your API's usage. If you're a developer, it takes a few small steps to send your API logs to [ReadMe](http://readme.com). Here's an overview of how the integration works:

  - You add the ReadMe middleware to your [Django](https://www.djangoproject.com/), [Flask](https://flask.palletsprojects.com/), or [WSGI](https://wsgi.readthedocs.io/) application.
  - The middleware sends to ReadMe the response object that your application generates each time a user makes a request to your API. The entire response is sent, unless you allow or deny keys.
  - ReadMe populates Metrics with this information, such as which endpoint is being called, response code, and error messages. It also identifies the customer who called your API, using whichever keys in the middleware you call out as containing relevant customer info.

  ```bash
  pip install "readme-metrics[Django]" # Django applications
  pip install "readme-metrics[Flask]" # Flask applications
  pip install readme-metrics # WSGI
  ```

  - [Django Integrations](https://docs.readme.com/docs/python-django-api-metrics)
  - [Flask Integrations](https://docs.readme.com/docs/python-flask-api-metrics)
  - [WSGI Integrations](https://docs.readme.com/docs/python-wsgi-api-metrics)

  > 🚧 Any Issues?
  >
  > Integrations can be tricky! [Contact support](https://docs.readme.com/guides/docs/contact-support) if you have any questions/issues.


pkgId: ee39b80949687b211ac41dffde5171f5df40125f1a34aee13eaf7589a9be7ae4
name: python-readmission-model-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for readmission-model
url: https://github.com/pypa/sampleproject
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-readmission-model-0.0.5-1.src.rpm
location_href: Packages/python-readmission-model-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Development of models for readmission in US hospitals.



  Individual readmission prediction models are developed for the following conditions:

  - Pneumonia (POAY)
  - Myocardial infarction
  - Stroke
  - Diabetes
  - Dementia
  - Chronic pulmonary disease
  - Heart faliure

  These predictions are developed using a range of different models.



  Initial datasets required:
  - Data:
      - AdmissionsAllTriggers
      - AdmissionsPOANTriggers
      - AdmissionsDiagnosis
      - dates
      - Ids
  - Condition Spreadsheets:
      - Codes
      - CoMorbidity_List
      - Comorb_Mappings
      - Chronic condition mapping
      - ComorbiditiesMap_Groups
      - ChronicConditionsMap




  No license is offered for this package, and it cannot be used, modified, or shared for any purpose.


pkgId: dad2643fad792b2e9428e7a337a65cb75787dcdd0c4b8878fc74fd25f970766d
name: python-realtabformer-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for realtabformer
url: https://github.com/avsolatorio/REaLTabFormer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-realtabformer-0.2.2-1.src.rpm
location_href: Packages/python-realtabformer-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  <a href="https://colab.research.google.com/github/avsolatorio/RealTabFormer/blob/main/colab/REaLTabFormer_GeoValidator_Example.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a> [![Downloads](https://static.pepy.tech/badge/realtabformer)](https://pepy.tech/project/realtabformer) [![Downloads](https://static.pepy.tech/badge/realtabformer/month)](https://pepy.tech/project/realtabformer) [![Downloads](https://static.pepy.tech/badge/realtabformer/week)](https://pepy.tech/project/realtabformer)



  The REaLTabFormer (Realistic Relational and Tabular Data using Transformers) offers a unified framework for synthesizing tabular data of different types. A sequence-to-sequence (Seq2Seq) model is used for generating synthetic relational datasets. The REaLTabFormer model for a non-relational tabular data uses GPT-2, and can be used out-of-the-box to model any tabular data with independent observations.
  <br>
  <br>
  <p align="center">
  <img src="https://github.com/avsolatorio/RealTabFormer/raw/main/img/REalTabFormer_Final_EQ.png" style="width:75%"/>
  </p>
  <p align="center">
  <strong>REaLTabFormer: Generating Realistic Relational and Tabular Data using Transformers</strong>
  <br>
  <a href="https://arxiv.org/abs/2302.02041">Paper on ArXiv</a>
  </p>
  <br>
  <!---
  Tabular data is a common form of organizing data. Multiple models are available to generate synthetic tabular datasets where observations are independent, but few have the ability to produce relational datasets. Modeling relational data is challenging as it requires modeling both a "parent" table and its relationships across tables. We introduce REaLTabFormer (Realistic Relational and Tabular Transformer), a tabular and relational synthetic data generation model. It first creates a parent table using an autoregressive GPT-2 model, then generates the relational dataset conditioned on the parent table using a sequence-to-sequence (Seq2Seq) model. We implement target masking to prevent data copying and propose the $Q_\delta$ statistic and statistical bootstrapping to detect overfitting. Experiments using real-world datasets show that REaLTabFormer captures the relational structure better than a baseline model. REaLTabFormer also achieves state-of-the-art results on prediction tasks, "out-of-the-box", for large non-relational datasets without needing fine-tuning. --->




  REaLTabFormer is available on PyPi and can be easily installed with [pip](https://pypi.org/project/pip/) (Python version >= 3.7):

  ```bash
  pip install realtabformer
  ```



  We show examples of using the REaLTabFormer for modeling and generating synthetic data from a trained model.

  > [!NOTE]
  > The model implements an optimal stopping criterion based on the synthetic data distribution when training a non-relational tabular model.
  > The model will stop training when the synthetic data distribution is close to the real data distribution.
  >
  > **Make sure to set the `epochs` parameter to a large number to allow the model to fit the data better.**
  > The model will stop training when the optimal stopping criterion is met.




  ```Python

  import pandas as pd
  from realtabformer import REaLTabFormer

  df = pd.read_csv("foo.csv")





  rtf_model = REaLTabFormer(
      model_type="tabular",
      gradient_accumulation_steps=4,
      logging_steps=100)




  rtf_model.fit(df)






  rtf_model.save("rtf_model/")



  samples = rtf_model.sample(n_samples=len(df))



  rtf_model2 = REaLTabFormer.load_from_dir(
      path="rtf_model/idXXXX")
  ```




  ```Python

  import os
  import pandas as pd
  from pathlib import Path
  from realtabformer import REaLTabFormer

  parent_df = pd.read_csv("foo.csv")
  child_df = pd.read_csv("bar.csv")
  join_on = "unique_id"



  assert ((join_on in parent_df.columns) and
          (join_on in child_df.columns))



  parent_model = REaLTabFormer(model_type="tabular")
  parent_model.fit(parent_df.drop(join_on, axis=1))

  pdir = Path("rtf_parent/")
  parent_model.save(pdir)




  parent_model_path = sorted([
      p for p in pdir.glob("id*") if p.is_dir()],
      key=os.path.getmtime)[-1]

  child_model = REaLTabFormer(
      model_type="relational",
      parent_realtabformer_path=parent_model_path,
      output_max_length=None,
      train_size=0.8)

  child_model.fit(
      df=child_df,
      in_df=parent_df,
      join_on=join_on)


  parent_samples = parent_model.sample(len(parend_df))


  parent_samples.index.name = join_on
  parent_samples = parent_samples.reset_index()


  child_samples = child_model.sample(
      input_unique_ids=parent_samples[join_on],
      input_df=parent_samples.drop(join_on, axis=1),
      gen_batch=64)

  ```



  The REaLTabFormer framework provides an interface to easily build observation validators for filtering invalid synthetic samples. We show an example of using the `GeoValidator` below. The chart on the left shows the distribution of the generated latitude and longitude without validation. The chart on the right shows the synthetic samples with observations that have been validated using the `GeoValidator` with the California boundary. Still, even when we did not optimally train the model for generating this, the invalid samples (falling outside of the boundary) are scarce from the generated data with no validator.

  <div align=center>
      <img src="https://github.com/avsolatorio/RealTabFormer/raw/main/img/CA-housing-raw-samples.png" style="width:35%; padding-right:5%;"/>
      <img src="https://github.com/avsolatorio/RealTabFormer/raw/main/img/CA-housing-validated-samples.png" style="width:35%; padding-left:5%;"/>
  </div>
  <br>

  ```Python



  import geopandas
  import seaborn as sns
  import matplotlib.pyplot as plt
  from realtabformer import REaLTabFormer
  from realtabformer import rtf_validators as rtf_val
  from shapely.geometry import Polygon, LineString, Point, MultiPolygon
  from sklearn.datasets import fetch_california_housing


  def plot_sf(data, samples, title=None):
      xlims = (-126, -113.5)
      ylims = (31, 43)
      bins = (50, 50)

      dd = samples.copy()
      pp = dd.loc[
          dd["Longitude"].between(data["Longitude"].min(), data["Longitude"].max()) &
          dd["Latitude"].between(data["Latitude"].min(), data["Latitude"].max())
      ]

      g = sns.JointGrid(data=pp, x="Longitude", y="Latitude", marginal_ticks=True)
      g.plot_joint(
          sns.histplot,
          bins=bins,
      )

      states[states['NAME'] == 'California'].boundary.plot(ax=g.ax_joint)
      g.ax_joint.set_xlim(*xlims)
      g.ax_joint.set_ylim(*ylims)

      g.plot_marginals(sns.histplot, element="step", color="#03012d")

      if title:
          g.ax_joint.set_title(title)

      plt.tight_layout()


  states = geopandas.read_file('geopandas-tutorial/data/usa-states-census-2014.shp')
  states = states.to_crs("EPSG:4326")  # GPS Projection


  data = fetch_california_housing(as_frame=True).frame


  rtf_model = REaLTabFormer(
      model_type="tabular",
      batch_size=64,
      epochs=10,
      gradient_accumulation_steps=4,
      logging_steps=100)


  rtf_model.fit(data, num_bootstrap=10)


  rtf_model.save("rtf_model/")


  samples_raw = rtf_model.sample(n_samples=10240, gen_batch=512)


  obs_validator = rtf_val.ObservationValidator()
  obs_validator.add_validator(
      "geo_validator",
      rtf_val.GeoValidator(
          MultiPolygon(states[states['NAME'] == 'California'].geometry[0])),
      ("Longitude", "Latitude")
  )

  samples_validated = rtf_model.sample(
      n_samples=10240, gen_batch=512,
      validator=obs_validator,
  )


  plot_sf(data, samples_raw, title="Raw samples")
  plot_sf(data, samples_validated, title="Validated samples")
  ```



  Please cite our work if you use the REaLTabFormer in your projects or research.

  ``` bibtex
  @article{solatorio2023realtabformer,
    title={REaLTabFormer: Generating Realistic Relational and Tabular Data using Transformers},
    author={Solatorio, Aivin V. and Dupriez, Olivier},
    journal={arXiv preprint arXiv:2302.02041},
    year={2023}
  }
  ```



  We thank the [World Bank-UNHCR Joint Data Center on Forced Displacement (JDC)](https://www.jointdatacenter.org/) for funding the project "Enhancing Responsible Microdata Access to Improve
  Policy and Response in Forced Displacement Situations" (KP-P174174-GINP-TF0B5124). A part of the fund went into supporting the development of the REaLTabFormer framework which was used to generate the synthetic population for research on disclosure risk and the mosaic effect.

  We also send :hugs: to the [HuggingFace](https://huggingface.co/) :hugs: for all the open-sourced software they release. And to all open-sourced projects, thank you!


pkgId: d282862329f6cbd28e01c266050688679641cef236cdff7b406edc7d74a664dd
name: python-realtime-trains-py-help
arch: noarch
version: 1.1.3b1
epoch: 0
release: 1
summary: Development documents and examples for realtime-trains-py
url: https://pypi.org/project/realtime-trains-py/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-realtime-trains-py-1.1.3b1-1.src.rpm
location_href: Packages/python-realtime-trains-py-help-1.1.3b1-1.noarch.rpm
checksum_type: sha256
description:
  Maintained by [@anonymous44401](https://github.com/anonymous44401)

  ![PyPI](https://img.shields.io/pypi/v/realtime-trains-py) ![License](https://img.shields.io/github/license/anonymous44401/realtime-trains-py) ![Issues](https://img.shields.io/github/issues/anonymous44401/realtime-trains-py)




  [Documentation](https://github.com/anonymous44401/realtime-trains-py/wiki/Home)



  **realtime-trains-py** is a python package designed to allow you to access data directly from the Realtime Trains API, in a simple and user-friendly way. The package includes 5 different complexity modes that allow you to customise the data you want to see.

  This package can be used for anything railway related, whether you're a rail enthusiast or commuter, this package can be used for all your purposes. The package can be used in personal applications or for personal rail data access.


  This package allows you to access data directly from the Realtime Trains API using one of 5 complexities. Each complexity mode gives you access to different data the API offers.

  For the most freedom with the API, you can use **complex** mode. Complex mode lets you access all the data available from the Realtime Trains API. This mode does not format any data for you - it creates new .json files with the data you requested. This mode is recommended for those who have a good understanding of python and managing json files.

  For a mix of freedom and flexibility, you can use **advanced** mode. Advanced mode allows you to access most the data available from the Realtime Trains API, but it comes with a time constraint. You can't request data more than 7 days prior to the current date nor 80 days after the current date.


  Using advanced and simple mode, you can optionally select between prettier or normal mode. Prettier mode gives you your data in a nicely formatted table, while normal mode gives you your data as a list of objects, so you'll need to get the data out of the objects yourself. Don't worry though, we have plenty of [documentation](https://github.com/anonymous44401/realtime-trains-py/wiki/Home) to help you out!




  To install the package, simply run the following command in your terminal:
  ```
  $ pip install realtime-trains-py
  ```
  Alternatively, you can clone, fork or download the [repository](https://github.com/anonymous44401/realtime-trains-py) onto your device.

  Once installed, you can import the package. Place the lines below in your file, or you can run them directly in your terminal.
  ```python
  from realtime_trains_py import RealtimeTrainsPy

  rtt = RealtimeTrainsPy(username = "your_username", password = "your_password", complexity = "c")
  ```

  Check out the [documentation](https://github.com/anonymous44401/realtime-trains-py/wiki/Home) for more help setting up.

  > [!IMPORTANT]
  > You need an RTT API account to access this package. You can sign up for free at the [API home page](https://api.rtt.io).




  The example below will return you up to 15 rows on the departure board for London King's Cross at the time you run the program.
  ```python
  rtt.get_departures_board(tiploc = "KNGX", rows = 15)
  ```

  The example below will return you up to 15 rows on the arrivals board for London King's Cross at the time you run the program.
  ```python
  rtt.get_arrivals_board(tiploc = "KNGX", rows = 15)
  ```

  More in-depth examples can be found on our [GitHub wiki](https://github.com/anonymous44401/realtime-trains-py/wiki/Home).




  The **realtime-trains-py** API Wrapper uses an MIT License.

rpm_license:
  MIT License    Copyright (c) [2024] [anonymous44401]  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: 64ade3111103bf2443351a94a7b513fd0cfa7eb4d5f29b5c25e249703253f856
name: python-reana-client-help
arch: noarch
version: 0.9.4
epoch: 0
release: 1
summary: Development documents and examples for reana-client
url: https://github.com/reanahub/reana-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reana-client-0.9.4-1.src.rpm
location_href: Packages/python-reana-client-help-0.9.4-1.noarch.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/pyversions/reana-client.svg)](https://pypi.org/pypi/reana-client)
  [![image](https://github.com/reanahub/reana-client/workflows/CI/badge.svg)](https://github.com/reanahub/reana-client/actions)
  [![image](https://readthedocs.org/projects/reana-client/badge/?version=latest)](https://reana-client.readthedocs.io/en/latest/?badge=latest)
  [![image](https://codecov.io/gh/reanahub/reana-client/branch/master/graph/badge.svg)](https://codecov.io/gh/reanahub/reana-client)
  [![image](https://img.shields.io/badge/discourse-forum-blue.svg)](https://forum.reana.io)
  [![image](https://img.shields.io/github/license/reanahub/reana.svg)](https://github.com/reanahub/reana-client/blob/master/LICENSE)
  [![image](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  REANA-Client is a component of the [REANA](https://www.reana.io/) reusable and
  reproducible research data analysis platform. It provides a command-line tool that allows
  researchers to submit, run, and manage their computational workflows.

  - seed workspace with input code and data
  - run computational workflows on remote compute clouds
  - list submitted workflows and enquire about their statuses
  - download results of finished workflows



  ```console
  $ # create new virtual environment
  $ virtualenv ~/.virtualenvs/reana
  $ source ~/.virtualenvs/reana/bin/activate
  $ # install reana-client
  $ pip install reana-client
  ```



  The detailed information on how to install and use REANA can be found in
  [docs.reana.io](https://docs.reana.io).



  - [REANA project home page](http://www.reana.io/)
  - [REANA user documentation](https://docs.reana.io)
  - [REANA user support forum](https://forum.reana.io)
  - [REANA-Client releases](https://reana-client.readthedocs.io/en/latest#changes)
  - [REANA-Client developer documentation](https://reana-client.readthedocs.io/)
  - [REANA-Client known issues](https://github.com/reanahub/reana-client/issues)
  - [REANA-Client source code](https://github.com/reanahub/reana-client)









  * **docker:** create `reana-client` container image ([#710](https://github.com/reanahub/reana-client/issues/710)) ([2c99c5d](https://github.com/reanahub/reana-client/commit/2c99c5d1bd36e4303885875375085f7d714e8732)), closes [#709](https://github.com/reanahub/reana-client/issues/709)
  * **python:** add support for Python 3.13 ([#736](https://github.com/reanahub/reana-client/issues/736)) ([fd9b944](https://github.com/reanahub/reana-client/commit/fd9b9446d58f21cc6e57b343874d55433532c959))
  * **python:** bump shared REANA packages as of 2024-11-28 ([#736](https://github.com/reanahub/reana-client/issues/736)) ([778df03](https://github.com/reanahub/reana-client/commit/778df037dbeb1340478060e7f913dfff7c0235e5))




  * **actions:** pin setuptools 70 ([#728](https://github.com/reanahub/reana-client/issues/728)) ([0a4bcc7](https://github.com/reanahub/reana-client/commit/0a4bcc79af33dd00a6a03216be32d10000bb432b))




  * **cli:** fix `open` command documentation typo ([#728](https://github.com/reanahub/reana-client/issues/728)) ([c822dd6](https://github.com/reanahub/reana-client/commit/c822dd6570d5474e535be83d0ee4beb44ecee85b))






  * **appimage:** upgrade to Python 3.8.18 ([#704](https://github.com/reanahub/reana-client/issues/704)) ([783c17a](https://github.com/reanahub/reana-client/commit/783c17a97c265d0d3cfe97857dc414c6bd7c8b11))




  * **status:** display correct duration of stopped workflows ([#701](https://github.com/reanahub/reana-client/issues/701)) ([b53def8](https://github.com/reanahub/reana-client/commit/b53def8dd3246b10d4da0f2367710af0911e284c)), closes [#699](https://github.com/reanahub/reana-client/issues/699)




  * **docs:** move from reST to Markdown ([#703](https://github.com/reanahub/reana-client/issues/703)) ([c9c4d53](https://github.com/reanahub/reana-client/commit/c9c4d530eb3e1e3d6996fe71821116815c8eaba3))




  * **black:** format with black v24 ([#702](https://github.com/reanahub/reana-client/issues/702)) ([02dc830](https://github.com/reanahub/reana-client/commit/02dc83009a6477c1ae045f4e1a6ea9f9e66640fb))




  * **snakemake:** allow running Snakemake 7 tests on Python 3.11+ ([#700](https://github.com/reanahub/reana-client/issues/700)) ([8ad7ff1](https://github.com/reanahub/reana-client/commit/8ad7ff19e98d1f9231af65bf608d408031546a3e)), closes [#655](https://github.com/reanahub/reana-client/issues/655)




  * **commitlint:** addition of commit message linter ([#695](https://github.com/reanahub/reana-client/issues/695)) ([2de7d61](https://github.com/reanahub/reana-client/commit/2de7d61db96693e8ee9c3ac555aef9dbfd7bb4bc))
  * **commitlint:** allow release commit style ([#708](https://github.com/reanahub/reana-client/issues/708)) ([f552752](https://github.com/reanahub/reana-client/commit/f55275296cd6cc72b4d21d89f51442842cb15d30))
  * **commitlint:** check for the presence of concrete PR number ([#698](https://github.com/reanahub/reana-client/issues/698)) ([fa5b7c7](https://github.com/reanahub/reana-client/commit/fa5b7c76eb25bfb1591e6fae4a142d975e14b937))
  * **pytest:** install `tests` package variant instead of `all` ([#703](https://github.com/reanahub/reana-client/issues/703)) ([fe0b00a](https://github.com/reanahub/reana-client/commit/fe0b00af1ad7b79ec607de7b810f597a3d6df93a))
  * **release-please:** initial configuration ([#695](https://github.com/reanahub/reana-client/issues/695)) ([5b278f1](https://github.com/reanahub/reana-client/commit/5b278f131b59d3ecfd3c7f129040a126cd01b60a))
  * **shellcheck:** fix exit code propagation ([#698](https://github.com/reanahub/reana-client/issues/698)) ([fe696ea](https://github.com/reanahub/reana-client/commit/fe696eae4cef119b29784ab80ec03d3f4cc089ea))




  * **authors:** complete list of contributors ([#705](https://github.com/reanahub/reana-client/issues/705)) ([875997c](https://github.com/reanahub/reana-client/commit/875997c06e657d3e19e1af32324127caa2b1a9c5))



  - Changes `validate` command to show detailed errors when the specification file is not a valid YAML file.
  - Changes the validation of specification files to show improved validation warnings, which also indicate where unexpected properties are located in the file.
  - Fixes `create_workflow_from_json` API function to always load and send the workflow specification to the server.
  - Fixes `list` command to accept case-insensitive column names when sorting the returned workflow runs via the `--sort` option.
  - Fixes `run` wrapper command for workflows that do not contain `inputs` clause in their specification.



  - Adds support for Python 3.12.
  - Adds `prune` command to delete all intermediate files of a given workflow. Use with care.
  - Changes `open` command to inform user about the auto-closure of interactive sessions after a certain inactivity timeout.
  - Changes `validate` command to display non-critical validation warnings when checking the REANA specification file.
  - Fixes `list` command to correctly list workflows when sorting them by their run number or by the size of their workspace.
  - Fixes `du` command help message typo.
  - Fixes `validation --environments` command to correctly handle fully-qualified image names.



  - Adds support for Python 3.11.
  - Adds support for `.gitignore` and `.reanaignore` to specify files that should not be uploaded to REANA.
  - Adds `retention-rules-list` command to list the retention rules of a workflow.
  - Changes REANA specification loading and validation functionalities by porting some of the logic to `reana-commons`.
  - Changes `create` and `restart` commands to always upload the REANA specification file.
  - Changes `delete` command to always delete the workflow's workspace.
  - Changes `delete_workflow` Python API function to always delete the workflow's workspace.
  - Changes `download` command to add the possibility to write files to the standard output via `-o -` option.
  - Changes `list` command to hide deleted workflows by default.
  - Changes `list` command to allow displaying deleted workflows via `--all` and `--show-deleted-runs` options.
  - Changes `list` and `status` commands to allow displaying the duration of workflows with the `--include-duration` option.
  - Changes `mv` command to allow moving files while a workflow is running.
  - Changes `upload` command to prevent uploading symlinks.
  - Changes `validation --environment` command to use Docker registry v2 APIs to check that a Docker image exists in DockerHub.
  - Fixes `list` command to highlight the workflow specified in `REANA_WORKON` correctly.
  - Fixes `secrets-delete` command error message when deleting non existing secrets.
  - Fixes `start` command to report failed workflows as errors.
  - Fixes `start` and `run` commands to correctly follow the execution of the workflow until termination.
  - Fixes `status` command to respect output format provided by the `--format` option.
  - Fixes `upload` command to report when input directories are listed under the `files` section in the REANA specification file and vice versa.
  - Fixes `validate --environment` command to detect illegal whitespace characters in Docker image names.



  - Adds support for creating reana-client standalone AppImage executables.
  - Adds support for Python 3.10.
  - Adds workflow name validation for `create_workflow_from_json()` Python API function.
  - Fixes formatting of error messages and sets appropriate exit status codes.



  - Adds support for running and validating Snakemake workflows.
  - Adds support for `outputs.directories` in `reana.yaml` allowing to easily download output directories.
  - Adds new command `quota-show` to retrieve information about total CPU and Disk usage and quota limits.
  - Adds new command `info` that retrieves general information about the cluster, such as available workspace path settings.
  - Changes `validate` command to add the possibility to check the workflow against server capabilities such as desired workspace path via `--server-capabilities` option.
  - Changes `list` command to add the possibility to filter by workflow status and search by workflow name via `--filter` option.
  - Changes `list` command to add the possibility to filter and display all the runs of a given workflow via `-w` option.
  - Changes `list` command to stop including workflow progress and workspace size by default. Please use new options `--include-progress` and `--include-workspace-size` to show this information.
  - Changes `list --sessions` command to display the status of interactive sessions.
  - Changes `logs` command to display also the start and finish times of individual jobs.
  - Changes `ls` command to add the possibility to filter by file name, size and last-modified values via `--filter` option.
  - Changes `du` command to add the possibility filter by file name and size via `--filter` option.
  - Changes `delete` command to prevent hard-deletion of workflows.
  - Changes Yadage workflow specification loading to be done in `reana-commons`.
  - Changes CWL workflow engine to `cwltool` version `3.1.20210628163208`.
  - Removes support for Python 2.7. Please use Python 3.6 or higher from now on.



  - Changes workflow validation to display more granular output.
  - Changes workflow parameters validation to warn about misused parameters for each step.
  - Changes dependencies to unpin six so that client may be installed in more contexts.
  - Fixes environment image validation not to test repetitively the same image.
  - Fixes `upload_to_server()` Python API function to silently skip uploading in case of none-like inputs.



  - Adds support of wildcard patterns to `ls` command.
  - Adds support of directory download and wildcard patterns to `download` command.
  - Changes `list` command to include deleted workflows by default.
  - Fixes environment image validation info message where UIDs were switched.



  - Adds validation of workflow input parameters to the `validate` command.
  - Adds optional validation of workflow environment images (`--environments`) to the `validate` command.



  - Adds support for Python 3.9.
  - Fixes exception handling when uploading files.
  - Fixes minor code warnings.
  - Fixes traling slash issue from user exported REANA_SERVER_URL.



  - Changes `ping` command output to include REANA client and server version information.
  - Fixes `upload` command to properly display errors.



  - Adds option to `logs` command to filter job logs according to compute backend, docker image, status and step name.
  - Adds new `restart` command to restart previously run or failed workflows.
  - Adds possibility to specify operational options in the `reana.yaml` of the workflow.
  - Fixes user experience by preventing dots as part of the workflow name to avoid confusion with restart runs.
  - Changes `du` command output format.
  - Changes file loading to optimise CLI performance.
  - Changes `logs` command to enhance formatting using marks and colours.
  - Changes from Bravado to requests to improve download performance.
  - Changes `ping` command to perform user access token validation.
  - Changes defaults to accept both `reana.yaml` and `reana.yml` filenames.
  - Changes `diff` command to improve output formatting.
  - Changes code formatting to respect `black` coding style.
  - Changes documentation to single-page layout.



  - Fixes installation troubles for REANA 0.6.x release series by pinning several
    dependencies.



  - Introduces user secrets management commands `secrets-add`,
    `secrets-list` and `secrets-delete`.
  - Enhances `run` and `create` commands to allow specifying
    workfow via the `--workflow` flag.
  - Introduces new command `version` to report client version.
  - Fixes `upload` command behaviour for uploading very large files.
  - Simplifies `run` command by removing free upload parameters.
  - Upgrades `cwltool` to 1.0.20191022103248.
  - Disables SSL verification warnings when talking to self-signed server
    certificates.



  - Introduces new `resources` field in `reana.yaml` specification file
    allowing to declare computing resources needed for workflow runs, such as the
    CVMFS repositories via `cvmfs` subfield.
  - Improves `reana-client` embedded command-line documentation (`-help`) by
    grouping commands and providing concrete usage examples for all commands.
  - Enhances workflow `start` command allowing to override input parameters
    (`--parameter`) and to specify additional operational options
    (`--option`).
  - Introduces new workflow `run` wrapper command that creates workflow, uploads
    its input data and code and starts its execution.
  - Introduces new workflow `stop` command for stopping a running workflow.
  - Enhances workflow `logs` command output capabilities via new `--json`
    option.
  - Introduces new workflow `diff` command for comparing two workflow runs.
  - Introduces new workflow `delete` command for deleting one or more workflow
    runs.
  - Introduces new session `open` command allowing to run interactive sessions
    such as Jupyter notebook upon workflow workspace.
  - Introduces new session `close` command for closing interactive sessions.
  - Renames past `workflows` command to `list` allowing to list both workflow
    runs and interactive sessions.
  - Introduces new workspace `du` command for checking workspace disk usage.
  - Introduces new workspace `mv` command for moving files within workspace.
  - Introduces new workspace `rm` command for removing files within workspace.
  - Renames past workspace `list` command to `ls` allowing to list workspace
    files. Enhances its output capabilities via new `--format` option.
  - Introduces new API function `create_workflow_from_json()` which allows
    developers and third-party systems to create workflows directly from JSON
    specification.



  - Enhances test suite and increases code coverage.
  - Changes license to MIT.



  - Amends upload and download commands that will now upload/download all the
    files specified in `reana.yaml` in case no arguments are provided.
  - Fixes `status` command's JSON output mode.
  - Upgrades CWL reference implementation to version `1.0.20180912090223`.
  - Renames Serial workflow operational parameter from ``` CACHING``to ``CACHE ```.
  - Adds support for Python 3.7.



  - Adds support for
    [Serial workflows](http://reana-workflow-engine-serial.readthedocs.io/en/latest/).

  - CLI refactored to a flat design:

    - `inputs`/`outputs`/`code` removed, everything is a file managed
      : with upload/download/list commands.
    - Removes `workflow` command, workflows are managed with
      : `create`/`start`/`status`.

  - Removes `analyes` command, now `validate` is first level command.

  - `status` now shows the selected workflow progress and current command on
    verbose mode.

  - Requires the usage of an access token to talk to REANA Server.

  - Fixes bug when uploading binary files.

  - Supports addition of workflow engine parameters when using `start` for
    serial workflows.

  - Improves error messages.



  - Adds support for Common Workflow Language workflows.
  - Adds support for persistent user-selected workflow names.
  - Enables file and directory input uploading using absolute paths.
  - Adds new `status` command to display the current status of the client.
  - Reduces verbosity level for commands and improves error messages.



  - Initial public release.


pkgId: 3b48f246ea05881c2c53ba328f246425e98f6b067b6b072e26e052a02f10e2b2
name: python-reasonchain-help
arch: noarch
version: 0.1.95
epoch: 0
release: 1
summary: Development documents and examples for reasonchain
url: https://github.com/sunnybedi990/reasonchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reasonchain-0.1.95-1.src.rpm
location_href: Packages/python-reasonchain-help-0.1.95-1.noarch.rpm
checksum_type: sha256
description:
  1. **Customizable Reasoning Pipelines**:
     - Seamless integration of **Chain of Thought (CoT)**, **Tree of Thought (ToT)**, Parallel Chains, and Hybrid Pipelines.
     - Facilitates task decomposition, execution, and validation.
  2. **RAG Integration**:
     - Retrieve and augment responses using long-term memory stored in vector databases like FAISS.
  3. **Short-term and Long-term Memory**:
     - Session-based short-term memory for reasoning chains.
     - Persistent long-term memory powered by FAISS.
  4. **LLM Compatibility**:
     - Supports OpenAI GPT, Llama, and other models for robust reasoning and summarization.
  5. **Utility Tools**:
     - Adaptive complexity evaluation for reasoning tasks.
     - Centralized model management for handling LLM interactions.
  6. **Supported File Types**:
     - Extract text, tables, and figures from a wide range of file formats, including:
       - **Documents**: PDF, Word, RTF, Markdown, HTML, LaTeX.
       - **Spreadsheets**: Excel, CSV.
       - **Multimedia**: Images, Videos, Audio.
       - **E-books**: EPUB, MOBI.
     - Provides modular extractors tailored for each file type, ensuring efficient data retrieval.
  7. **Domain Templates**:
     - Pre-built reasoning templates tailored for specific industries and applications:
       - **Customer Support**: Automates handling of customer inquiries and escalations.
       - **Healthcare**: Assists in diagnosis recommendations and treatment plans.
       - **Finance**: Analyzes trends, generates financial reports, and forecasts.
       - **Retail**: Provides insights on inventory optimization and customer behavior.
       - **Real Estate**: Summarizes market data and assists in property evaluations.
     - Fully customizable to meet domain-specific requirements.


pkgId: 054cb3bb1ced4482d545e69a8d2c9cb94828a1af5c8a4043b5a1d49ccb0d4ea7
name: python-reasonercli-help
arch: noarch
version: 0.2.9
epoch: 0
release: 1
summary: Development documents and examples for reasonercli
url: https://pypi.org/project/reasonercli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reasonercli-0.2.9-1.src.rpm
location_href: Packages/python-reasonercli-help-0.2.9-1.noarch.rpm
checksum_type: sha256
description:
  To run locally:
  ```
  uv run python -m src.reasoner.cli upload --path=/path/to/docs
  ```


  ```
  uv pip sync pyproject.toml
  uv run python -m build
  uv run pip install --editable .


  ```


  ```
  python3 -m build


  python3 -m twine upload dist/*


  python3 -m twine upload --repository testpypi dist/*


  python3 -m pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.python.org/simple reasonercli
  ```


  ```
  uv pip sync pyproject.toml
  uv run pyinstaller --clean --onefile --name reasoner entry.py

  cd dist
  ./reasoner
  ```


  ```
  pipenv --python 3.8 shell
  python3 -m pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.python.org/simple reasonercli
  reasonercli auth
  ```


pkgId: 9b8970b46bde2e3e980152d98614fe3e29a491d7a0cd2b80ec96edb35761cc53
name: python-recce-nightly-help
arch: noarch
version: 0.46.0.20241215
epoch: 0
release: 1
summary: Development documents and examples for recce-nightly
url: https://github.com/InfuseAI/recce
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-recce-nightly-0.46.0.20241215-1.src.rpm
location_href: Packages/python-recce-nightly-help-0.46.0.20241215-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://datarecce.io">
          <picture>
              <source media="(prefers-color-scheme: dark)" srcset="https://datarecce.io/assets/images/recce-logo-stacked.png">
              <source media="(prefers-color-scheme: light)" srcset="https://datarecce.io/assets/images/recce-logo-stacked.png">
              <img alt="Recce: DataRecce.io" src="https://datarecce.io/assets/images/recce-logo-stacked.png" width="200" style="width: 100%; max-width: 200px; display: block; margin: 0 auto 20px;">
          </picture>
      </a>
  </p>

  <h3 align="center">The&nbsp;data&nbsp;validation&nbsp;toolkit<br />for teams that care about building better data</h3>

  <p align="center">
      <a href="https://pypi.org/project/recce/"><img src="https://img.shields.io/badge/pip_install-recce-006DAD?style=flat-square" alt="install"></a> &nbsp;
      <a href="https://pypi.org/project/recce/"><img src="https://img.shields.io/pypi/v/recce?style=flat-square" alt="pipy"></a> &nbsp;
      <a href="https://pypi.org/project/recce/"><img src="https://img.shields.io/pypi/pyversions/recce?style=flat-square" alt="Python"></a> &nbsp;
      <a href="https://pypi.org/project/recce/#files"><img src="https://img.shields.io/pypi/dw/recce?style=flat-square" alt="downloads"></a> &nbsp;
      <a href="https://github.com/DataRecce/recce/blob/main/LICENSE"><img src="https://img.shields.io/github/license/DataRecce/recce?style=flat-square" alt="license"></a> &nbsp;
      <a href="https://getdbt.slack.com/archives/C05C28V7CPP"><img src="https://img.shields.io/badge/Slack-4A154B?style=flat-square&amp;logo=slack&amp;logoColor=white" alt="Slack"></a> &nbsp;
      <a href="https://discord.com/invite/5zb2aK9KBV"><img src="https://img.shields.io/discord/664381609771925514?color=%237289DA&amp;label=chat&amp;logo=discord&amp;logoColor=white&amp;style=flat-square" alt="InfuseAI Discord Invite"></a> &nbsp;
  </p>

  <p align="center">
      <a href="https://cal.com/team/recce/chat?utm_source=banner&utm_campaign=oss">
          <img alt="Book us with Cal.com" src="https://cal.com/book-with-cal-light.svg" />
      </a>
  </p>



  `Recce` is data validation toolkit for pull request (PR) review in dbt projects. Get enhanced visibility into how your team’s dbt modeling changes impact data by comparing your dev branch with stable production data. Run manual data checks during development, and automate checks in CI for PR review.




  Get up and running quickly by prepping your dev and prod environments. The key is building prod into the `target-base` folder to use as the base for the data comparison.

  ```Bash

  dbt seed --target prod
  dbt run --target prod
  dbt docs generate --target prod --target-path ./target-base


  git switch my-awesome-branch


  dbt seed
  dbt run
  dbt docs generate


  recce server
  ```

  Follow our [5-minute Jaffle Shop tutorial](https://datarecce.io/docs/get-started-jaffle-shop/) to try it out for yourself.



  `recce server` launches a web UI that shows you the area of your lineage that is impacted by the branch changes.

  <a href="https://datarecce.io"><img src="https://datarecce.io/assets/images/readme/recce-overview-screenshot.png" style="width: 100%; max-width: 600px; display: block; margin: 0 auto 20px;" /></a>



  - Select nodes in the lineage to perform Checks (diffs) as part of your impact assessment during development or PR review.
  - Add Checks to your Checklist to note observed impacts.
  - Share your Checklist with the PR reviewer.
  - (`Recce Cloud`) Automatically sync Check status between Recce Instances
  - (`Recce Cloud`) Block PR merging until all Recce Checks have been approved

  Read more about using [Recce for Impact Assessment](https://datarecce.io/blog/hands-on-data-impact-analysis-recce/) on the Recce blog.




  We provide three online Recce demos (based on Jaffle Shop), each is related to a specific pull request. Use these demos to inspect the data impact caused by the modeling changes in the PR.

  For each demo, review the following:

  - The pull request comment
  - The code changes
  - How the lineage and data has changed in `Recce`

  This will enable you to validate if the intention of the PR has been successfully implemented without unintended impact.

  > [!TIP]
  Don't forget to click the Checks tab to view the Recce Checklist, and perform your own Checks for further investigation.
  >



  This pull request adjusts the **logic** for how customer lifetime value is calculated:

  - [Demo #1](https://pr1.cloud.datarecce.io/)
  - [Pull request #1](https://github.com/DataRecce/jaffle_shop_duckdb/pull/1)



  This pull request performs some **refactoring** on the customers model by turning two CTEs into intermediate models, enhancing readability and maintainability:

  - [Demo #2](https://pr2.cloud.datarecce.io/)
  - [Pull request #2](https://github.com/DataRecce/jaffle_shop_duckdb/pull/2)



  This pull request introduces a new Rounding Effect **Analysis** feature, aimed at analyzing and reporting the impacts of rounding in our data processing.

  - [Demo #3](https://pr3.cloud.datarecce.io/)
  - [Pull request #3](https://github.com/DataRecce/jaffle_shop_duckdb/pull/3)




  [dbt](https://www.getdbt.com/) has brought many software best practices to data projects, such as:

  - Version controlled code
  - Modular SQL
  - Reproducible pipelines

  Even so, 'bad merges' still happen and erroneous data and silent errors make their way into prod data. As self-serve analytics opens dbt projects to many roles, and the size of dbt projects increase, the job of reviewing data modeling changes is even more critical.

  The only way to understand the impact of code changes on data is to compare the data before-and-after the changes.



  `Recce` provides a data review environment for data teams to check their work during development, and then again as part of PR review. The suite of tools and diffs in Recce are specifically geared towards surfacing, understanding, and recording data impact from code changes.



  [Lineage Diff](https://datarecce.io/docs/features/lineage/) is the main interface to `Recce`  and shows which nodes in the lineage have been added, removed, or modified.



  - [Schema Diff](https://datarecce.io/docs/features/lineage/#schema-diff) - Show the struture of the table including added or removed columns
  - [Row Count Diff](https://datarecce.io/docs/features/lineage/#row-count-diff) - Compares the row count for tables



  Advanced Diffs provide high level statistics about data change:

  - [Profile Diff](https://datarecce.io/docs/features/lineage/#profile-diff): Compares stats such as count, distinct count, min, max, average.
  - [Value Diff](https://datarecce.io/docs/features/lineage/#value-diff): The matched count and percentage for each column in the table.
  - [Top-K Diff](https://datarecce.io/docs/features/lineage/#top-k-diff): Compares the distribution of a categorical column.
  - [Histogram Diff](https://datarecce.io/docs/features/lineage/#histogram-diff): Compares the distribution of a numeric column in an overlay histogram chart.



  [Query Diff](https://datarecce.io/docs/features/query/) compares the results of any ad-hoc query, and supports the use of dbt macros.



  The [checklist](https://datarecce.io/docs/features/checklist/) provides a way to record the results of your data validation process.

  - Save the results of checks
  - Re-run checks
  - Annotate checks to add context
  - Share the results of checks
  - (`Recce Cloud`) Sync checks and check results across Recce instances
  - (`Recce Cloud`) Block PR merging until checks have been approved



  `Recce` is useful for validating your own work or the work of others, and can also be used to share data impact with non-technical stakeholders to approve data checks.

  - **Data engineers** can use `Recce` to ensure the structural integrity of the data and understand the scope of impact before merging.
  - **Analysts** can use `Recce` to self-review and understand how data modeling changes have changed the data.
  - **Stakeholders** can use `Recce` to sign-off on data after updates have been made



  The [Recce Documentation](https://datarecce.io/docs/) covers everything you need to get started.

  We’d advise first following the [5-minute tutorial](https://datarecce.io/docs/get-started-jaffle-shop/) that uses Jaffle Shop and then [trying out Recce](https://datarecce.io/docs/get-started/) in your own project.

  For advice on best practices in preparing dbt environments to enable effective PR review, check out [Best Practices for Preparing Environments](https://datarecce.io/docs/guides/best-practices-prep-env/).



  `Recce Cloud` provides a backbone of supporting services that make Recce usage more suitable for teams reviewing multiple pull requests.

  With `Recce Cloud`:

  - `Recce` Instances can be launched **directly from a PR**
  - **Checks** are automatically **synced** across `Recce` Instances
  - **Blocked merging** until all checks are approved

  [Recce Cloud](https://datarecce.io/cloud) is currently in early-access private beta.

  To find out how you can get access please [book an appointment](https://cal.com/team/recce/chat?utm_source=banner&utm_campaign=oss) for a short meeting.

  <a href="https://cal.com/team/recce/chat?utm_source=banner&utm_campaign=oss">
  <img alt="Book us with [Cal.com](http://cal.com/)" src="https://cal.com/book-with-cal-light.svg" />
  </a>



  `Recce` consists of a local server application that you run on your own device or compute services.

  - Diffs or queries that are performed by `Recce` happen either in your data warehouse, or in the browser itself.
  - `Recce` does not store your data.

  For `Recce Cloud` users:

  - An encrypted version of your `Recce` [state file](https://datarecce.io/docs/features/state-file/) is storedon `Recce Cloud`. This file is encrypted *before* transmission.



  Here's where you can get in touch with the `Recce` team and find support:

  - [dbt Slack](https://www.getdbt.com/community/join-the-community) in the [#tools-recce](https://getdbt.slack.com/archives/C05C28V7CPP) channel
  - [Recce Discord](https://discord.gg/VpwXRC34jz)
  - Email us [product@datarecce.io](mailto:product@datarecce.io)

  If you believe you have found a bug, or there is some missing functionality in Recce, please open a [GitHub Issue](https://github.com/DataRecce/recce/issues).



  You can follow along with news about `Recce` and blogs from our team in the following places:

  - [DataRecce.io](https://DataRecce.io)
  - [LinkedIn](https://www.linkedin.com/company/datarecce)
  - [Medium blog](https://medium.com/inthepipeline)
  - [@datarecce](https://x.com/DataRecce) on Twitter/X
  - [@DataRecce@mastodon.social](https://mastodon.social/@DataRecce) on Mastodon
  - [@datarecce.bsky.social](https://bsky.app/profile/datarecce.bsky.social) on BlueSky


pkgId: 4a103bb0f76198104e1bfb8bfd90a9fe91ca6690a665f7d7a578cb651c6358fc
name: python-reclaim-python-sdk-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for reclaim-python-sdk
url: https://github.com/reclaimprotocol/reclaim-python-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reclaim-python-sdk-0.1.4-1.src.rpm
location_href: Packages/python-reclaim-python-sdk-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  This guide will walk you through integrating the Reclaim Protocol Python SDK into your application. We'll create a simple Python application that demonstrates how to use the SDK to generate proofs and verify claims.



  Before we begin, make sure you have:

  1. An application ID from Reclaim Protocol.
  2. An application secret from Reclaim Protocol.
  3. A provider ID for the specific service you want to verify.

  You can obtain these details from the [Reclaim Developer Portal](https://dev.reclaimprotocol.org/).



  You can install this package directly from GitHub using pip:

  ```bash
  pip install reclaim-python-sdk
  ```



  Here's a simple example of how to use the SDK:

  ```python
  from reclaim_sdk import ReclaimProofRequest
  import asyncio

  async def main():
      
      APP_ID = 'YOUR_APPLICATION_ID_HERE'
      APP_SECRET = 'YOUR_APPLICATION_SECRET_HERE'
      PROVIDER_ID = 'YOUR_PROVIDER_ID_HERE'

      proof_request = await ReclaimProofRequest.init(
          app_id=APP_ID,
          app_secret=APP_SECRET,
          provider_id=PROVIDER_ID
      )

      
      request_url = await proof_request.get_request_url()
      print(f"Request URL: {request_url}")

      
      status_url = proof_request.get_status_url()
      print(f"Status URL: {status_url}")


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  Let's break down what's happening in this code:

  1. We initialize the Reclaim SDK with your application ID, secret, and provider ID.

  2. We generate a request URL using `get_request_url()`. This URL can be used to create a QR code.

  3. We get the status URL using `get_status_url()`. This URL can be used to check the status of the claim process.




  The Reclaim Python SDK offers several advanced options to customize your integration:

  1. **Adding Context**:

     ```python
     proof_request.add_context('0x00000000000', 'Example context message')
     ```

  2. **Setting Parameters**:

     ```python
     proof_request.set_params({
         'email': 'test@example.com',
         'userName': 'testUser'
     })
     ```

  3. **Custom Redirect URL**:

     ```python
     proof_request.set_redirect_url('https://example.com/redirect')
     ```

  4. **Custom Callback URL**:

     ```python
     proof_request.set_app_callback_url('https://example.com/callback')
     ```

  5. **Exporting and Importing SDK Configuration**:

     ```python
     
     config_json = proof_request.to_json_string()
     print('Exportable config:', config_json)

     
     imported_request = ReclaimProofRequest.from_json_string(config_json)
     request_url = await imported_request.get_request_url()
     ```



  Here's a more complete example showing various features:

  ```python
  from reclaim_sdk import ReclaimProofRequest
  import asyncio
  import qrcode

  async def main():
      
      proof_request = await ReclaimProofRequest.init(
          app_id='YOUR_APP_ID',
          app_secret='YOUR_APP_SECRET',
          provider_id='YOUR_PROVIDER_ID'
      )

      
      proof_request.add_context('0x00000000000', 'Example context')
      proof_request.set_params({'email': 'test@example.com'})
      proof_request.set_redirect_url('https://example.com/redirect')
      proof_request.set_app_callback_url('https://example.com/callback')

      
      request_url = await proof_request.get_request_url()


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  For production applications, it's recommended to handle proofs on your backend:

  1. Set a callback URL:

     ```python
     proof_request.set_callback_url('https://your-backend.com/receive-proofs')
     ```

  2. Create an endpoint on your backend to receive proofs:

     ```python
     from flask import Flask, request

     app = Flask(__name__)

     @app.route('/receive-proofs', methods=['POST'])
     def receive_proofs():
         proofs = request.json
         
         return {'status': 'success'}
     ```



  Explore the [Reclaim Protocol documentation](https://docs.reclaimprotocol.org/) for more advanced features and best practices for integrating the SDK into your production applications.

  Happy coding with Reclaim Protocol!



  We welcome contributions to our project! If you find any issues or have suggestions for improvements, please open an issue or submit a pull request.



  Always keep your Application Secret secure. Never expose it in client-side code or public repositories.



  Please read and follow our [Code of Conduct](https://github.com/reclaimprotocol/.github/blob/main/Code-of-Conduct.md) to ensure a positive and inclusive environment for all contributors.



  If you discover any security-related issues, please refer to our [Security Policy](https://github.com/reclaimprotocol/.github/blob/main/SECURITY.md) for information on how to responsibly disclose vulnerabilities.



  Before contributing to this project, please read and sign our [Contributor License Agreement (CLA)](https://github.com/reclaimprotocol/.github/blob/main/CLA.md).



  For Indie Hackers: [Check out our guidelines and potential grant opportunities](https://github.com/reclaimprotocol/.github/blob/main/Indie-Hackers.md)



  This project is licensed under a [custom license](https://github.com/reclaimprotocol/.github/blob/main/LICENSE). By contributing to this project, you agree that your contributions will be licensed under its terms.

  Thank you for your contributions!


pkgId: 6739ddbb386124edf40d53c9ca0d76252a8ae7ca85a72df907f44116a12f71ca
name: python-rectangle-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for rectangle
url: https://pypi.org/project/rectangle/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rectangle-0.5.1-1.src.rpm
location_href: Packages/python-rectangle-help-0.5.1-1.noarch.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2017 Neil  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: 4f2f38f5aac9aad4723dfa168c26ef89773e473f940e22382256f7de2efaa371
name: python-rectified-flow-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for rectified-flow
url: https://github.com/lqiang67/rectified-flow
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rectified-flow-1.0.1-1.src.rpm
location_href: Packages/python-rectified-flow-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [Getting Started](#getting-started)
    - [Rectified Flow: A One-Minute Introduction](#rectified-flow-a-one-minute-introduction)
    - [A Quick Walkthrough](#a-quick-walkthrough)
    - [Interactive Tutorials](#interactive-tutorials)
    - [Training Pipelines](#training-pipelines)
  - [Customize Your Component](#customize-your-component)
    - [Interpolation](#interpolation)
    - [Wrapping a New Velocity](#wrapping-a-new-velocity)
    - [Training Utilities](#training-utilities)
    - [Customized Samplers](#customized-samplers)
  - [License](#license)

  You can install the `rectified-flow` package using `pip`:
  ```
  pip install rectified-flow
  ```
  Alternatively, you can install the package from source. Please run the following commands in the given order to install the dependency.
  ```
  conda create -n rf python=3.10
  conda activate rf
  git clone https://github.com/lqiang67/rectified-flow.git
  cd rectified-flow
  pip install -r requirements.txt
  ```
  Then install the `rectified-flow` package:
  ```
  pip install -e .
  ```


  Consider the task of learning an ODE model $\mathrm d Z_t = v_t(Z_t)\mathrm d t$ that transforms a noise distribution $X_0 \sim \pi_0$ into a data distribution $X_1 \sim \pi_1$. We begin by drawing random pairs $(X_0, X_1)$ (where $X_0$ and $X_1$) are independent by default, and then construct the interpolation $X_t = t X_1 + (1 - t) X_0.$ The rectified flow velocity is learned by minimizing
  $$
  \min_v \mathbb{E}_{X_0, X_1, t} \left[ \left\lVert \frac{\mathrm d}{\mathrm d t} X_t - v_t(X_t, t) \right\rVert^2 \right]
  $$
  where $t \sim \text{Uniform}([0, 1])$ and $\frac{\mathrm d}{\mathrm d t} X_t = X_1 - X_0$.
  After training the model $v_t$, we can solve the ODE $\mathrm d Z_t = v_t(Z_t)  \mathrm d t$ with the initial condition $Z_0 \sim \pi_0$. This yields a set of pairs $(Z_0, Z_1)$, which can be treated as new data pairs $(X_0, X_1)$ to train a new model $v_t^{\text{reflow}}$. This "reflowed" model is known to produce straighter trajectories, allowing the ODE to be solved with fewer Euler steps and larger step sizes.
  Although ultimately unnecessary in theory (see Chapter 3 of the lecture notes), the codebase supports a more general affine interpolation $X_t = \alpha_t X_1 + \beta_t X_0$ to ensure compatibility with existing algorithms.

  The `RectifiedFlow` class serves as an **intermediary** for your training and inference processes. Each different velocity field should instantiate a separate `RectifiedFlow` class.
  ```python
  from rectified_flow.rectified_flow import RectifiedFlow
  model = YourVelocityFieldModel()

  rectified_flow = RectifiedFlow(
      data_shape=(32, 32),
      velocity_field=model,
      interp="straight",
      source_distribution="normal",
      is_independent_coupling=True,
      train_time_distribution="uniform",
      train_time_weight="uniform",
      criterion="mse",
      device=device,
  )

  rectified_flow = RectifiedFlow(
      data_shape=(32, 32),
      velocity_field=model,
      device=device,
  )
  ```
  During training, you can easily compute the predefined loss by passing your target data samples `x_1`. If samples from source distribution `x_0` is not provided, it will be sampled by default from standard Gaussian. The `RectifiedFlow` class supports various pre-specified loss functions and interpolation methods, and it calculates the loss accordingly.
  ```python
  loss = rectified_flow.get_loss(x_0=None, x_1=x_1, **kwargs)
  ```
  This is implemented by:
  ```python

  x_t, dot_x_t = self.get_interpolation(x_0, x_1, t)

  v_t = self.get_velocity(x_t, t, **kwargs)

  time_weights = self.train_time_weight(t)

  return self.criterion(
      v_t=v_t,
      dot_x_t=dot_x_t,
      x_t=x_t,
      t=t,
      time_weights=time_weights,
  )
  ```
  For sampling, import the desired sampler class and pass the `RectifiedFlow` instance to it.
  ```python
  from rectified_flow.samplers import SDESampler
  sde_sampler = SDESampler(rectified_flow=rectified_flow)
  sde_sampler.sample_loop(
      num_samples=128,
      num_steps=100,
      seed=0,
  )
  traj = sde_sampler.trajectories
  img = traj[-1]
  ```

  1. **Introduction with 2D Toy**: This [notebook](examples/train_2d_toys.ipynb) provides a 2D toy example to illustrate the fundamental concepts of Rectified Flow. It covers the basics of interpolation processes, the training and inference of rectified flow, and reflow, which straightens flow dynamics to achieve speedup.
  2. **Samplers**: This [notebook](examples/samplers_2d_toys.ipynb) explores the samplers available in this repository using a 2D toy example. It illustrates the concepts and usage of both deterministic and stochastic samplers. Additionally, it demonstrates how to customize a sampler by inheriting from the $\texttt{Sampler}$ base class and discusses the effects of using stochastic samplers.
  3. **Interpolation**: This [notebook](examples/interpolation_conversion.ipynb) introduces the idea that different affine interpolations can be converted from one form to another and provides a simple implementation to achieve this transformation. It also highlights the interesting observation that the same transformation applies to rectified flows — and, in fact, to their discretized trajectories produced by natural Euler samplers.
  4. **Flux**: We provide a [notebook](examples/inference_flux_dev.ipynb) that shows how to easily interact with the wrapped Flux model using different samplers. Additionally, another [notebook](examples/editing_flux_dev.ipynb) demonstrates how to perform image editing task with Flux. All implementations in a clear and accesible manner.

  We provide **[Diffusers](https://github.com/huggingface/diffusers)-style** training scripts for [UNet](https://github.com/NVlabs/edm). and [DiT](https://github.com/facebookresearch/DiT) in this [directory](rectified_flow/pipelines). The training scripts utilizes **[Accelerate](https://github.com/huggingface/accelerate)** for multi-GPU training.
  **Results Using this Training Scripts**:
  - **UNet CIFAR10**: Trained for $500 \text{k}$ iterations with `batch_size=128`. You can download the model [here](). $\text{FID}_{50\text{K}}=4.308$.
  - **DiT CIFAR10**: Trained for $1000 \text{k}$ iterations with `batch_size=128`. You can download the model [here](). $\text{FID}_{50\text{K}}=3.678$.
  **Loading a Pretrained Model**:
  To construct a model from a pretrained checkpoint, simply run the following code:
  ```python
  from rectified_flow.models.dit import DiT
  model = DiT.from_pretrained(save_directory="PATH_TO_MODEL", filename="dit", use_ema=True).to(device)
  ```


  The `AffineInterp` class manages the affine interpolation between the source distribution $\pi_0$ and the target distribution $\pi_1$. It offers two primary features:
  1. **Automatic Interpolation Handling**: Given an affine interpolation $X_t=\alpha_tX_1 + \beta_t X_0$, providing $\alpha_t$ and $\beta_t$ functions (optionally along with their time-derivative functions $\dot \alpha_t$ and $\dot \beta_t$), `AffineInterp` computes the interpolated state $X_t$ and its time derivative $\dot X_t$. If the derivatives functions $\dot \alpha_t, \dot\beta_t$ are not supplied, they are calculated automatically using Pytorch automatic differentiation.
     ```python
     from rectified_flow.flow_components import AffineInterp
     alpha_function = lambda t: torch.sin(a * t) / torch.sin(a)
     beta_function = lambda t: torch.sin(a * (1 - t)) / torch.sin(a)
     interp = AffineInterp(alpha=alpha_function, beta=beta_function)
     x_t, dot_x_t = interp.forward(x_0, x_1, t)
     ```
  2. **Automatic Solving of Unknown Variables**: Given any two of the four variables ($X_0,X_1,X_t,\dot X_t$), the class can automatically solve for the remaining unknowns using precomputed symbolic solvers from $X_t = \alpha_t X_1 + \beta_t X_0$, and $\dot{X}_t = \boldsymbol{\dot{\alpha}}_t X_1 + \boldsymbol{\dot{\beta}}_t X_0$.
  This feature is  convenient to avoid the hand derivation of the coefficients in DDIM like algorithms, and conversion between important quantities, such as the RF velocity, score fuction, and predicte noise and targets.
     ```python
     
     interp.solve(t=t, x_t=x_t, dot_x_t=velocity)
     print(interp.x_0, interp.x_1)
     ```
     ```python
       
      def step(self):
          t, t_next, x_t = self.t, self.t_next, self.x_t
          v_t = self.rectified_flow.get_velocity(x_t, t)
           
          interp = self.interp_inference.solve(t, x_t=x_t, dot_x_t=v_t)
          x_1_pred = interp.x_1
          x_0_pred = interp.x_0
          
          self.x_t = self.interp_inference.solve(t_next, x_0=x_0_pred, x_1=x_1_pred).x_t
     ```

  The `velocity_field` argument in the `RectifiedFlow` class accepts a neural network or any callable function that takes $x_t$ and $t$ as inputs. If you need to customize your model or convert it from other formats, we recommend using a velocity field wrapper to simplify the process.
  1. **Reversing the Time Direction**
  In Rectified Flow, we use the convention of transforming the **noise (or source) distribution** $X_0 \sim \pi_0$ at time $t = 0$ to the **data (target) distribution** $X_1 \sim \pi_1$ a time $t=1$. In scenarios like Flux, where the velocity transitions from $\pi_1$ to $\pi_0$ for image generation, we need to reverse the ODE time direction. This can be easily achieved by using a simple wrapper:
     ```python
     
     velocity = lambda x_t, t: -model(x_t, 1.0 - t)
     ```
  2. **Reparameterizing for Noise Prediction**
     Some works parameterize the model to predict noise instead of velocity. Using an `AffineInterpSolver`, you can automatically convert noise predictions into velocity predictions, bypassing the complexity of handling DDIM coefficients.
     ```python
     
     
     velocity = lambda x_t, t: self.interp.solve(t=t, x_t=x_t, x_0=model(x_t, t)).dot_x_t
     ```

  To tailor the training process to your specific requirements, you can customize these utilities by inheriting from their base classes and overriding their methods. Once customized, simply pass the instances to the `RectifiedFlow` class during initialization.
  **Example: Custom Weighting Scheme**
  ```python
  from rectified_flow.flow_components import TrainTimeWeight
  class CustomTimeWeight(TrainTimeWeight):
      def __init__(self):
          super().__init__()
      def __call__(self, t: torch.Tensor) -> torch.Tensor:
          wts = torch.exp(t)
          return wts

  custom_time_weight = CustomTimeWeight()
  ```

  To create custom samplers with specific integration schemes, subclass the `Sampler` class and implement the `step` method tailored to your needs. The `step` method receives the current state `x_t`, `t`, and `t_next` from the base class and defines the integration scheme.
  **Example: Euler Sampler**
  ```python
  from rectified_flow.flow_components import Sampler
  class EulerSampler(Sampler):
      def __init__(
          self,
          rectified_flow: RectifiedFlow,
          num_steps: int | None = None,
          time_grid: list[float] | torch.Tensor | None = None,
          record_traj_period: int = 1,
          callbacks: list[Callable] | None = None,
          num_samples: int | None = None,
      ):
          super().__init__(
              rectified_flow,
              num_steps,
              time_grid,
              record_traj_period,
              callbacks,
              num_samples,
          )
      def step(self, **model_kwargs):
          t, t_next, x_t = self.t, self.t_next, self.x_t
          v_t = self.rectified_flow.get_velocity(x_t, t, **model_kwargs)
          self.x_t = x_t + (t_next - t) * v_t
  ```
  After defining your custom sampler, you can perform sampling just like with a standard sampler.
  The following is a quick implementation of stochastic sampler which covers the DDPM sampling algorithm:
  ```python
  class MyStochasticSampler(Sampler):
      def __init__(self, rectified_flow: RectifiedFlow, noise_replacement_rate: Callable | str = lambda t, t_next: 0.5, **kwargs):
          super().__init__(rectified_flow=rectified_flow, **kwargs)
          if not (self.rectified_flow.independent_coupling and self.rectified_flow.is_pi_0_zero_mean_gaussian):
              import warnings
              warnings.warn("It is only theoretically correct to use this sampler when pi0 is a zero mean Gaussian and the coupling (X0, X1) is independent. Proceed at your own risk.")
          self.noise_replacement_rate = noise_replacement_rate
      def step(self, **model_kwargs):
          """Perform a single step of the sampling process."""
          t, t_next, x_t = self.t, self.t_next, self.x_t
          v_t = self.rectified_flow.get_velocity(x_t, t, **model_kwargs)
          
          interp = self.rectified_flow.interp.solve(t, x_t=x_t, dot_x_t=v_t)
          x_1_pred = interp.x_1
          x_0_pred = interp.x_0
          
          noise = self.rectified_flow.sample_source_distribution(self.num_samples)
          noise_replacement_factor = self.noise_replacement_rate(t, t_next)
          x_0_pred_refreshed = (
              (1 - noise_replacement_factor) * x_0_pred +
              (1 - (1 - noise_replacement_factor) ** 2) ** 0.5 * noise
          )
          
          self.x_t = self.rectified_flow.interp.solve(t_next, x_0=x_0_pred_refreshed, x_1=x_1_pred).x_t
    ```

  If you find this repository useful for your research, please consider citing
  ```bibtex
  @misc{lq2024rectifiedflow,
    author = {Qiang Liu, Runlong Liao, Bo Liu, Xixi Hu},
    title = {PyTorch RectifiedFlow},
    year = {2024},
    url = {https://github.com/lqiang67/rectified-flow}
  }
  ```

  | Component | License                                                      |
  | --------- | ------------------------------------------------------------ |
  | Codebase  | [MIT License](LICENSE)                                       |


pkgId: d1f7a7889f01524443b2d5bb7241cd1d5f193769e754feec209689cf902d1d5d
name: python-recurly-help
arch: noarch
version: 4.55.0
epoch: 0
release: 1
summary: Development documents and examples for recurly
url: https://github.com/recurly/recurly-client-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-recurly-4.55.0-1.src.rpm
location_href: Packages/python-recurly-help-4.55.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/static/v1?label=pypi&message=recurly&color=purple)](https://pypi.org/project/recurly/)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](CODE_OF_CONDUCT.md)

  This repository houses the official python library for Recurly's V3 API.

  > *Note*:
  > If you were looking for the V2 client, see the [v2 branch](https://github.com/recurly/recurly-client-python/tree/v2).



  This library's [python documentation](https://recurly-client-python.readthedocs.io/en/latest/) is hosted on ReadTheDocs.
  It contains the Getting Started guide as well as the reference documentation.

  Documentation for the HTTP API and example code can be found
  [on our Developer Portal](https://developers.recurly.com/api/v2019-10-10/).



  Please see our [Contributing Guide](CONTRIBUTING.md).


pkgId: 48a9038de5b8df9b0bbddfc83e7b3c51606bf16e7a6db66d94179363dc9fce8e
name: python-red-plex-help
arch: noarch
version: 1.7.1
epoch: 0
release: 1
summary: Development documents and examples for red-plex
url: https://github.com/marceljungle/red-plex
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-red-plex-1.7.1-1.src.rpm
location_href: Packages/python-red-plex-help-1.7.1-1.noarch.rpm
checksum_type: sha256
description:
  **red-plex** is a command-line tool for creating and updating Plex playlists and collections based on collages and bookmarks from Gazelle-based music trackers like Redacted (RED) and Orpheus Network (OPS). It allows users to generate playlists and collections in their Plex Media Server by matching music albums from specified collages or personal bookmarks, and provides ways to synchronize previously created items with updated information.



  - [Overview](#overview)
  - [Features](#features)
  - [Commands](#commands)
    - [Convert Commands](#convert-commands)
    - [Playlist Management](#playlist-management)
    - [Collection Management](#collection-management)
    - [Bookmark Management](#bookmark-management)
    - [Album Cache Management](#album-cache-management)
    - [Configuration](#configuration-commands)
  - [Examples](#examples)
    - [Creating Playlists and Collections](#creating-playlists-and-collections)
    - [Updating Existing Items](#updating-existing-items)
  - [Configuration](#configuration-root)
    - [Configuration Tips](#configuration-tips)
  - [Considerations](#considerations)



  - **Library Scanning**: The application scans the folder structure of your Plex music library, extracting album paths to create a local cache for efficient matching.
  - **Fetching Collages**: It connects to a Gazelle-based site using API credentials to fetch collages or bookmarks, retrieving torrent paths for the albums listed.
  - **Matching Albums**: The app compares the torrent paths from the site with the album paths in the Plex library, identifying matching albums based on folder names.
  - **Creating Playlists/Collections**: For each collage or bookmark, it creates corresponding Plex playlists or collections containing all matched albums.
  - **Cache Management**: Album, playlist, and collection data are cached to avoid redundant scanning and enable incremental updates.



  - **Multi-Site Support**: Create Plex playlists and collections from both Redacted and Orpheus Network
  - **Playlist and Collection Creation**: Generate both playlists and collections from collages and bookmarks
  - **Multiple Collage IDs**: Support for processing multiple collage IDs in a single command
  - **Optimized Album Caching**: Album cache includes timestamps for incremental updates
  - **Cache Management**: Track processed playlists and collections for automatic updating
  - **Automatic Updates**: Synchronize all cached items with their source collages
  - **Configurable Logging**: Adjust logging level via configuration file
  - **Easy Configuration**: Simple setup using a `config.yml` file
  - **Command-Line Interface**: User-friendly CLI with comprehensive commands
  - **Rate Limiting and Retries**: Handles API rate limiting with retries for failed calls
  - **Python 3 Compatible**: Works with Python 3.7 and above




  ```bash

  red-plex convert playlist [COLLAGE_IDS] --site SITE


  red-plex convert collection [COLLAGE_IDS] --site SITE
  ```


  ```bash

  red-plex playlists cache show


  red-plex playlists cache reset


  red-plex playlists update
  ```


  ```bash

  red-plex collections cache show


  red-plex collections cache reset


  red-plex collections update
  ```


  ```bash

  red-plex bookmarks create playlist --site SITE


  red-plex bookmarks create collection --site SITE


  red-plex bookmarks update playlist


  red-plex bookmarks update collection


  red-plex bookmarks cache playlist show


  red-plex bookmarks cache playlist reset


  red-plex bookmarks cache collection show


  red-plex bookmarks cache collection reset
  ```


  ```bash

  red-plex album-cache show


  red-plex album-cache reset


  red-plex album-cache update
  ```


  ```bash

  red-plex config show


  red-plex config edit


  red-plex config reset
  ```




  ```bash

  red-plex convert playlist 12345 67890 --site red


  red-plex convert collection 12345 67890 --site red


  red-plex bookmarks create playlist --site red


  red-plex bookmarks create collection --site red
  ```


  ```bash

  red-plex playlists update


  red-plex collections update


  red-plex bookmarks update playlist


  red-plex bookmarks update collection
  ```



  The configuration file (`~/.config/red-plex/config.yml`) should contain:

  ```yaml
  PLEX_URL: 'http://localhost:32400'
  PLEX_TOKEN: 'your_plex_token_here'
  SECTION_NAME: 'Music'
  LOG_LEVEL: 'INFO'

  RED:
    API_KEY: 'your_red_api_key_here'
    BASE_URL: 'https://redacted.sh'
    RATE_LIMIT:
      calls: 10
      seconds: 10

  OPS:
    API_KEY: 'your_ops_api_key_here'
    BASE_URL: 'https://orpheus.network'
    RATE_LIMIT:
      calls: 4
      seconds: 15
  ```


  If you encounter issues accessing your Plex server via `http`, like this exception:

  ```xml
  requests.exceptions.ConnectionError: ('Connection aborted.', RemoteDisconnected('Remote end closed connection without response'))
  ```

  You can use the following method to retrieve the secure `https` URL for local access without additional configuration:

  Use the following API call, replacing `{TOKEN}` with your Plex token:
  ```text
  https://plex.tv/api/resources?includeHttps=1&X-Plex-Token={TOKEN}
  ```

  This will return an XML response, including the full https URL:
  ```xml
  <MediaContainer size="5">
    <Device name="Your Server Name" product="Plex Media Server" ...>
      <Connection protocol="https" address="192.168.x.x" port="32400"
        uri="https://192-168-x-x.0123456789abcdef0123456789abcdef.plex.direct:32400" local="1"/>
      ...
    </Device>
    ...
  </MediaContainer>
  ```
  Thanks anonysmussi for pointing this out!



  - **Album Matching**: Ensure proper music library organization with matching folder names
  - **Cache Management**: Regular cache updates improve performance and accuracy
  - **API Rate Limits**: Be mindful of site-specific rate limits
  - **Required Credentials**: Valid API keys needed in configuration
  - **Site Specification**: The `--site` option is mandatory for relevant commands
  - **Logging Levels**: Adjust verbosity in configuration as needed
  - **Cache Tracking**: Separate caches for playlists, collections, and bookmarks enable independent updates
  - **Update Process**: Updates add new items while maintaining existing ones


pkgId: 27700413f17310843596e9c01c952c493e0e56542d0cd2f32185d42ff5b7ed05
name: python-redbookweb-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for redbookweb
url: https://github.com:liusuxian/redbookweb
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-redbookweb-1.0.1-1.src.rpm
location_href: Packages/python-redbookweb-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  基于小红书 Web 端进行的请求封装


  由于 x-s 签名较复杂，因此使用 playwright 进行模拟浏览器行为进行 js 函数调用获取签名算法， 并且其中存在大量的环境检测的行为，因此需要使用到 stealth.min.js 进行绕过。

  环境安装（本地调试）
  ```bash
  pip3 install redbookweb # 下载 redbookweb 客户端包
  pip3 install playwright # 下载 playwright
  playwright install # 安装浏览器环境
  curl -O https://cdn.jsdelivr.net/gh/requireCool/stealth.min.js/stealth.min.js # 下载 stealth.min.js
  ```

  如果在本机启动 Flask 需要安装如下依赖
  ```bash
  pip3 install flask
  pip3 install gevent
  pip3 install requests
  ```

  redbookweb 客户端打包
  ```bash
  pip3 install twine # 使用 twine 来上传你的包。首先需要安装 twine
  python3 setup.py sdist
  twine upload dist/* # 使用 twine 上传生成的包文件
  ```


pkgId: 6b249afa23326b1a50436b52aea31f420c93bb10250214d41a1ed4d9db860b3a
name: python-redhat-qe-cloud-tools-help
arch: noarch
version: 2.0.3
epoch: 0
release: 1
summary: Development documents and examples for redhat-qe-cloud-tools
url: https://github.com/RedHatQE/cloud-tools
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-redhat-qe-cloud-tools-2.0.3-1.src.rpm
location_href: Packages/python-redhat-qe-cloud-tools-help-2.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Python utilities to manage cloud services, such as AWS.



  clone the [repository](https://github.com/RedHatQE/cloud-tools.git)

  ```
  git clone https://github.com/RedHatQE/cloud-tools.git
  ```

  Install [poetry](https://github.com/python-poetry/poetry)

  ```
  poetry install
  ```


  - [AWS Readme](clouds/aws/README.md)
  - [Cloud nuke CLI tools Readme](clouds/cli/README.md)



  * Export GitHub token
  ```bash
  export GITHUB_TOKEN=<your_github_token>
  ```
  * [release-it](https://github.com/release-it/release-it)
  Run the following once (execute outside repository dir for example `~/`):
  ```bash
  sudo npm install --global release-it
  npm install --save-dev @j-ulrich/release-it-regex-bumper
  rm -f package.json package-lock.json
  ```

  * Create a release, run from the relevant branch.
  To create a new release, run:
  ```bash
  git checkout main
  git pull
  release-it # Follow the instructions
  ```


pkgId: e3a788c073ee61daf477878836fd092035bae3b776b5c9f7c3129a0223a8f393
name: python-redis-func-cache-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for redis-func-cache
url: https://pypi.org/project/redis-func-cache/
rpm_license: AGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-redis-func-cache-0.1-1.src.rpm
location_href: Packages/python-redis-func-cache-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![python-package](https://github.com/tanbro/redis_func_cache/actions/workflows/python-package.yml/badge.svg)](https://github.com/tanbro/redis_func_cache/actions/workflows/python-package.yml)
  [![codecov](https://codecov.io/gh/tanbro/redis_func_cache/graph/badge.svg?token=BgeXJZdPbJ)](https://codecov.io/gh/tanbro/redis_func_cache)
  [![readthedocs](https://readthedocs.org/projects/redis-func-cache/badge/)](https://readthedocs.org/projects/redis-func-cache/badge/)

  `redis_func_cache` is a _Python_ library for caching function results in [Redis][], similar to the caching functionality provided by the standard library's [`functools`](https://docs.python.org/library/functools.html) module, which comes with some cache decorators quite handy when we want to code something with memorization.

  When we need to cache function return values distributed over multiple processes or machines, we can use [Redis][] as a backend.
  The purpose of the project is to provide a simple and clean way to use [Redis][] as a backend for cache decorators.
  It implements caches with _LRU_, _RR_, _FIFO_, _RR_ and _LFU_ eviction/replacement policies(<https://wikipedia.org/wiki/Cache_replacement_policies>).

  `redis_func_cache` is fully based on [redis-py][], the official Python client for [Redis][].

  > ❗ **note**:\
  > The project is still under development, and **DO NOT USE IT IN PRODUCTION**



  - install from PyPI:

      ```bash
      pip install -U redis_func_cache
      ```

  - install from source:

      ```bash
      git clone https://github.com/tanbro/redis_func_cache.git
      cd redis_func_cache
      python setup.py install
      ```



  The library combines a pair of [Redis][] data structures to manage cache data:

  - The first one is a sorted set, which stores the hash values of the decorated function calls along with a score for each item.

      When the cache reaches its maximum size, the score is used to determine which item to evict.

  - The second one is a hash map, which stores the hash values of the function calls and their corresponding return values.

  This can be visualized as follows:

  ![data_structure](images/data_structure.svg)

  The main idea of eviction policy is that the cache keys are stored in a sorted set, and the cache values are stored in a hash map. Eviction is performed by removing the lowest-scoring item from the set, and then deleting the corresponding value from the hash map.

  Here is an example showing how the _LRU_ cache's eviction policy works(maximum size is 3):

  ![eviction_example](images/eviction_example.svg)





  Using _LRU_ cache to decorate a recursive Fibonacci function:

  ```python
  from redis import Redis
  from redis_func_cache import RedisFuncCache, TLruPolicy

  redis_client = Redis(...)

  lru_cache = RedisFuncCache("my-first-lru-cache", TLruPolicy, redis_client)

  @lru_cache
  def fib(n):
      if n <= 1:
          return n
      if n == 2:
          return 1
      return fib(n - 1) + fib(n - 2)
  ```

  In this example, we first create a [Redis][] client, then create a [`RedisFuncCache`][] instance with the [Redis][] client and [`TLruPolicy`][] as its arguments.
  Next, we use the `@lru_cache` decorator to decorate the `fib` function.
  This way, each computed result is cached, and subsequent calls with the same parameters retrieve the result directly from the cache, thereby improving performance.

  It works almost the same as the standard library's `functools.lru_cache`, except that it uses [Redis][] as the backend instead of the local machine's memory.

  If we browse the [Redis][] database, we can find the pair of keys' names look like:

  - `func-cache:my-first-lru-cache:lru:__main__:fib:0`

      The key (with `0` suffix) is a sorted set that stores the hash of function invoking and their corresponding scores.

  - `func-cache:my-first-lru-cache:lru:__main__:fib:1`

      The key (with `1` suffix) is a hash map. Each key field in it is the hash value of a function invoking, and the value filed is the return value of the function.



  If want to use other eviction policies, you can specify another policy class as the second argument of [`RedisFuncCache`][].

  For example, we use [`FifoPolicy`][] to implement a _FIFO_ cache:

  ```python
  from redis_func_cache import FifoPolicy

  fifo_cache = RedisFuncCache("my-cache-2", FifoPolicy, redis_client)

  @fifo_cache
  def func1(x):
      ...
  ```

  Use [`RrPolicy`][] to implement a random-remove cache:

  ```python
  from redis_func_cache import RrPolicy

  rr_cache = RedisFuncCache("my-cache-3", RrPolicy, redis_client)

  @rr_cache
  def func2(x):
      ...
  ```

  So far, the following cache eviction policies are available:

  - **[`TLruPolicy`][]**

      > 💡**tip**:\
      > It is a pseudo _LRU_ policy, not very serious/legitimate.
      > The policy removes the lowest member according to the timestamp of invocation, and does not completely ensure eviction of the least recently used item, since the timestamp may be inaccurate.
      > However, the policy is still **MOST RECOMMENDED** for common use. It is faster than the LRU policy and accurate enough for most cases.

  - [`FifoPolicy`][]: first in first out
  - [`LfuPolicy`][]: least frequently used
  - [`LruPolicy`][]: least recently used
  - [`MruPolicy`][]: most recently used
  - [`RrPolicy`][]: random remove

  > ℹ️ **info**:\
  > Explore source codes in directory `src/redis_func_cache/policies` for more details.



  As described above, the cache keys are in a pair form. All decorated functions share the same two keys.
  But some times, we may want a standalone key pair for each decorated function.

  One solution is to use different [`RedisFuncCache`][] instances to decorate different functions.

  Another way is to use a policy that stores cache data in different [Redis][] key pairs for each function. There are several policies to do that out of the box.
  For example, we can use [`TLruMultiplePolicy`][] for a _LRU_ cache that has multiple different [Redis][] key pairs to store return values of different functions, and each function has a standalone keys pair:

  ```python
  from redis_func_cache import TLruMultiplePolicy

  cache = RedisFuncCache("my-cache-4", TLruMultiplePolicy, redis_client)

  @cache
  def func1(x):
      ...

  @cache
  def func2(x):
      ...
  ```

  In the example, [`TLruMultiplePolicy`][] inherits [`BaseMultiplePolicy`][] which implements how to store cache keys and values for each function.

  When called, we can see such keys in the [Redis][] database:

  - key pair for `func1`:

    - `func-cache:my-cache-4:tlru-m:__main__:func1#<hash1>:0`
    - `func-cache:my-cache-4:tlru-m:__main__:func1#<hash1>:1`

  - key pair for `func2`:

    - `func-cache:my-cache-4:tlru-m:__main__:func2#<hash2>:0`
    - `func-cache:my-cache-4:tlru-m:__main__:func2#<hash2>:1`

  where `<hash1>` and `<hash2>` are the hash values of the definitions of `func1` and `func2` respectively.

  Policies that store cache in multiple [Redis][] key pairs are:

  - [`FifoMultiplePolicy`][]
  - [`LfuMultiplePolicy`][]
  - [`LruMultiplePolicy`][]
  - [`MruMultiplePolicy`][]
  - [`RrMultiplePolicy`][]
  - [`TLruMultiplePolicy`][]



  We already known that the library implements cache algorithms based on a pair of [Redis][] data structures, the two **MUST** be in a same [Redis][] node, or it will not work correctly.

  While a [Redis][] cluster will distribute keys to different nodes based on the hash value, we need to guarantee that two keys are placed on the same node. Several cluster policies are provided to achieve this. These policies use the `{...}` pattern in key names.

  For example, here we use a [`TLruClusterPolicy`][] to implement a cluster-aware _LRU_ cache:

  ```python
  from redis_func_cache import TLruClusterPolicy

  cache = RedisFuncCache("my-cluster-cache", TLruClusterPolicy, redis_client)

  @cache
  def my_func(x):
      ...
  ```

  Thus, the names of the key pair may be like:

  - `func-cache:{my-cluster-cache:tlru-c}:0`
  - `func-cache:{my-cluster-cache:tlru-c}:1`

  Notice what is in `{...}`: the [Redis][] cluster will determine which node to use by the `{...}` pattern rather than the entire key string.

  Policies that support cluster are:

  - [`FifoClusterPolicy`][]
  - [`LfuClusterPolicy`][]
  - [`LruClusterPolicy`][]
  - [`MruClusterPolicy`][]
  - [`RrClusterPolicy`][]
  - [`TLruClusterPolicy`][]



  Policies that support both cluster and store cache in multiple [Redis][] key pairs are:

  - [`FifoClusterMultiplePolicy`][]
  - [`LfuClusterMultiplePolicy`][]
  - [`LruClusterMultiplePolicy`][]
  - [`MruClusterMultiplePolicy`][]
  - [`RrClusterMultiplePolicy`][]
  - [`TLruClusterMultiplePolicy`][]



  The [`RedisFuncCache`][] instance has two arguments to control the maximum size and expiration time of the cache:

  - `maxsize`: the maximum number of items that the cache can hold.

      When the cache reaches its `maxsize`, adding a new item will cause an existing cached item to be removed according to the eviction policy.

      > ℹ️ **Note**:\
      > For "multiple" policies, each decorated function has its own standalone data structure, so the value represents the maximum size of each individual data structure.

  - `ttl`: The expiration time (in seconds) for the cache data structure.

      The cache's [redis][] data structure will expire and be released after the specified time.
      Each time the cache is accessed, the expiration time will be reset.

      > ℹ️ **Note**:\
      > For "multiple" policies, each decorated function has its own standalone data structure, so the `ttl` value represents the expiration time of each individual data structure. The expiration time will be reset each time the cache is accessed individually.



  The return value (de)serializer [JSON][] (`json` module of std-lib) by default, which does not work with complex objects.

  But, still, we can use [`pickle`][] to serialize the return value, by specifying `serializers` argument of [`RedisFuncCache`][]:

  ```python
  import pickle

  from redis_func_cache import RedisFuncCache, TLruPolicy


  def redis_factory():
      ...


  my_pickle_cache = RedisFuncCache(
      __name__,
      TLruPolicy,
      redis_factory,
      serializer=(pickle.dumps, pickle.loads)
  )
  ```

  > ⚠️ **warning**:\
  > [`pickle`][] is considered a security risk, and should not be used with runtime/version sensitive data. Use it cautiously and only when necessary.
  > It's a good practice to only cache functions that return simple, [JSON][] serializable data types.

  Other serialization functions also should be workable, such as [simplejson](https://pypi.org/project/simplejson/), [cJSON](https://github.com/DaveGamble/cJSON), [msgpack](https://msgpack.org/), [cloudpickle](https://github.com/cloudpipe/cloudpickle), etc.





  An instance of [`RedisFuncCache`][] calculate key pair names string by calling method `calc_keys` of it's policy.
  There are four basic policies that implement respective kinds of key formats:

  - [`BaseSinglePolicy`][]: All functions share the same key pair, [Redis][] cluster is NOT supported.

      The format is: `<prefix><name>:<__key__>:<0|1>`

  - [`BaseMultiplePolicy`][]: Each function has its own key pair, [Redis][] cluster is NOT supported.

      The format is: `<prefix><name>:<__key__>:<function_name>#<function_hash>:<0|1>`

  - [`BaseClusterSinglePolicy`][]: All functions share the same key pair, [Redis][] cluster is supported.

      The format is: `<prefix>{<name>:<__key__>}:<0|1>`

  - [`BaseClusterMultiplePolicy`][]: Each function has its own key pair, and [Redis][] cluster is supported.

      The format is: `<prefix><name>:<__key__>:<function_name>#{<function_hash>}:<0|1>`

  Variables in the format string are defined as follows:

  |                 |                                                                   |
  | --------------- | ----------------------------------------------------------------- |
  | `prefix`        | `prefix` argument of [`RedisFuncCache`][]                         |
  | `name`          | `name` argument of [`RedisFuncCache`][]                           |
  | `__key__`       | `__key__` attribute the policy class used in [`RedisFuncCache`][] |
  | `function_name` | full name of the decorated function                               |
  | `function_hash` | hash value of the decorated function                              |

  `0` and `1` at the end of the keys are used to distinguish between the two data structures:

  - `0`: a sorted or unsorted set, used to store the hash value and sorting score of function invoking
  - `1`: a hash table, used to store the return value of the function invoking

  If want to use a different format, you can subclass [`AbstractPolicy`][] or any of above policy classes, and implement `calc_keys` method, then pass the custom policy class to [`RedisFuncCache`][].

  The following example demonstrates how to custom key format for a _LRU_ policy:

  ```python
  from typing import TYPE_CHECKING, Any, Callable, Mapping, Sequence, Tuple, override

  from redis_func_cache import AbstractPolicy, RedisFuncCache
  from redis_func_cache.mixins.hash import PickleMd5HashMixin
  from redis_func_cache.mixins.policy import LruScriptsMixin

  if TYPE_CHECKING:
      from redis.typing import KeyT


  def redis_factory():
      ...


  MY_PREFIX = "my_prefix"


  class MyPolicy(LruScriptsMixin, PickleMd5HashMixin, AbstractPolicy):
      __key__ = "my_key"

      @override
      def calc_keys(
          self, f: Callable|None = None, args: Sequence|None = None, kwds: Mapping[str, Any] | None= None
      ) -> Tuple[KeyT, KeyT]:
          k = f"{self.cache.prefix}-{self.cache.name}-{f.__name__}-{self.__key__}"
          return f"{k}-set", f"{k}-map"

  my_cache = RedisFuncCache(name="my_cache", policy=MyPolicy, redis=redis_factory, prefix=MY_PREFIX)

  @my_cache
  def my_func(...):
      ...
  ```

  In the example, we'll get a cache generates [redis][] keys separated by `-`, instead of `:`, prefixed by `"my-prefix"`, and suffixed by `"set"` and `"map"`, rather than `"0"` and `"1"`. The key pair names could be like `my_prefix-my_cache_func-my_key-set` and `my_prefix-my_cache_func-my_key-map`.

  > ❗ **important**:\
  > The calculated key name **SHOULD** be unique.

  `LruScriptsMixin` tells the policy which lua script to use, and `PickleMd5HashMixin` tells the policy to use [`pickle`][] to serialize and `md5` to calculate the hash value of the function.



  When the library performs a get or put action with [redis][], the hash value of the function invocation will be used.

  For the sorted set data structures, the hash value will be used as the member. For the hash map data structure, the hash value will be used as the hash field.

  The algorithm used to calculate the hash value is defined in `AbstractHashMixin`, it can be described as below:

  ```python
  class AbstractHashMixin:

      ...

      def calc_hash(
          self, f: Optional[Callable] = None, args: Optional[Sequence] = None, kwds: Optional[Mapping[str, Any]] = None
      ) -> KeyT:
          if not callable(f):
              raise TypeError(f"Can not calculate hash for {f=}")
          conf = self.__hash_config__
          h = hashlib.new(conf.algorithm)
          h.update(get_fullname(f).encode())
          source = get_source(f)
          if source is not None:
              h.update(source.encode())
          if args is not None:
              h.update(conf.serializer(args))
          if kwds is not None:
              h.update(conf.serializer(kwds))
          if conf.decoder is None:
              return h.digest()
          return conf.decoder(h)
  ```

  As the code snippet above, the hash value is calculated by the full name of the function, the source code of the function, the arguments and keyword arguments --- they are serialized and hashed, then decoded.

  The serializer and decoder are defined in `__hash_config__` attribute of the policy class, and they are used to serialize and decode the arguments and keyword arguments. The default serializer and decoder are [`pickle`][] and `md5` respectively. If no `decoder` is provided, the hash value will be returned as bytes.

  If want to use a different algorithm, we can select a mixin hash class defined in `src/redis_func_cache/mixins/hash.py`.
  For example:

  ```python
  from redis_func_cache import AbstractHashMixin, RedisFuncCache
  from redis_func_cache.mixins.hash import JsonSha1HexHashMixin
  from redis_func_cache.mixins.policy import LruScriptsMixin


  class MyLruPolicy(LruScriptsMixin, JsonSha1HexHashMixin, AbstractPolicy):
      __key__ = "my-lru"

  my_json_sha1_hex_cache = RedisFuncCache(name="json_sha1_hex", policy=MyLruPolicy, redis=redis_factory)
  ```

  If want to use write a new algorithm, you can subclass [`AbstractHashMixin`][] and implement `calc_hash` method.
  For example:

  ```python
  from redis_func_cache import AbstractHashMixin, RedisFuncCache
  from redis_func_cache.mixins.policy import LruScriptsMixin

  def my_func_hash(...):
      ...


  class MyHashMixin(AbstractHashMixin):
      def calc_hash(self, f=None, args=None, kwds=None):
          return my_func_hash(f, args, kwds)


  class MyLruPolicy2(LruScriptsMixin, MyHashMixin, AbstractPolicy):
      __key__ = "my-custom-hash-lru"


  my_custom_hash_cache = RedisFuncCache(name=__name__, policy=MyLruPolicy2, redis=redis_factory)


  @my_custom_hash_cache
  def some_func(...):
      ...
  ```



  - Cannot decorate a function that has an argument not serializable by [`pickle`][] or other serialization libraries.

    - For a common method defined inside a class, the class must be serializable; otherwise, the first `self` argument cannot be serialized.
    - For a class method (decorated by `@classmethod`), the class type itself, i.e., the first `cls` argument, must be serializable.

  - Compatibility with other decorators is not guaranteed.

  - The cache eviction policies are mainly based on [Redis][] sorted set's score ordering. For most policies, the score is a positive integer. It is `2^32-1` in [Redis][], which limits the number of times of eviction replacement. [Redis][] will return an `overflow` error when the score overflows.

  [redis]: https://redis.io/ "Redis is an in-memory data store used by millions of developers as a cache"
  [redis-py]: https://redis.io/docs/develop/clients/redis-py/ "Connect your Python application to a Redis database"

  [json]: https://www.json.org/ "JSON (JavaScript Object Notation) is a lightweight data-interchange format."
  [`pickle`]: https://docs.python.org/library/pickle.html "The pickle module implements binary protocols for serializing and de-serializing a Python object structure."

  [`RedisFuncCache`]: redis_func_cache.cache.RedisFuncCache
  [`AbstractPolicy`]: redis_func_cache.policies.abstract.AbstractPolicy

  [`BaseSinglePolicy`]: redis_func_cache.policies.base.BaseSinglePolicy
  [`BaseMultiplePolicy`]: redis_func_cache.policies.base.BaseMultiplePolicy
  [`BaseClusterSinglePolicy`]: redis_func_cache.policies.base.BaseClusterSinglePolicy
  [`BaseClusterMultiplePolicy`]: redis_func_cache.policies.base.BaseClusterMultiplePolicy

  [`FifoPolicy`]: redis_func_cache.policies.fifo.FifoPolicy "First In First Out policy"
  [`LfuPolicy`]: redis_func_cache.policies.lfu.LfuPolicy "Least Frequently Used policy"
  [`LruPolicy`]: redis_func_cache.policies.lru.LruPolicy "Least Recently Used policy"
  [`MruPolicy`]: redis_func_cache.policies.mru.MruPolicy "Most Recently Used policy"
  [`RrPolicy`]: redis_func_cache.policies.rr.RrPolicy "Random Remove policy"
  [`TLruPolicy`]: redis_func_cache.policies.tlru.TLruPolicy "Time based Least Recently Used policy."

  [`FifoMultiplePolicy`]: redis_func_cache.policies.fifo.FifoMultiplePolicy
  [`LfuMultiplePolicy`]: redis_func_cache.policies.lfu.LfuMultiplePolicy
  [`LruMultiplePolicy`]: redis_func_cache.policies.lru.LruMultiplePolicy
  [`MruMultiplePolicy`]: redis_func_cache.policies.mru.MruMultiplePolicy
  [`RrMultiplePolicy`]: redis_func_cache.policies.rr.RrMultiplePolicy
  [`TLruMultiplePolicy`]: redis_func_cache.policies.tlru.TLruMultiplePolicy

  [`FifoClusterPolicy`]: redis_func_cache.policies.fifo.FifoClusterPolicy
  [`LfuClusterPolicy`]: redis_func_cache.policies.lfu.LfuClusterPolicy
  [`LruClusterPolicy`]: redis_func_cache.policies.lru.LruClusterPolicy
  [`MruClusterPolicy`]: redis_func_cache.policies.mru.MruClusterPolicy
  [`RrClusterPolicy`]: redis_func_cache.policies.rr.RrClusterPolicy
  [`TLruClusterPolicy`]: redis_func_cache.policies.tlru.TLruClusterPolicy

  [`FifoClusterMultiplePolicy`]: redis_func_cache.policies.fifo.FifoClusterMultiplePolicy
  [`LfuClusterMultiplePolicy`]: redis_func_cache.policies.lfu.LfuClusterMultiplePolicy
  [`LruClusterMultiplePolicy`]: redis_func_cache.policies.lru.LruClusterMultiplePolicy
  [`MruClusterMultiplePolicy`]: redis_func_cache.policies.mru.MruClusterMultiplePolicy
  [`RrClusterMultiplePolicy`]: redis_func_cache.policies.rr.RrClusterMultiplePolicy
  [`TLruClusterMultiplePolicy`]: redis_func_cache.policies.tlru.TLruClusterMultiplePolicy


pkgId: 2150a21a6dea9311e2560ba7743c024ff845edf6222ca97a795c9e5bbdf918aa
name: python-redis-key-analyzer-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for redis-key-analyzer
url: https://pypi.org/project/redis-key-analyzer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-redis-key-analyzer-0.1.5-1.src.rpm
location_href: Packages/python-redis-key-analyzer-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  `redis-key-analyzer` is a tool designed to analyze Redis keys, providing detailed statistics on key patterns, memory usage, TTL (Time to Live), and more. This tool is useful for understanding the distribution and characteristics of keys in a Redis database, which can help in optimizing and managing Redis instances.



  - Analyze Redis keys based on patterns, prefixes, and separators.
  - Collect statistics on key types, memory usage, and TTL.
  - Support for read-only Redis clusters.
  - Configurable batch size and sleep intervals for large datasets.



  To install `redis-key-analyzer`, use pip:

  ```bash
  pip install rka
  ```



  You can use the `redis-key-analyzer` via the command line interface (CLI). Below are the available options:

  ```bash
  Usage: redis-key-analyzer [OPTIONS]

  Options:
    --host TEXT          Redis host. Default is 'localhost'.
    --port INTEGER       Redis port. Default is 6379.
    --db INTEGER         Redis database. Default is 0.
    --read-only, -ro     Check read-only cluster.
    --match, -m TEXT     Redis key pattern. Default is '*'.
    --batch-size INTEGER Batch size. Default is 1000.
    --prefix TEXT        Prefixes for key pattern. Example: --prefix 'prefix1 prefix2'.
    --separator TEXT     Separators for key pattern. Default is ':'.
    --limit INTEGER      Limit total keys. -1 for no limit. Default is -1.
    --sleep INTEGER      Sleep seconds between batches. -1 for no sleep. Default is -1.
    --help               Show this message and exit.
  ```

  Search

  ```bash
  rka --host localhost [--port 6379] [--db 0] [-m '*']

  +-------------+--------+-------+---------+---------+-------+--------------+-----------+------------+------------+----------+----------+--------------+
  | pattern     | dtype  |  ttl  | avg_ttl | max_ttl | count | total_memory | memory_hu | memory_avg | memory_max | size_avg | size_max | key(max_ttl) |
  +-------------+--------+-------+---------+---------+-------+--------------+-----------+------------+------------+----------+----------+--------------+
  | my-set      |  set   | NOTTL |    -1   |    -1   |   1   |          272 |  272.0  B |    272     |    272     |    3     |    3     | my-set       |
  | my-list     |  list  | NOTTL |    -1   |    -1   |   1   |          223 |  223.0  B |    223     |    223     |    14    |    14    | my-list      |
  | foos:<*>    | string |  TTL  |   524   |   984   |   3   |          183 |  183.0  B |     61     |     61     |    3     |    3     | foos:123     |
  | my-hash     |  hash  | NOTTL |    -1   |    -1   |   1   |           87 |   87.0  B |     87     |     87     |    2     |    2     | my-hash      |
  | my-zset     |  zset  | NOTTL |    -1   |    -1   |   1   |           83 |   83.0  B |     83     |     83     |    2     |    2     | my-zset      |
  | user.sc:<*> |  hash  | NOTTL |    -1   |    -1   |   1   |           75 |   75.0  B |     75     |     75     |    1     |    1     | user.sc:123  |
  | my-string   | string | NOTTL |    -1   |    -1   |   1   |           61 |   61.0  B |     61     |     61     |    3     |    3     | my-string    |
  +-------------+--------+-------+---------+---------+-------+--------------+-----------+------------+------------+----------+----------+--------------+
  ```


pkgId: 8ae9bb4fef366d96176727a933ebaeb124c503ba20e599199e44c58507d9fcf4
name: python-redis-leakybucket-rate-limiter-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for redis-leakybucket-rate-limiter
url: https://github.com/lee0210/rate-limiter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-redis-leakybucket-rate-limiter-1.0.0-1.src.rpm
location_href: Packages/python-redis-leakybucket-rate-limiter-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  A Redis-based Python package implementing the Leaky Bucket algorithm for rate limiting.



  ```bash
  pip install .
  ```


  ```bash
  docker compose up tests && docker compose down
  ```


pkgId: aa35c7e86861e54cc1414e1b679f185b05bb38333d0ec0b7f62625f12c3127af
name: python-redis-tagged-cache-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for redis-tagged-cache
url: https://pypi.org/project/redis-tagged-cache/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-redis-tagged-cache-0.7.0-1.src.rpm
location_href: Packages/python-redis-tagged-cache-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- *** GENERATED FILE - DO NOT EDIT *** -->
  <!-- This file was generated by jinja-tree (https://github.com/fabien-marty/jinja-tree) from the template file: README.md.template -->





  `redis-tagged-cache` is a Python 3.7+ cache library backed with Redis **with O(1) tags-based invalidation system**.



  Installation: `pip install redis-tagged-cache`

  Usage:

  ```python
  from rtc import CacheMiss, RedisTaggedCache

  cache = RedisTaggedCache(
      namespace="foo",
      host="localhost",
      port=6379,
  )

  invalidation_tags = ["tag1", "tag2"]  # tags are only strings of your choice



  cache.set("key1", "my value", tags=invalidation_tags, lifetime=60)


  print(cache.get("key1", tags=invalidation_tags))


  cache.invalidate("tag2")





  try:
      cache.get("key1", tags=invalidation_tags)
  except CacheMiss:
      print("cache miss")

  ```



  ```python
  from rtc import RedisTaggedCache

  cache = RedisTaggedCache(
      namespace="foo",
      host="localhost",
      port=6379,
  )


  class A:
      @cache.method_decorator(lifetime=60, tags=["tag1", "tag2"])
      def slow_method(self, arg1: str, arg2: str = "foo"):
          print("called")
          return arg1 + arg2


  if __name__ == "__main__":
      a = A()

      
      print(a.slow_method("foo", arg2="bar"))

      
      print(a.slow_method("foo", arg2="bar"))

      
      print(a.slow_method("foo2", arg2="bar"))




  ```



  You will find the full API in [this reference documentation](https://fabien-marty.github.io/redis-tagged-cache/reference/api/).





  All methods have a O(1) complexity regarding the number of keys. The invalidation is synchronous and very fast event if you invalidate millions of keys.

  Note: complexity is O(n) regarding the number of tags.



  The invalidation system does not really remove keys from redis. Invalidated entries are inaccessible (from the API) but they are not removed when the invalidation occurred. They are going to expire by themselves.

  **Be sure to configure your redis instance as a cache with capped memory (see `maxmemory` configuration parameter) and `maxmemory-policy allkeys-lru` settings about keys [automatic eviction](https://redis.io/docs/latest/develop/reference/eviction/)**



  As we support Python 3.7+ for the runtime, the dev environment requires Python 3.9+.

  - `make lint`: for linting the code
  - `make test`: for executing test

  (the poetry env will be automatically created)


pkgId: c66443f6e21db34facf20c9cdb911188b15fa561a27a9ea277bfc23f33f1b640
name: python-reefbuilder_segmentation-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for reefbuilder_segmentation
url: https://pypi.org/project/reefbuilder_segmentation/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reefbuilder_segmentation-1.0.0-1.src.rpm
location_href: Packages/python-reefbuilder_segmentation-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  The broad goal is to develop a pipeline to automate the modelling of segmentation tasks, primarily for
  marine conservation use cases. Find out more about the project at [this Notion page](https://sleet-metacarpal-b16.notion.site/Segmentation-e0ad44bf260a483b88967d4225496511?pvs=74).


  Loosely adapted from [here](https://medium.com/analytics-vidhya/folder-structure-for-machine-learning-projects-a7e451a8caaa)


  Follow the CONTRIBUTING.md file to see how to set up your project


pkgId: 0c1dff972fef2192747d239b2c64508b6278cfd5a544afed0d11c67d69360fe7
name: python-reference-package-help
arch: noarch
version: 0.2.3
epoch: 0
release: 1
summary: Development documents and examples for reference-package
url: https://pypi.org/project/reference-package/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reference-package-0.2.3-1.src.rpm
location_href: Packages/python-reference-package-help-0.2.3-1.noarch.rpm
checksum_type: sha256
description:
  Just a basic package template.



  ```bash
      src/reference_package/api       Public and internal API.
      src/reference_package/cli       Command-line-interface.
      src/reference_package/lib       Implementation.
      tests/e2e                       End-to-end tests.
      test/integration                Integration tests.
      tests/unit                      Unit tests.
  ```



  `reference_package` is a library from which you can import functions. Import the public example function like this: `from reference_package import wait_a_second`. Or, import the internal version like a power user like this: `from reference_package.api.internal import wait_a_second`.

  Unless you're developing, avoid importing directly from library, like `from reference_package.lib.example import wait_a_second`.



  Try the example CLI:

      $ python -m example
      $ python -m example --secs 2



  There are a number of dev tools in the `Makefile`. You can list all the make tools you might want to use:

      $ make list-targets

  Go check them out in `Makefile`.

  *Note: The dev tools are built around developing on a Mac, so they may not all work on Windows without some modifications.*



  You'll want this package's site-package files to be the source files in this repo so you can test your changes without having to reinstall. We've got some tools for that.

  First build and activate the env before installing this package:

      $ make build-env
      $ conda activate reference_package_py3.12

  Note, if you don't have Python installed, you need to pass the package name directly when you build the env: `make build-env PACKAGE_NAME=reference_package`. If you have Python installed (e.g., this conda env already activated), then you don't need to because it uses Python to grab the package name from the `setup.cfg` file.

  Then, install this package and its dev dependencies:

      $ make install INSTALL_EXTRAS=[dev]

  This installs all the dependencies in your conda env site-packages, but the files for this package's installation are now your source files in this repo.



  Before pushing commits, you'll usually want to rebuild the env and run all the QC and testing:

      $ make clean format full

  When making smaller commits, you might just want to run some of the smaller commands:

      $ make clean format full-qc full-test



  Before opening a PR or pushing to it, in addition to running the make QC and build targets above while developing, you'll want to run locally the same CI pipeline that GitHub will run (`.github/workflows/CI.yml`).

  The CI workflow runs multiple Docker images, so you'll need to install Docker and have it running on your machine: https://www.docker.com/.

  Once Dockers is installed and running, you can use `act`. You'll need to install that as well. I develop on a Mac, so I used `homebrew` to install it (which you'll also need to install: https://brew.sh/):

      $ brew install act

  Then, run it from the repo directory:

      $ make ci-run

  That will run `.github/workflows/CI.yml`.

  Since `act` doesn't work with Mac and Windows architecture, it skips/fails them, but it is a good test of the Linux build. Also, the workflow is set to skip some steps when called from `act` (like uploading the dist to GitHub and publishing the package to PyPi), so it doesn't run the full workflow, but it's still a good check of most of the workflow and especially useful when debugging the workflow itself.

  It's generally a good practice to run it at least once before opening a PR.



  I borrowed and modified the structure and tools from the idiomatic usage of IHME's Central Computation GBD team when I worked with them in 2023-2024.


pkgId: 1babebd5dc19eff31d176fbd7b11ad068c68c418be0d2b1cb838ff6c68648697
name: python-refidxdb-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for refidxdb
url: https://pypi.org/project/refidxdb/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-refidxdb-0.0.7-1.src.rpm
location_href: Packages/python-refidxdb-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/refidxdb.svg)](https://badge.fury.io/py/refidxdb)
  [![DeepSource](https://app.deepsource.com/gh/arunoruto/RefIdxDB.svg/?label=code+coverage&show_trend=true&token=6OxGvsq00pW0X5nKcAmq0vOQ)](https://app.deepsource.com/gh/arunoruto/RefIdxDB/)
  [![codecov](https://codecov.io/gh/arunoruto/RefIdxDB/graph/badge.svg?token=NQEJ466GGK)](https://codecov.io/gh/arunoruto/RefIdxDB)

  <p align="center">
    <img src="https://github.com/arunoruto/RefIdxDB/blob/main/.github/logo.png?raw=true" alt="RefIdxDB-Logo"/>
  </p>



  Python interface for various refractive index databases

  I was tired to download files from here and there, parse them each manually and locally.
  Hence, I copied most of my parsing code into this project, so it can be developed further.

  > [!note]
  > If your source is not implemented, feel free to open an issue!
  > You can also try to implement it yourself.
  > You can take `refidx` and `aria` as a reference on what needs to be implemented.



  `refidxdb` can be downloaded from PiPy.org:

  ```sh
  pip install refidxdb
  ```

  After the `pip` command, the `refidxdb` command should be available.



  The main purpose of the CLI is to download and cache the databases locally and interact with it.
  The data will be downloaded to `$HOME/.cache/refidxdb` under a folder corresponding to the class name.
  Please use `refidxdb --help` to explore the functionality.

  Example:

  ```console
  $ # Download all databases
  $ # equivalent to refidxdb db --download aria,refidx
  $ refidxdb db --download all
  Downloading the database for RefIdx from https://github.com/polyanskiy/refractiveindex.info-database/releases/download/v2024-08-14/rii-database-2024-08-14.zip to /home/mar/.cache/refidxdb/RefIdx
  Downloading the database for Aria from https://eodg.atm.ox.ac.uk/ARIA/data_files/ARIA.zip to /home/mar/.cache/refidxdb/Aria
  All databases downlaoded!
  Bye :)

  $ # Replace table with plot to diplay a graph of the data in the terminal
  $ refidxdb show --db aria --data "data_files/Minerals/Olivine/z_orientation_(Fabian_et_al._2001)/olivine_Z_Fabian_2001.ri" --display table --bounds 2.5,15.5
  shape: (2_748, 3)
  ┌───────────┬──────────┬──────────┐
  │ w         ┆ n        ┆ k        │
  │ ---       ┆ ---      ┆ ---      │
  │ f64       ┆ f64      ┆ f64      │
  ╞═══════════╪══════════╪══════════╡
  │ 2.500617  ┆ 1.619696 ┆ 0.000053 │
  │ 2.501381  ┆ 1.619685 ┆ 0.000053 │
  │ 2.502144  ┆ 1.619674 ┆ 0.000053 │
  │ 2.502909  ┆ 1.619663 ┆ 0.000053 │
  │ 2.503674  ┆ 1.619652 ┆ 0.000053 │
  │ …         ┆ …        ┆ …        │
  │ 15.369648 ┆ 1.42662  ┆ 0.036282 │
  │ 15.398545 ┆ 1.419686 ┆ 0.036761 │
  │ 15.427528 ┆ 1.412672 ┆ 0.037256 │
  │ 15.456643 ┆ 1.405576 ┆ 0.037768 │
  │ 15.485869 ┆ 1.398394 ┆ 0.038299 │
  └───────────┴──────────┴──────────┘

  $ # Explore the databases using streamlit
  $ refidxdb explore
  /home/user/Projects/refidxdb/refidxdb

    You can now view your Streamlit app in your browser.

    Local URL: http://localhost:8501
    Network URL: http://10.42.42.212:8501
  ```



  `RefIdxDB`: is the main blueprint class from which all the specific parser classes need to inherit.
  This yields a unified API, i.e., all the instances have the same methods available.

  `path`: is the path leading to the wanted file relative to the database.
  This value can be usually copied from the URL.

  `data`: represents the raw data obtained from the file found under `path`.

  `nk`: are the parsed real and imaginary parts of the refractive index.
  The main column is always the wavelength, i.e., wave numbers will always be transformed into wavelengths.

  `interpolate`: you rarely want to use the tables as is, therefore an interpolation method is implemented
  to calculate `n` and `k` for a target wavelength.

  > [!warning]
  > Only wavelengths are currently supported, since they are my main use-case.
  > If you have a proposal on how to add wave number support, please submit an issue/PR.





  `refractiveindex.info` mainly differentiates between raw data with wavelengths in micrometers,
  or polynomial functions which hold for a certain range. The raw data is contained in `YAML` files,
  with each data type being referenced.

  Currently, supported data types are:

  - `tabulated_nk`
  - `tabulated_n`
  - `tabulated_k`
  - `formula 1`
  - `formula 2`
  - `formula 3`



  Aria consists of `ri` files, which are whitespace separated values.
  The header is prefixed by a hashtag `#`. The `FORMAT` value gives information about the column labels.
  Both wavelengths `WAVL` and wave numbers `WAVN` will be read correctly and transformed into wavelengths
  with no SI prefix (meters [m]). The default scales for wavelengths and wave numbers are 1e-6 (micrometers)
  and 1e2 (centimeters^-1).



  RefIdxDB is, to the best of my knowledge,
  the only project that tries to unify multiple databases under one API.
  Nevertheless, there are projects that have tried to achieve the same for a single database:

  - [refractiveindex](https://pypi.org/project/refractiveindex/)
  - [PyTMM](https://github.com/kitchenknif/PyTMM) - the API is implemented in
    [refractiveindex.py](https://github.com/kitchenknif/PyTMM/blob/master/PyTMM/refractiveIndex.py)
  - [PyOptik](https://github.com/MartinPdeS/PyOptik)

rpm_license:
  MIT License  Copyright (c) 2024 Mirza Arnaut  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: 06a8ba041ce457dc51754d82bb29ef82221a88a94fab4bfeabba7008a9a4568e
name: python-reflex-agent-help
arch: noarch
version: 0.1.0a25
epoch: 0
release: 1
summary: Development documents and examples for reflex-agent
url: https://pypi.org/project/reflex-agent/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reflex-agent-0.1.0a25-1.src.rpm
location_href: Packages/python-reflex-agent-help-0.1.0a25-1.noarch.rpm
checksum_type: sha256
description:
  `reflex-agent` is a flexible framework to create AI agents with modular capabilities and tool integrations.




  ```bash
  pip install reflex-agent
  ```



  - **Zero Dependencies**: The core install has no extra dependencies - bring your own LLM.
  - **Modular Capabilities**: The base agent loop is simple and can be modified through capabilities to add features like memory and chain of thought.
  - **Simple Tool Use**: Use any Python function as a tool that the agent can call.
  - **Client-Server Architecture**: Designed for easy use in a client-server architecture - allowing for stepping through the agent loop.
  - **Async by Default**: All functions are async by default.





  Agents are entities that you can chat with. To create a basic agent, by specifiying an LLM and a system prompt.

  We currently have built-in support for OpenAI and Anthropic models.

  ```python
  from flexai import Agent
  from flexai.llm.openai import OpenAIClient
  from flexai.llm.anthropic import AnthropicClient


  openai_agent = Agent(
      llm=OpenAIClient(model="gpt-4o-mini"),
      prompt="You are a helpful assistant.",
  )

  anthropic_client = Agent(
      llm=AnthropicClient(model="claude-3-5-sonnet-20240620"),
      prompt="You are a helpful assistant.",
  )
  ```

  To interact with an agent, pass in a list of messages. There are two ways to interact with an agent - `stream` and `step`.

  Streaming allows the agent to use multiple messages (such as inner tool uses) before returning a final response.

  ```python
  import asyncio
  from flexai import Agent, UserMessage
  from flexai.llm.openai import OpenAIClient

  agent = Agent(
      llm=OpenAIClient(model="gpt-4o-mini"),
      prompt="You are an expert mathematician.",
  )

  async def get_agent_response(messages):
      async for response in agent.stream(messages):
          print(response)


  asyncio.run(get_agent_response([UserMessage("What's 2 + 2?")]))
  ```

  Stepping allows you to step through the agent loop, allowing you to see the agent's internal state at each step.

  ```python
  import asyncio
  from flexai import Agent, UserMessage
  from flexai.llm.openai import OpenAIClient

  agent = Agent(
      llm=OpenAIClient(model="gpt-4o-mini"),
      prompt="You are an expert mathematician.",
  )

  async def get_agent_response(messages):
      response = await agent.step(messages)
      print(response)

  asyncio.run(get_agent_response([UserMessage("What's 2 + 2?")]))
  ```



  Agents are stateless by default - all state management is done on the user end.
  You can save the agent's output messages to have an extended conversation.

  ```python
  import asyncio
  from flexai import Agent, UserMessage
  from flexai.llm.openai import OpenAIClient

  agent = Agent(
      llm=OpenAIClient(model="gpt-4o-mini"),
      prompt="You are an expert mathematician.",
  )

  async def get_agent_response(messages):
      response = await agent.step(messages):
      print(response)
      messages.append(response)
      messages.append(UserMessage("Tell me some key themes from your story."))
      response = await agent.step(messages):
      print(response)

  asyncio.run(get_agent_response([UserMessage("Tell me a random story")]))
  ```



  Tools are Python functions that the agent can call. The function's signature and docstring are used to determine when and how the tool is called.

  ```python
  import asyncio
  from flexai import Agent, UserMessage
  from flexai.llm.openai import OpenAIClient

  def read_file(file_path: str) -> str:
      """Read a file and get the contents."""
      with open(file_path, "r") as file:
          return file.read()

  def write_file(file_path: str, contents: str) -> None:
      """Write contents to a file."""
      with open(file_path, "w") as file:
          file.write(contents)

  agent = Agent(
      llm=OpenAIClient(model="gpt-4o-mini"),
      prompt="You are an expert mathematician.",
      tools=[
          read_file,
          write_file,
      ]
  )


  async def get_agent_response(messages):
      
      async for message in agent.stream(messages):
          print(message)

  asyncio.run(get_agent_response([UserMessage("Read the README.md file and create a copy at README2.md with a high level summary.")]))
  ```



  Capabilities allow you to modify the core agent loop and change the behavior of the agent.

  You can plug in to the agent loop to modify messages, responses, and system messages. For example, the `TruncateMessages` capability truncates the input messages to the LLM to a maximum.

  ```python
  @dataclass
  class TruncateMessages(Capability):
      """Truncate the input messages to the LLM to a maximum number."""

      
      max_messages: int

      async def modify_messages(self, messages: list[Message]) -> list[Message]:
          return messages[-self.max_messages :]
  ```

  This capability is built-in to the framework to use:

  ```python
  import asyncio
  from flexai import Agent, UserMessage
  from flexai.llm.openai import OpenAIClient
  from flexai.capabilities import TruncateMessages

  agent = Agent(
      llm=OpenAIClient(model="gpt-4o-mini"),
      prompt="You are an expert mathematician.",
      capabilities=[TruncateMessages(max_messages=3)],
  )
  ```


pkgId: 3d38a3d82a58e65afab89b765c68bf434a341555a637b08519b00973fa6fa122
name: python-reflex-ai-help
arch: noarch
version: 0.1.0a37
epoch: 0
release: 1
summary: Development documents and examples for reflex-ai
url: https://pypi.org/project/reflex-ai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reflex-ai-0.1.0a37-1.src.rpm
location_href: Packages/python-reflex-ai-help-0.1.0a37-1.noarch.rpm
checksum_type: sha256
description:
  `reflex-ai` is a package to bring AI agent capabilities to your local development environment.

  It also includes blocks for higher level components.



  Install the package with pip:

  ```bash
  pip install reflex-ai
  ```

  NOTE: `reflex-ai` requires `reflex` 0.6.0 or later. Before this is out, make sure to run the following:

  ```bash
  pip install git+https://github.com/reflex-dev/reflex.git@main
  pip uninstall watchfiles
  ```



  `reflex-ai` works with both new and existing Reflex projects. To create a new project, create a directory for your app and run:

  ```bash
  reflex init
  ```

  See the [reflex docs](https://github.com/reflex-dev/reflex) for more information on creating Reflex projects.



  To enable AI in your project, add the following to your main app file.

  ```bash

  from reflex_ai import enable

  app = rx.App()

  enable(app)


  app.add_page(index)
  ```



  Run your app as usual:

  While we're in beta, you need to take the following steps:

  Export the backend URL for the AI agent:
  ```
  export FLEXGEN_BACKEND_URL=https://rxh-prod-flexgen-agent.fly.dev/
  ```

  Install `

  Then run your app as usual:

  ```bash
  reflex run
  ```

  NOTE: You must be logged in to Reflex to use `reflex-ai`.



  Every page in your app will have an additional route by adding `/edit` to the end of the URL. For example, if your index page is at `localhost:3000`, you can access the AI editor at `localhost:3000/edit`. Similarly, if your about page is at `localhost:3000/about`, you can access the AI editor at `localhost:3000/about/edit`.

  When `reflex-ai` is enabled, a scratch copy of your app will be created in the `.web/reflex-ai-tmp` directory for the AI to make changes without affecting your main app.



  On an edit page, you can select elements by clicking on them. The selected element will be highlighted in the editor and the toolbar will show the selected code.

  You can enter prompts in the toolbar input to generate new content for the selected element. The AI will generate new content based on the prompt and update the element in the editor.


pkgId: 33254fc9fb10f39e4931c27b945ba534337cd499489d7e41d8d479ed6e0cada3
name: python-reflex-audio-capture-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for reflex-audio-capture
url: https://pypi.org/project/reflex-audio-capture/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reflex-audio-capture-0.0.5-1.src.rpm
location_href: Packages/python-reflex-audio-capture-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Cross-browser audio capture using audio-recorder-polyfill.

  This component is highly experimental.



  ```bash
  pip install reflex-audio-capture
  ```



  See audio-capture-demo for example usage.


pkgId: 2112169784d52a339e4f3b601ed3a9938f5ccc103279c3c471d0ac9cb8911e84
name: python-reflex-google-auth-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for reflex-google-auth
url: https://pypi.org/project/reflex-google-auth/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reflex-google-auth-0.0.7-1.src.rpm
location_href: Packages/python-reflex-google-auth-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  Sign in with Google.



  ```bash
  pip install reflex-google-auth
  ```





  Head over to https://console.developers.google.com/apis/credentials and sign in with the Google account that should manage the app and credential tokens.

  - Click "Create Project" and give it a name. After creation the new project should be selected.
  - Click "Configure Consent Screen", Choose "External", then Create.
    - Enter App Name and User Support Email -- these will be shown to users when logging in
    - Scroll all the way down to "Developer contact information" and add your email address, click "Save and Continue"
    - Click "Add or Remove Scopes"
      - Select "Email", "Profile", and "OpenID Connect"
      - Click "Update", then "Save and Continue"
    - Add any test users that should be able to log in during development.
  - From the "Credentials" page, click "+ Create Credentials", then "OAuth client ID"
    - Select Application Type: "Web Application"
    - Add Authorized Javascript Origins: http://localhost, http://localhost:3000, https://example.com (prod domain must be HTTPS)
    - Click "Save"
  - Copy the OAuth "Client ID" and save it for later. Mine looks like 309209880368-4uqd9e44h7t4alhhdqn48pvvr63cc5j5.apps.googleusercontent.com

  https://github.com/reflex-dev/reflex-examples/assets/1524005/af2499a6-0bda-4d60-b52b-4f51b7322fd5



  The `GoogleAuthState` provided by this component has a `token_is_valid` var that
  should be checked before returning any protected content.

  Additionally the `GoogleAuthState.tokeninfo` dict contains the user's profile information.

  ```python
  from reflex_google_auth import GoogleAuthState, require_google_login


  class State(GoogleAuthState):
      @rx.var(cache=True)
      def protected_content(self) -> str:
          if self.token_is_valid:
              return f"This content can only be viewed by a logged in User. Nice to see you {self.tokeninfo['name']}"
          return "Not logged in."
  ```

  The convenience decorator, `require_google_login`, can wrap an existing component, and
  show the "Sign in with Google" button if the user is not already authenticated. It can be
  used on a page function or any subcomponent function of the page.

  The "Sign in with Google" button can also be displayed via `google_login()`:

  ```python
  from reflex_google_auth import google_login, google_oauth_provider

  def page():
      return rx.div(
          google_oauth_provider(
              google_login(),
          ),
      )
  ```

  To uniquely identify a user, the `GoogleAuthState.tokeninfo['sub']` field can be used.

  See the example in
  [masenf/rx_shout](https://github.com/masenf/rx_shout/blob/main/rx_shout/state.py)
  for how to integrate an authenticated Google user with other app-specific user
  data.


pkgId: 82c078c735d1e073e19786db4bb49e34554a4733d395c1f19b30345c85360876
name: python-reflex-google-auth-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for reflex-google-auth
url: https://pypi.org/project/reflex-google-auth/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reflex-google-auth-0.0.8-1.src.rpm
location_href: Packages/python-reflex-google-auth-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  Sign in with Google.



  ```bash
  pip install reflex-google-auth
  ```





  Head over to https://console.developers.google.com/apis/credentials and sign in with the Google account that should manage the app and credential tokens.

  - Click "Create Project" and give it a name. After creation the new project should be selected.
  - Click "Configure Consent Screen", Choose "External", then Create.
    - Enter App Name and User Support Email -- these will be shown to users when logging in
    - Scroll all the way down to "Developer contact information" and add your email address, click "Save and Continue"
    - Click "Add or Remove Scopes"
      - Select "Email", "Profile", and "OpenID Connect"
      - Click "Update", then "Save and Continue"
    - Add any test users that should be able to log in during development.
  - From the "Credentials" page, click "+ Create Credentials", then "OAuth client ID"
    - Select Application Type: "Web Application"
    - Add Authorized Javascript Origins: http://localhost, http://localhost:3000, https://example.com (prod domain must be HTTPS)
    - If using custom button, add the same origins to "Authorized redirect URIs"
    - Click "Save"
  - Copy the OAuth "Client ID" and "Client Secret" and save it for later. Mine looks like 309209880368-4uqd9e44h7t4alhhdqn48pvvr63cc5j5.apps.googleusercontent.com

  https://github.com/reflex-dev/reflex-examples/assets/1524005/af2499a6-0bda-4d60-b52b-4f51b7322fd5



  Set the following environment variables based on your deployment.

  ```bash
  export GOOGLE_CLIENT_ID="309209880368-4uqd9e44h7t4alhhdqn48pvvr63cc5j5.apps.googleusercontent.com"
  export GOOGLE_CLIENT_SECRET="your_client_secret"
  export GOOGLE_REDIRECT_URI="http://localhost:3000"
  ```



  The `GoogleAuthState` provided by this component has a `token_is_valid` var that
  should be checked before returning any protected content.

  Additionally the `GoogleAuthState.tokeninfo` dict contains the user's profile information.

  ```python
  from reflex_google_auth import GoogleAuthState, require_google_login


  class State(GoogleAuthState):
      @rx.var(cache=True)
      def protected_content(self) -> str:
          if self.token_is_valid:
              return f"This content can only be viewed by a logged in User. Nice to see you {self.tokeninfo['name']}"
          return "Not logged in."
  ```

  The convenience decorator, `require_google_login`, can wrap an existing component, and
  show the "Sign in with Google" button if the user is not already authenticated. It can be
  used on a page function or any subcomponent function of the page.

  The "Sign in with Google" button can also be displayed via `google_login()`:

  ```python
  from reflex_google_auth import google_login, google_oauth_provider

  def page():
      return rx.div(
          google_oauth_provider(
              google_login(),
          ),
      )
  ```

  To uniquely identify a user, the `GoogleAuthState.tokeninfo['sub']` field can be used.

  See the example in
  [masenf/rx_shout](https://github.com/masenf/rx_shout/blob/main/rx_shout/state.py)
  for how to integrate an authenticated Google user with other app-specific user
  data.



  If you want to use your own login button, you may use whatever component you
  like, as long as it is wrapped in a `reflex_google_auth.google_oauth_provider`
  component and the `on_click` triggers
  `reflex_google_auth.handle_google_login()`. Note that this cannot be combined
  with other event handlers.

  This functionality is also exposed in the `require_google_auth` decorator, which
  accepts a `button` keyword argument.

  When using a custom button, the returned auth-code _must be validated on the
  backend_, which is handled by this library, but **requires additionally setting
  `GOOGLE_CLIENT_SECRET` and `GOOGLE_REDIRECT_URI` environment variables**. These
  can be configured in the Google Cloud Console as described above.

  ```python
  from reflex_google_auth import handle_google_login, require_google_login, GoogleAuthState


  @require_google_login(button=rx.button("Google Login 🚀", on_click=handle_google_login()))
  def custom_button() -> rx.Component:
      return rx.vstack(
          f"{GoogleAuthState.tokeninfo['email']} clicked a custom button to login, nice",
      )
  ```


pkgId: 7499e05a19c9c6521fd77c4a0fb0ce4b1c928b6e40a1db340ae7291ed7b7bbf6
name: python-reflex-intersection-observer-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for reflex-intersection-observer
url: https://github.com/masenf/reflex-intersection-observer
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reflex-intersection-observer-0.0.5-1.src.rpm
location_href: Packages/python-reflex-intersection-observer-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  React to a component coming into view using Reflex event handler.



  ```bash
  pip install reflex-intersection-observer
  ```



  ```python
  import reflex as rx

  from reflex_intersection_observer import intersection_observer

  def index():
      return rx.vstack(
          rx.box(height="150vh"),
          intersection_observer(
              on_intersect=rx.console_log,
          ),
      )
  ```

  See [intersection_observer_demo](./intersection_observer_demo/) app for further examples.



  The following props are understood by `intersection_observer`:

  * `root` - ID of the element that is used as the viewport for checking
    visibility of the target. Must be the id of a parent of the target. Default is
    the browser viewport.
  * `root_margin` - An offset rectangle applied to the root's bounding box when
    calculating intersections, effectively shrinking or growing the root for
    calculation purposes. The value returned by this property may not be the same
    as the one specified when calling the constructor as it may be changed to
    match internal requirements. Each offset can be expressed in pixels (px) or as
    a percentage (%). The default is "0px 0px 0px 0px".
  * `threshold` - value between 0 and 1 indicating the percentage that should be
    visible before the event is triggered. Default is 1.

  The following events are emitted by `intersection_observer`:

  * `on_intersect` - fired when the target element intersects with the root element.
  * `on_non_intersect` - fired when the target element does not intersect with the root element.

  Both of these events provide an `IntersectionObserverEntry` with intersection details:

  * `intersection_ratio`: how much of the target element is intersection (0 - 1).
  * `is_intersecting`: true/false based on whether the observer is intersecting or not
  * `time`: relative timestamp when the intersection occured

  See [IntersectionObserver API](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver)
  docs on MDN for more information about how the API works.


pkgId: c681c4d9266f2e057691146b45f92cb112df507d2534a3df6bf92b4fc7190744
name: python-reflex-mouse-track-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for reflex-mouse-track
url: https://github.com/Lendemor/reflex-mouse-track/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reflex-mouse-track-0.0.1-1.src.rpm
location_href: Packages/python-reflex-mouse-track-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  A Reflex custom component mouse-track.



  ```bash
  pip install reflex-mouse-track
  ```

  Example:
  ```python
  @dataclasses.dataclass
  class Point:
      """Point dataclass."""

      x: int
      y: int

  class MouseTrackState(rx.State):
      def handle_click(self, mouse: Point):
          """Handle click event."""
          yield rx.toast(f"Click event: {mouse}")

  def tracking_area():
      return mouse_track(
          background_color="gray",
          on_click=MouseTrackState.handle_click,
          width="100vw",
          height="100vh",
      )
  ```


  - Event Triggers:
      - `on_click`: Triggered when the user clicks on the tracking area.
      - `on_mouse_down`: Triggered when the user press a mouse button on the tracking area.
      - `on_mouse_up`: Triggered when the user releases the mouse on the tracking area.

  Known errors:
   - When trying to access `MousePosition`, if you get an error saying `'mouse' is undefined`, you might need to decorate the global function where you do the mouse tracking with `@rx.memo`.


pkgId: edfb13e73c1829ff3a8c036a616a59f4d35d85af5bd668d1067d7ed1e36f15e2
name: python-reflexive-help
arch: noarch
version: 1.0.19
epoch: 0
release: 1
summary: Development documents and examples for reflexive
url: https://github.com/nlytx/reflexive
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reflexive-1.0.19-1.src.rpm
location_href: Packages/python-reflexive-help-1.0.19-1.noarch.rpm
checksum_type: sha256
description:
  A package to conduct Reflexive Expression analysis using AWS.

                                   Apache License
                             Version 2.0, January 2004
                          http://www.apache.org/licenses/

     TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

     1. Definitions.

        "License" shall mean the terms and conditions for use, reproduction,
        and distribution as defined by Sections 1 through 9 of this document.

        "Licensor" shall mean the copyright owner or entity authorized by
        the copyright owner that is granting the License.

        "Legal Entity" shall mean the union of the acting entity and all
        other entities that control, are controlled by, or are under common
        control with that entity. For the purposes of this definition,
        "control" means (i) the power, direct or indirect, to cause the
        direction or management of such entity, whether by contract or
        otherwise, or (ii) ownership of fifty percent (50%) or more of the
        outstanding shares, or (iii) beneficial ownership of such entity.

        "You" (or "Your") shall mean an individual or Legal Entity
        exercising permissions granted by this License.

        "Source" form shall mean the preferred form for making modifications,
        including but not limited to software source code, documentation
        source, and configuration files.

        "Object" form shall mean any form resulting from mechanical
        transformation or translation of a Source form, including but
        not limited to compiled object code, generated documentation,
        and conversions to other media types.

        "Work" shall mean the work of authorship, whether in Source or
        Object form, made available under the License, as indicated by a
        copyright notice that is included in or attached to the work
        (an example is provided in the Appendix below).

        "Derivative Works" shall mean any work, whether in Source or Object
        form, that is based on (or derived from) the Work and for which the
        editorial revisions, annotations, elaborations, or other modifications
        represent, as a whole, an original work of authorship. For the purposes
        of this License, Derivative Works shall not include works that remain
        separable from, or merely link (or bind by name) to the interfaces of,
        the Work and Derivative Works thereof.

        "Contribution" shall mean any work of authorship, including
        the original version of the Work and any modifications or additions
        to that Work or Derivative Works thereof, that is intentionally
        submitted to Licensor for inclusion in the Work by the copyright owner
        or by an individual or Legal Entity authorized to submit on behalf of
        the copyright owner. For the purposes of this definition, "submitted"
        means any form of electronic, verbal, or written communication sent
        to the Licensor or its representatives, including but not limited to
        communication on electronic mailing lists, source code control systems,
        and issue tracking systems that are managed by, or on behalf of, the
        Licensor for the purpose of discussing and improving the Work, but
        excluding communication that is conspicuously marked or otherwise
        designated in writing by the copyright owner as "Not a Contribution."

        "Contributor" shall mean Licensor and any individual or Legal Entity
        on behalf of whom a Contribution has been received by Licensor and
        subsequently incorporated within the Work.

     2. Grant of Copyright License. Subject to the terms and conditions of
        this License, each Contributor hereby grants to You a perpetual,
        worldwide, non-exclusive, no-charge, royalty-free, irrevocable
        copyright license to reproduce, prepare Derivative Works of,
        publicly display, publicly perform, sublicense, and distribute the
        Work and such Derivative Works in Source or Object form.

     3. Grant of Patent License. Subject to the terms and conditions of
        this License, each Contributor hereby grants to You a perpetual,
        worldwide, non-exclusive, no-charge, royalty-free, irrevocable
        (except as stated in this section) patent license to make, have made,
        use, offer to sell, sell, import, and otherwise transfer the Work,
        where such license applies only to those patent claims licensable
        by such Contributor that are necessarily infringed by their
        Contribution(s) alone or by combination of their Contribution(s)
        with the Work to which such Contribution(s) was submitted. If You
        institute patent litigation against any entity (including a
        cross-claim or counterclaim in a lawsuit) alleging that the Work
        or a Contribution incorporated within the Work constitutes direct
        or contributory patent infringement, then any patent licenses
        granted to You under this License for that Work shall terminate
        as of the date such litigation is filed.

     4. Redistribution. You may reproduce and distribute copies of the
        Work or Derivative Works thereof in any medium, with or without
        modifications, and in Source or Object form, provided that You
        meet the following conditions:

        (a) You must give any other recipients of the Work or
            Derivative Works a copy of this License; and

        (b) You must cause any modified files to carry prominent notices
            stating that You changed the files; and

        (c) You must retain, in the Source form of any Derivative Works
            that You distribute, all copyright, patent, trademark, and
            attribution notices from the Source form of the Work,
            excluding those notices that do not pertain to any part of
            the Derivative Works; and

        (d) If the Work includes a "NOTICE" text file as part of its
            distribution, then any Derivative Works that You distribute must
            include a readable copy of the attribution notices contained
            within such NOTICE file, excluding those notices that do not
            pertain to any part of the Derivative Works, in at least one
            of the following places: within a NOTICE text file distributed
            as part of the Derivative Works; within the Source form or
            documentation, if provided along with the Derivative Works; or,
            within a display generated by the Derivative Works, if and
            wherever such third-party notices normally appear. The contents
            of the NOTICE file are for informational purposes only and
            do not modify the License. You may add Your own attribution
            notices within Derivative Works that You distribute, alongside
            or as an addendum to the NOTICE text from the Work, provided
            that such additional attribution notices cannot be construed
            as modifying the License.

        You may add Your own copyright statement to Your modifications and
        may provide additional or different license terms and conditions
        for use, reproduction, or distribution of Your modifications, or
        for any such Derivative Works as a whole, provided Your use,
        reproduction, and distribution of the Work otherwise complies with
        the conditions stated in this License.

     5. Submission of Contributions. Unless You explicitly state otherwise,
        any Contribution intentionally submitted for inclusion in the Work
        by You to the Licensor shall be under the terms and conditions of
        this License, without any additional terms or conditions.
        Notwithstanding the above, nothing herein shall supersede or modify
        the terms of any separate license agreement you may have executed
        with Licensor regarding such Contributions.

     6. Trademarks. This License does not grant permission to use the trade
        names, trademarks, service marks, or product names of the Licensor,
        except as required for reasonable and customary use in describing the
        origin of the Work and reproducing the content of the NOTICE file.

     7. Disclaimer of Warranty. Unless required by applicable law or
        agreed to in writing, Licensor provides the Work (and each
        Contributor provides its Contributions) on an "AS IS" BASIS,
        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
        implied, including, without limitation, any warranties or conditions
        of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
        PARTICULAR PURPOSE. You are solely responsible for determining the
        appropriateness of using or redistributing the Work and assume any
        risks associated with Your exercise of permissions under this License.

     8. Limitation of Liability. In no event and under no legal theory,
        whether in tort (including negligence), contract, or otherwise,
        unless required by applicable law (such as deliberate and grossly
        negligent acts) or agreed to in writing, shall any Contributor be
        liable to You for damages, including any direct, indirect, special,
        incidental, or consequential damages of any character arising as a
        result of this License or out of the use or inability to use the
        Work (including but not limited to damages for loss of goodwill,
        work stoppage, computer failure or malfunction, or any and all
        other commercial damages or losses), even if such Contributor
        has been advised of the possibility of such damages.

     9. Accepting Warranty or Additional Liability. While redistributing
        the Work or Derivative Works thereof, You may choose to offer,
        and charge a fee for, acceptance of support, warranty, indemnity,
        or other liability obligations and/or rights consistent with this
        License. However, in accepting such obligations, You may act only
        on Your own behalf and on Your sole responsibility, not on behalf
        of any other Contributor, and only if You agree to indemnify,
        defend, and hold each Contributor harmless for any liability
        incurred by, or claims asserted against, such Contributor by reason
        of your accepting any such warranty or additional liability.

     END OF TERMS AND CONDITIONS

     APPENDIX: How to apply the Apache License to your work.

        To apply the Apache License to your work, attach the following
        boilerplate notice, with the fields enclosed by brackets "[]"
        replaced with your own identifying information. (Don't include
        the brackets!)  The text should be enclosed in the appropriate
        comment syntax for the file format. We also recommend that a
        file or class name and description of purpose be included on the
        same "printed page" as the copyright notice for easier
        identification within third-party archives.

     Copyright [yyyy] [name of copyright owner]

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

         http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.


pkgId: 8e29d38b4a266655a5ec50dbfb58173b451080b56f4cfef891047e08d78bd8d7
name: python-refscan-help
arch: noarch
version: 0.1.23
epoch: 0
release: 1
summary: Development documents and examples for refscan
url: https://github.com/microbiomedata/refscan
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-refscan-0.1.23-1.src.rpm
location_href: Packages/python-refscan-help-0.1.23-1.noarch.rpm
checksum_type: sha256
description:
  If you have `curl` installed, you can download a YAML file from GitHub by running the following command (after replacing
  the `{...}` placeholders and customizing the path):
  ```shell

  curl -o schema.yaml https://raw.githubusercontent.com/{user_or_org}/{repo}/{branch}/path/to/schema.yaml
  ```
  For example:
  ```shell

  curl -o schema.yaml https://raw.githubusercontent.com/microbiomedata/berkeley-schema-fy24/main/nmdc_schema/nmdc_materialized_patterns.yaml


pkgId: 3a0c5ae47003451676948e6d3526e1d082e8f9e5353c0f9521b23edb96ebc6e8
name: python-regbot-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for regbot
description:
  Install from [PyPI](https://pypi.org/project/regbot/):
  ```shell
  python3 -m pip install regbot

url: https://github.com/genomicmedlab/regbot
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-regbot-0.1.1-1.src.rpm
location_href: Packages/python-regbot-help-0.1.1-1.noarch.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 Wagner Laboratory at the Institute for Genomic Medicine  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: 386607fe7bfee8527ec32f3e3b0a19b52538c1a494cc48126803c969ca6efe12
name: python-regex-enumerator-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for regex-enumerator
url: https://github.com/Buba98/regex_enumerator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-regex-enumerator-0.7.0-1.src.rpm
location_href: Packages/python-regex-enumerator-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/regex-enumerator.svg)](https://pypi.org/project/regex-enumerator/)

  This library is meant to generate all the strings that match a given regex pattern. It is written in python and uses no external libraries.



  ```bash
  pip install regex-enumerator
  ```



  Here's an example of how to use the library:

  ```python
  from regex_enumerator import RegexEnumerator


  re = RegexEnumerator(r'a[0-9]b')


  print(re.next()) # a0b
  print(re.next()) # a1b
  print(re.next()) # a2b
  ```



  - [x] Character classes
  - [x] Quantifiers for character classes
  - [x] Quantifiers for groups
  - [x] Groups (named and unnamed)
  - [x] Alternation
  - [x] Escaped characters
  - [x] Backreferences (named and unnamed)



  - [ ] Lookahead and lookbehind
  - [ ] Non-capturing groups



  - [ ] Unicode properties
  - [ ] Word boundaries
  - [ ] Anchors
  - [ ] Non-greedy quantifiers



  The library supports ASCII characters by default. To handle Unicode characters, include them explicitly in your regex or define a custom character set.

  ```python
  from regex_enumerator import RegexEnumerator


  regex_enum = RegexEnumerator(r'£')
  print(regex_enum.next())  # £


  unicode_charset = [chr(i) for i in range(ord('¡'), ord('£'))]
  unicode_charset = ['¡', '¢', '£']
  unicode_charset = '¡¢£'
  unicode_charset = ['¡¢', '£']

  regex_enum = RegexEnumerator(r'.', additional_charset=unicode_charset)

  result = []
  while (char := regex_enum.next()) is not None:
      result.append(char)

  assert '¡' in result
  assert '¢' in result
  assert '£' in result
  ```



  This library works by parsing the regex pattern into a tree structure. Once parsed, it performs a breadth-first search (BFS) on the tree to generate all matching strings. This ensures it does not get stuck on unbounded quantifiers for character classes or groups.



  The library includes a comprehensive test suite. To run the tests, use the following command:

  ```bash
  pytest
  ```



  I don't know what license to use, so I'm going to use the MIT license. If you have any suggestions, please let me know.



  Feel free to contribute to this project. I'm open to suggestions and improvements.


pkgId: 731fb2c0095ce52fe4d8609cd648088a3590be45482471dd12696d69b59e09cb
name: python-region-grower-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for region-grower
url: https://region-grower.readthedocs.io
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-region-grower-1.6.0-1.src.rpm
location_href: Packages/python-region-grower-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  Synthesize neuronal morphologies in a given spatial context provided by an atlas. The documentation can be found here: https://region-grower.readthedocs.io/en/latest/




  This package provides a general tools to synthesize cells in a given spatial context (a brain Atlas)
  with embarrassingly parallel computation (with distributed computing via dask-mpi).
  This package is difficult to use on its own, as it requires several specific inputs from atlas and
  synthesis. It is advised to use it via [synthesis-workflow](https://github.com/BlueBrain/synthesis-workflow),
  which is a workflow generating most of the inputs of region-grower.




  This package should be installed using pip:

  ```bash
  pip install region-grower
  ```




  This package provides one main command which provides several tools.
  Two tools to generate input parameters and input distributions and another to synthesize the cells.



  Generate the TMD distribution file:

  ```bash
  region-grower generate-distributions --help
  ```



  The command ``region-grower generate-distributions`` needs the following inputs:

  * a folder containing the cells which are used to generate the parameters (see the ``input_folder`` and ``--ext`` parameters).
  * a ``dat`` file (see the ``dat_file`` parameter) with 3 columns:
  	* morphology names,
  	* any integer value (this column is not used by ``region-grower``)
  	* mtypes.
  * optionally a ``JSON`` file containing the specific parameters used for diametrization (see the ``--diametrizer-config`` parameter).



  The command ``region-grower generate-distributions`` will create the following outputs:

  * a ``JSON`` file containing the formatted distributions (see the ``--parameter-filename`` parameter).



  Generate the TMD parameter file:

  ```bash
  region-grower generate-parameters --help
  ```



  The command ``region-grower generate-parameters`` needs the following inputs:

  * a folder containing the cells which are used to generate the parameters (see the ``input_folder`` and ``--ext`` parameters).
  * a ``dat`` file (see the ``dat_file`` parameter) with 3 columns:
  	* morphology names,
  	* any integer value (this column is not used by ``region-grower``)
  	* mtypes.
  * optionally a ``JSON`` file containing the specific parameters used for diametrization (see the ``--diametrizer-config`` parameter).



  The command ``region-grower generate-parameters`` will create the following outputs:

  * a ``JSON`` file containing the formatted parameters (see the ``--parameter-filename`` parameter).



  Synthesize morphologies into an given atlas according to the given TMD parameters and distributions:

  ```bash
  region-grower synthesize-morphologies --help
  ```



  The command ``region-grower synthesize-morphologies`` needs the following inputs:

  * a ``sonata`` file containing the positions of the cells that must be synthesized.
  * a ``JSON`` file containing the parameters used to synthesize the cells (see the ``--tmd-parameters`` parameter). This file should follow the schema given in :ref:`Parameters`.
  * a ``JSON`` file containing the distributions used to synthesize the cells (see the ``--tmd-distributions`` parameter). This file should follow the schema given in :ref:`Parameters`.
  * a ``TSV`` file giving which morphology should be used for axon grafting and the optional scaling factor (see the ``--morph-axon`` parameter). The morphologies referenced in this file should exist in the directory given with the ``--base-morph-dir`` parameter.
  * a directory containing an Atlas.



  The command ``region-grower synthesize-morphologies`` will create the following outputs:

  * a ``sonata`` file containing all the positions and orientations of the synthesized cells (see ``--out-cells`` parameter).
  * a directory containing all the synthesized morphologies (see ``--out-morph-dir`` and ``--out-morph-ext`` parameters).
  * a ``YAML`` file containing the apical point positions (see ``--out-apical`` parameter).
  * a ``YAML`` file containing the Neuron IDs of the sections containing the apical points (see ``--out-apical-nrn-sections`` parameter).



  The development of this software was supported by funding to the Blue Brain Project,
  a research center of the École polytechnique fédérale de Lausanne (EPFL),
  from the Swiss government's ETH Board of the Swiss Federal Institutes of Technology.

  Copyright (c) 2022-2024 Blue Brain Project/EPFL


pkgId: acce72c0c0692d31ffe8a83c48872d3b1855459031d5d8f9c5747097076639e0
name: python-regula.documentreader.webclient-help
arch: noarch
version: 7.4.46
epoch: 0
release: 1
summary: Development documents and examples for regula.documentreader.webclient
url: https://regulaforensics.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-regula.documentreader.webclient-7.4.46-1.src.rpm
location_href: Packages/python-regula.documentreader.webclient-help-7.4.46-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/regula.documentreader.webclient?style=flat-square)](https://support.regulaforensics.com/hc/en-us/articles/115000916306-Documentation)
  [![OpenAPI](https://img.shields.io/badge/OpenAPI-defs-8c0a56?style=flat-square)](https://github.com/regulaforensics/DocumentReader-web-openapi)
  [![documentation](https://img.shields.io/badge/docs-en-f6858d?style=flat-square)](https://support.regulaforensics.com/hc/en-us/articles/115000916306-Documentation)
  [![live](https://img.shields.io/badge/live-demo-0a8c42?style=flat-square)](https://api.regulaforensics.com/)

  Documents recognition as easy as reading two bytes.

  If you have any problems with or questions about this client, please contact us
  through a [GitHub issue](https://github.com/regulaforensics/DocumentReader-web-python-client/issues).
  You are invited to contribute [new features, fixes, or updates](https://github.com/regulaforensics/DocumentReader-web-python-client/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22), large or small;
  We are always thrilled to receive pull requests, and do our best to process them as fast as we can.
  See [dev guide](./dev.md)


  `regula.documentreader.webclient` is on the Python Package Index (PyPI):

  ```bash
  pip install regula.documentreader.webclient
  ```

  Or using `pipenv`
  ```bash
  pipenv install regula.documentreader.webclient
  ```


  Performing request:
  ```python
  from regula.documentreader.webclient import *

  with open("australia_passport.jpg", "rb") as f:
      input_image = f.read()

  with DocumentReaderApi(host='http://localhost:8080') as api:
      params = ProcessParams(
          scenario=Scenario.FULL_PROCESS,
          result_type_output=[Result.DOCUMENT_IMAGE, Result.STATUS, Result.TEXT, Result.IMAGES]
      )
      request = RecognitionRequest(process_params=params, images=[input_image])
      response = api.process(request)
  ```

  Parsing results:
  ```python

  response_status = response.status
  doc_overall_status = "valid" if response_status.overall_status == CheckResult.OK else "not valid"


  doc_number_field = response.text.get_field(TextFieldType.DOCUMENT_NUMBER)
  doc_number_mrz = doc_number_field.get_value()
  doc_number_visual = doc_number_field.get_value(Source.VISUAL)
  doc_number_visual_validity = doc_number_field.source_validity(Source.VISUAL)
  doc_number_mrz_validity = doc_number_field.source_validity(Source.MRZ)
  doc_number_mrz_visual_matching = doc_number_field.cross_source_comparison(Source.MRZ, Source.VISUAL)


  normalized_input_image = response.images.document_image()
  portrait_field = response.images.get_field(GraphicFieldType.PORTRAIT)
  portrait_from_visual = portrait_field.get_value(Source.VISUAL)
  portrait_from_rfid = portrait_field.get_value(Source.RFID, original=True)
  ```
  You can find more detailed guide and run this sample in [example](./example) folder.


pkgId: 164dfaa76dd8b9f51b68ad448b18e03cce7694efde9e05bad43dcab8ef08d2aa
name: python-regula.facesdk.webclient-help
arch: noarch
version: 6.4.107
epoch: 0
release: 1
summary: Development documents and examples for regula.facesdk.webclient
url: https://regulaforensics.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-regula.facesdk.webclient-6.4.107-1.src.rpm
location_href: Packages/python-regula.facesdk.webclient-help-6.4.107-1.noarch.rpm
checksum_type: sha256
description:
  [![OpenAPI](https://img.shields.io/badge/OpenAPI-defs-8c0a56?style=flat-square)](https://github.com/regulaforensics/FaceSDK-web-openapi)
  [![documentation](https://img.shields.io/badge/docs-en-f6858d?style=flat-square)](https://support.regulaforensics.com/hc/en-us/articles/115000916306-Documentation)
  [![live](https://img.shields.io/badge/live-demo-0a8c42?style=flat-square)](https://faceapi.regulaforensics.com/)

  Face recognition as easy as reading two bytes.

  If you have any problems with or questions about this client, please contact us
  through a [GitHub issue](https://github.com/regulaforensics/FaceSDK-web-python-client/issues).
  You are invited to contribute [new features, fixes, or updates](https://github.com/regulaforensics/FaceSDK-web-python-client/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22), large or small;
  We are always thrilled to receive pull requests, and do our best to process them as fast as we can.
  See [dev guide](./dev.md)


  `regula.facesdk.webclient` is on the Python Package Index (PyPI):

  ```bash
  pip install regula.facesdk.webclient
  ```

  Or using `pipenv`
  ```bash
  pipenv install regula.facesdk.webclient
  ```


  Performing request:

  ```python
  from regula.facesdk.webclient import *

  with open("face1.jpg", "rb") as f:
      face_1_bytes = f.read()

  with open("face2.jpg", "rb") as f:
      face_2_bytes = f.read()

  with MatchingApi(host="http://0.0.0.0:41101/api") as api:
      images = [
          MatchImage(index=1, data=face_1_bytes, type=ImageSource.LIVE),
          MatchImage(index=2, data=face_1_bytes, type=ImageSource.DOCUMENT_RFID),
          MatchImage(index=3, data=face_2_bytes)
      ]
      match_request = MatchRequest(images=images)
      match_response = api.match(match_request)

      detect_request = DetectRequest(face_1_bytes)
      detect_response = api.detect(detect_request)
  ```

  You can find more detailed guide and run this sample in [example](./example) folder.


pkgId: 95180fa4bbd9702319da1ced7cf73da05fb08c00df88c53f181048bf5dfff9ba
name: python-reinforcement-learning-framework-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for reinforcement-learning-framework
url: https://github.com/alexander-zap/reinforcement-learning-framework
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reinforcement-learning-framework-0.6.1-1.src.rpm
location_href: Packages/python-reinforcement-learning-framework-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  An easy-to-read Reinforcement Learning (RL) framework. Provides standardized interfaces and implementations to various Reinforcement Learning methods and environments. Also this is the main place to start your journey with Reinforcement Learning and learn from tutorials and examples.



  - Choose from a growing number of **Gym environments** and **MLAgent environments**
  - Using various Reinforcement Learning algorithms for learning, which are implemented in **Stable-Baselines 3**
  - Integrate or implement own **custom environments and agents** in a standardized interface
  - Upload your models to the **HuggingFace Hub**





  If you are on a UNIX-based OS:
  You are fine. Continue with the next step.

  If you are on Windows:
  Make sure to use a WSL Python interpreter as your development environment, since we require a UNIX-based system underneath Python to run a lot of the environments and algorithms.
  For users using PyCharm, see https://www.jetbrains.com/help/pycharm/using-wsl-as-a-remote-interpreter.html for more information.
  For users using Visual Studio Code, see https://code.visualstudio.com/docs/remote/wsl-tutorial and https://code.visualstudio.com/docs/remote/wsl for more information.



  To set up your local development environment, please run:

  ```
  poetry install
  ```

  Behind the scenes, this creates a virtual environment and installs `rl_framework` along with its dependencies into a new virtualenv. Whenever you run `poetry run <command>`, that `<command>` is actually run inside the virtualenv managed by poetry.

  You can now import functions and classes from the module with `import rl_framework`.



  The creation of videos for the functionality of creating video-replays of the agent performance on the environment requires installing the FFMPEG package on your machine.
  This feature is important if you plan to upload replay videos to an experiment tracking service together with the agent itself.
  The `ffmpeg` command needs to be available to invoke from the command line, since it is called from Python through a `os.system` invoke. Therefore, it is important that you install this package directly on your machine.

  Please follow the guide which can be found [here](https://www.geeksforgeeks.org/how-to-install-ffmpeg-on-windows/) to install the FFMPEG library on your respective machine.



  - Create an account to HuggingFace and sign in. ➡ https://huggingface.co/join
  - Create a new token with write role. ➡ https://huggingface.co/settings/tokens
  - Store your authentication token from the Hugging Face website. ➡ `huggingface-cli login`



  In order to use environments based on the Unity game framework, make sure to follow the installation procedures detailed in [following installation guideline provided by Unity Technologies](https://github.com/Unity-Technologies/ml-agents/blob/develop/docs/Installation.md).
  In short:

  - Install Unity. ➡ https://unity.com/download
  - Create a new Unity project.
  - Navigate to the menu `Window -> Package Manager` and install the `com.unity.ml-agents` package in Unity. ➡ https://docs.unity3d.com/Manual/upm-ui-install.html





  To integrate your environment you wish to train on, you need to create an Environment class representing your problem. For this you can

  - you use an existing Gym environment with [the `GymEnvironment` class](src/rl_framework/environment/gym_environment.py)
  - you use an existing MLAgent environment with [the `MLAgentsEnvironment` class](src/rl_framework/environment/mlagents_environment.py)
  - create a custom environment by inheriting from [the base `Environment` class](src/rl_framework/environment/base_environment.py), which specifies the required interface



  To integrate the Reinforcement Learning algorithm you wish to train an agent on your environment with, you need to create an Agent class representing your training agent. For this you can

  - you use an existing Reinforcement Learning algorithm implemented in the Stable-Baselines 3 framework with [the `StableBaselinesAgent` class](src/rl_framework/agent/stable_baselines.py) (see the Example section below)
  - create a custom Reinforcement Learning algorithm by inheriting from [the base `BaseAgent` class](src/rl_framework/agent/base_agent.py), which specifies the required interface



  After configuring the environment and the agent, you can start training your agent on the environment.
  This can be done in one line of code:

  ```
  agent.train(environments=environments, total_timesteps=100000)
  ```

  Independent of which environment and which agent you choose, the unified interface allows to always start the training this way.



  Once you trained the agent, you can evaluate the agent policy on the environment and get the average accumulated reward (and standard deviation) as evaluation metric.
  This evaluation method is implemented in the [evaluate function of the agent](src/rl_framework/agent/base_agent.py) and called with one line of code:

  ```
  agent.evaluate(evaluation_environment=environment, n_eval_episodes=100, deterministic=False)
  ```



  Once you trained the agent, you can upload the agent model to the HuggingFace Hub in order to share and compare your agent to others. You can also downloaded yours or other agents from the same HuggingFace Hub and use them for solving environments or re-training.
  The object which allows for this functionality is `HuggingFaceConnector`, which can be found in the [connection collection package](src/rl_framework/util/saving_and_loading/connector).



  In [this example script](exploration/train_sb3_agent.py) you can see all of the above steps unified.

  For a quick impression in this README, find a minimal training and evaluation example here:

  ```

  environments = [GymEnvironmentWrapper(ENV_ID) for _ in range(PARALLEL_ENVIRONMENTS)]


  agent = StableBaselinesAgent(
      algorithm=StableBaselinesAlgorithm.PPO,
      algorithm_parameters={
          "policy": "MlpPolicy"
      }
  )

  agent.train(environments=environments, total_timesteps=100000)


  mean_reward, std_reward = agent.evaluate(evaluation_environment=environments[0])
  ```





  You can use your module code (`src/`) in Jupyter notebooks without running into import errors by running:

  ```
  poetry run jupyter notebook
  ```

  or

  ```
  poetry run jupyter-lab
  ```

  This starts the jupyter server inside the project's virtualenv.

  Assuming you already have Jupyter installed, you can make your virtual environment available as a separate kernel by running:

  ```
  poetry add ipykernel
  poetry run python -m ipykernel install --user --name="reinforcement-learning-framework"
  ```

  Note that we mainly use notebooks for experiments, visualizations and reports. Every piece of functionality that is meant to be reused should go into module code and be imported into notebooks.



  We use `pytest` as test framework. To execute the tests, please run

  ```
  pytest tests
  ```

  To run the tests with coverage information, please use

  ```
  pytest tests --cov=src --cov-report=html --cov-report=term
  ```

  and have a look at the `htmlcov` folder, after the tests are done.



  To build a distribution package (wheel), please use

  ```
  python setup.py bdist_wheel
  ```

  this will clean up the build folder and then run the `bdist_wheel` command.



  Before contributing, please set up the pre-commit hooks to reduce errors and ensure consistency

  ```
  pip install -U pre-commit
  pre-commit install
  ```

  If you run into any issues, you can remove the hooks again with `pre-commit uninstall`.



  © Alexander Zap


pkgId: 2546bb41f6bff1570fb03cd282b8e8b0b2951f1ec300b1317b7738f4586033e6
name: python-relap-py
arch: noarch
version: 0.0.36
epoch: 0
release: 1
summary: Module for RELAP post-processing
url: https://pypi.org/project/relap-py/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-relap-py-0.0.36-1.src.rpm
location_href: Packages/python-relap-py-0.0.36-1.noarch.rpm
checksum_type: sha256
description:
  * Title: RELAP utilities
  * created: May 2020
  * last modified: 2024-12-17
  * Created by: Jordi Freixa
  * Description: This Module provides function tools for postprocessing RELAP data



  * install with pip install relap_py
  * make a new system environmental variable called `RELAP_EXE_PATH` that contains
  the path to your relap executable.



  Use the following functions to set up the configuration of the module for the particular python project:

  * set_figures_type('pdf') the figures will be saved with this format
  * set_figures_loc('./figures/') location where the figures will be saved
  * set_show_plot(False) Boolean, show interactive python plot window?
  * set_unc_bands(False) is there a uncertainty file containing bands? set the name here and bands will be added to the variables plot
  * set_relap_scdap(False) Are you using the package for Relap/scdap cases?




  - [ ] Adapt to TRACE plotting (basically reading data from csv files)
  - [ ] Read and plot uncertainty bands
  - [ ] profile plot



  * Title: relap.py tutorial
  * Version: 2.0
  * Date: 2024-12-17
  * Created by: Jordi Freixa
  * Description: A quick tutorial for relap.py package

  Firstly import the package, for instance

  ```
  import relap_py as rp
  ```

  You may use the help function of Python to get info on the possible functions

  ```
  help(rp) # to get info on the whole package
  help(rp.plot_var) # to get info on one specific function
  ```



  List of defaults. If you want to change them, you can do so by using the
  following commands

  ```
  rp.set_figures_type('pdf')
  rp.set_figures_loc('./my_best_figures/')
  rp.set_show_plot(True)
  rp.set_unc_bands('unc.dat')
  rp.set_relap_scdap(True)
  ```



  It is good to write a file to specify a list of variables that you want to extract.
  The structure is as follows:

  ```
  alphanum   numeric     star   experiment_tag   figure_tag                    unit   timei   timee   ymin   ymax   general
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  mflowj     933020000   *      SGTR_MF          SGTR_Break_Mass_Flow          kg/s   -100    3500    0      0      no
  mflowj     545000000   *      REL_VLV_MF       Reliev_Valve_Flow_A           kg/s   -100    3500    0      0      mid_left
  ```

  * `experiment_tag` This is the tag of the variable used to plot it. If you you use experimental data, you should use the same names for the variables.
  * `figure_tag` will be used in the plots for the title, labels or legends. (the underscores will be removed automatically)
  * `temei` will be used as initial time for plots
  * `timee` will be used as the end time
  * `ymin` and `ymax` will be the limits in the plot, 0 means automatic
  * `general` indicates if you want to plot this in the general figure and in which position:
      * `no` it will not be added
      * `top_left` added to the top plot with the left y-axis
      * `top_right` added to the top plot with the right y-axis
      * `mid_left`
      * `mid_right`
      * `bottom_left`
      * `bottom_right`



  The package works best when you adapt to the following structure when you
  perform several calculations of the same scenario/case

  * Place each calculation in a different folder
  * In each folder, always use the same restart name

  ```
  ├── Test4
  │   ├── base
  │   │   ├── test4.i
  │   │   ├── test4.o
  │   │   ├── test4.r
  │   ├── no_hpis
  │   │   ├── test4.i
  │   │   ├── test4.o
  │   │   ├── test4.r
  │   ├── rcp_earlier
  │   │   ├── test4.i
  │   │   ├── test4.o
  │   │   ├── test4.r
  │   ├── figures
  │   ├── variables_test4.txt
  ```

  I find this approach very convenient as it is very easy to generate new
  sensitivities and it is clearly structured. It is also very easy to automatize a
  loop to run several cases at once as the commands will be the same for all folders.





  ```
  rp.set_show_plot(True) # Most probably you want to play with the plot
  rp.plot('voidfj', '993020000', 'your_restart')
  ```

  > [!NOTE]
  >
  > remember that for more info, `help(rp.plot)`



  In this case you plot more than one variable and you want to store the data in
  a variable. In this example the data of two cases is extracted and stored in `voidfj`
  the figure will be stored in pdf format but you can still play with the interactive plot

  ```
  rp.set_show_plot(True) # Most probably you want to play with the plot
  voidfj = rp.plot('voidfj', '993020000', 'test4', ['base', 'no_hpis'], 'pdf')

  rp.set_show_plot(False) # I want to hide other plots created later
  ```



  > [!NOTE]
  >
  >  You will need to first create the variables file, in this example `variables_test4.txt`

  With the following command the time trends specified in `variables_test4` will
  be extracted from restart file `test4.r` which should be in the folder
  you are running the command

  ```
  data, variables = rp.extract_data('variables_test4.txt', 'test4')
  ```

  Once you have loaded the variable files you can change its contents if you need. For instance to change the final time for all

  ```
  variables['timee'] = 4000.0 #
  ```

  Once you have loaded the variable files you can use it to extract other data:

  ```
  data, _ = rp.extract_data(variables, 'test4')
  ```





  > [!NOTE]
  >
  >  first declare the list of cases, it can be a single case or even empty and then it will read the restart in the folder


  ```
  cases_sgtr = ['base', 'no_hpis', 'rcp_earlier']
  cases_df_sgtr, variables = rp.extract_data('variables_test4.txt', 'test4', cases_sgtr )
  ```

  Once you have loaded the variable files you can change its contents if you need. For instance to change the final time for all

  ```
  variables['timee'] = 4000.0 #
  ```
  > [!TIP]
  > At this point you can do data manipulation if needed. For instance, to correct the time for all cases

  ```
  for i, item in enumerate(cases_sgtr):
      cases_df_sgtr[item]['time'] = cases_df_sgtr[item]['time'] - 4900
  ```
  > [!TIP]
  > If you are not repeating the calculations, and you already extracted the data, you might want to load the data directly from the created .dat files. In this case you can load them with numpy and then put them together:

  ```
  base = np.genfromtxt('base/test4.dat', delimiter=',',names= True)
  no_hpis = np.genfromtxt('no_hpis/test4.dat', delimiter=',',names= True)
  rcp_earlier = np.genfromtxt('rcp_earlier/test4.dat', delimiter=',',names= True)
  cases_df_sgtr = {'base': base,
                   'no_hpis': no_hpis,
                   'rcp_earlier': rcp_earlier}
  ```



  in this example only 'base' and 'rcp_earlier' will be plotted

  ```
  rp.plot_var('SGTR_MF', variables, cases_df_sgtr, ['base', 'rcp_earlier'] )
  ```



  This one could be eliminated because it simply does a for loop
  over each variable and runs rp.plot_var

  ```
  rp.plot_all(variables, cases_df_sgtr, cases_sgtr)
  ```



  ```
  vars_to_plot = ['core_level', 'SG_A_level']
  rp.plot_variables(vars_to_plot, variables, cases_df_sgtr['base'])
  ```



  A general figure is a figure with three subfigures (top, mid and bottom) each figure
  may contain more than one time trend and you may use right or left Y-axes

  This figure is useful to generate a figure to explain the whole transient.

  ```
  rp.general_fig(variables, cases_df_sgtr['base'])
  ```

  Labels to each time trend are placed automatically, sometimes they are not placed
  in the best location and you may want to adjust them. When you run the command above
  you will see that a list of numbers is shown, this list is the locations of each label
  ordered from top to bottom. You can copy the list, modify it and provide it as an input
  for the command so you can manually set the locations of the labels
      (see `help(rp.general_fig)`for further details)



      first calculate whatever new variable you want to do.
      In this case I want to get the sgtr flow minus the HPIS flow
  ```
  for elements in cases_df_sgtr:
      new = cases_df_sgtr[elements]['core_level']
      for i in range(0, len(new)):
          new[i] = cases_df_sgtr[elements]['SGTR_MF'][i] - cases_df_sgtr[elements]['HPSI_A'][i]
      
      cases_df_sgtr[elements] = append_fields(cases_df_sgtr[elements], 'new_var', new , np.double)
  ```

  > [!TIP]
  >
  > Additionally we may want to add one line to the variables dataframe

  ```
  variables = rp.append_variable(variables, 'new_var', 'kg/s', 'mid_right')
  ```

  > [!TIP]
  >
  > If I want to remove a variable from the general figure I can select it like this

  ```
  variables.loc[23, 'general'] = 'no' # to change a single option
  ```


  The general figure does not compare cases. If you want to generate one general figure
  for each of your cases, you should do the following.

  ```
  for i, item in enumerate(cases_sgtr):
      rp.general_fig(variables, cases_df_sgtr[item])
      try : os.remove(rp.figures_loc + cases_sgtr[i] + '.pdf')
      except : pass
      os.rename(rp.figures_loc + 'general.pdf', rp.figures_loc + cases_sgtr[i] + '.pdf')
  ```



  If you have already generated .dat files and you just want to load them,
  you can do so as follows:

  ```
  new_case = np.genfromtxt('path/to/data.dat', delimiter=',',names= True)
  ```

  The problem now is that you will need to load the variables file if you want
  to do run some of the functions of the package. You can do so by:

  ```
  variables = rp.read_variables('path/to/variables.i')
  ```



  * make_strip --> make a strip
  * read_variables --> just reads a file that lists all variables
  * read_stripf --> reads a stripf file
  * run_strip --> performs a strip
  * mypie --> makes a fancy pie chart
  * read_exp --> reads a experiment data file
  * print_ss --> Makes a table with the steady state data (in development)


pkgId: 42b08ca88bf57ac7f7708c7e099a13aebbb2041b360bdb247064d9dbee130729
name: python-relationalai-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for relationalai
url: https://pypi.org/project/relationalai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-relationalai-0.7.0-1.src.rpm
location_href: Packages/python-relationalai-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  The Python library for building and querying knowledge graphs with RelationalAI.

  For more information, visit our documentation at [https://relational.ai/docs](https://relational.ai/docs).


pkgId: 33de00c1f5b437cdf88216f15183a2255c64cec8d5e100de0fd6f42c696a6934
name: python-relatorio-help
arch: noarch
version: 0.11.1
epoch: 0
release: 1
summary: Development documents and examples for relatorio
url: https://pypi.python.org/pypi/relatorio
rpm_license: GPL License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-relatorio-0.11.1-1.src.rpm
location_href: Packages/python-relatorio-help-0.11.1-1.noarch.rpm
checksum_type: sha256
description:
  Relatorio


  Relatorio is a templating library which provides a way to easily generate
  various kinds of documents (odt, ods, png, svg, ...) from a template.
  Support for more filetypes can be added by creating plugins for them.

  Relatorio also provides a report repository allowing you to link python objects
  and reports together, and find reports by mimetype/name/python object.


pkgId: 08710c47003a40afcc6eefb071f974353634e9b471b6baa0d0b12b633f1970b2
name: python-relevanceai-help
arch: noarch
version: 10.1.2
epoch: 0
release: 1
summary: Development documents and examples for relevanceai
url: https://relevanceai.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-relevanceai-10.1.2-1.src.rpm
location_href: Packages/python-relevanceai-help-10.1.2-1.noarch.rpm
checksum_type: sha256
description:
  🔥 Use Relevance to build AI agents for your AI workforce

  [Sign up for a free account ->](https://app.relevanceai.com)



  | Type      | Link |
  | ------------- | ----------- |
  | Home Page | [Home Page](https://relevanceai.com/) |
  | Platform | [Platform](https://app.relevanceai.com/) |
  | Developer Documentation | [Documentation](https://sdk.relevanceai.com/) |



  Welcome to the Relevance AI SDK! This guide will help you set up and start using the SDK to interact with your AI agents, tools, and knowledge.



  To get started, you'll need to install the RelevanceAI library in a Python 3 environment. Run the following command in your terminal:

  ```bash
  pip install relevanceai
  ```



  Before using the SDK, ensure you have an account with Relevance AI.

  1. Sign up for a free account at [Relevance AI](https://app.relevanceai.com) and log in.
  2. Create a new secret key at [SDK Login](https://app.relevanceai.com/login/sdk). Scroll to the bottom of the integrations page, click on "+ Create new secret key," and select "Admin" permissions.



  To interact with Relevance AI, you'll need to set up a client. Start by importing the library:

  ```python
  from relevanceai import RelevanceAI
  client = RelevanceAI()
  ```



  You can validate your client credentials by storing them as environment variables and loading them into your project using `python-dotenv` or the `os` library:

  ```env
  RAI_API_KEY=
  RAI_REGION=
  RAI_PROJECT=
  ```

  ```python
  from dotenv import load_dotenv
  load_dotenv()

  from relevanceai import RelevanceAI
  client = RelevanceAI()
  ```

  Alternatively, pass the credentials directly to the client:

  ```python
  from relevanceai import RelevanceAI
  client = RelevanceAI(
      api_key="your_api_key",
      region="your_region",
      project="your_project"
  )
  ```

  You are now ready to start using Relevance AI via the Python SDK.





  List all the agents in your project:

  ```python
  from relevanceai import RelevanceAI
  client = RelevanceAI()

  my_agents = client.agents.list_agents()
  print(my_agents)
  ```

  Retrieve and interact with a specific agent:

  ```python
  my_agent = client.agents.retrieve_agent(agent_id="xxxxxxxx")

  message = "Let's qualify this lead:\n\nName: Ethan Trang\n\nCompany: Relevance AI\n\nEmail: ethan@relevanceai.com"

  triggered_task = client.tasks.trigger_task(
      agent_id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      message=message
  )
  print(triggered_task)
  ```



  List all the tools in your project:

  ```python
  my_tools = client.tools.list_tools()
  print(my_tools)
  ```

  Retrieve and interact with a specific tool:

  ```python
  my_tool = client.tools.retrieve_tool(tool_id="xxxxxxxx")

  params = {"text": "This is text", "number": 245}

  tool_response = client.tools.trigger_tool(
      tool_id="xxxxxxxx",
      params=params
  )
  print(tool_response)
  ```



  Explore all the methods available for agents, tasks, tools, and knowledge with the [documentation](https://sdk.relevanceai.com/)


pkgId: a8ac0c8b238f01c2881cf5064352c7faa51fb57a6b7fb132fcc3ee4503d13523
name: python-remote-compression-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for remote-compression
url: https://github.com/balouf/remote-compression
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-remote-compression-0.1.3-1.src.rpm
location_href: Packages/python-remote-compression-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI Status](https://img.shields.io/pypi/v/remote-compression.svg)](https://pypi.python.org/pypi/remote-compression)
  [![Build Status](https://github.com/balouf/remote-compression/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/balouf/remote-compression/actions?query=workflow%3Abuild)
  [![Documentation Status](https://github.com/balouf/remote-compression/actions/workflows/docs.yml/badge.svg?branch=main)](https://github.com/balouf/remote-compression/actions?query=workflow%3Adocs)
  [![License](https://img.shields.io/github/license/balouf/remote-compression)](https://github.com/balouf/remote-compression/blob/main/LICENSE)
  [![Code Coverage](https://codecov.io/gh/balouf/remote-compression/branch/main/graphs/badge.svg)](https://codecov.io/gh/balouf/remote-compression/tree/main)

  rcomp helps to perform x265 video compression on remote server.


  - Free software: MIT license
  - Documentation: https://balouf.github.io/remote-compression/.




  - `ffprobe` must be in the path of the local machine
  - `ffmpeg` must be in the path of the remote server
  - `.ssh/config` must enable direct connection to remote server
    - private key
    - proxyjump if required



  `$ rcomp --help`



  This package was created with [Cookiecutter][CC] and the [Package Helper 3][PH3] project template.

  [CC]: https://github.com/audreyr/cookiecutter
  [PH3]: https://balouf.github.io/package-helper-3/


pkgId: d0e966789e984054961033145c4865543f325d969290556fa002be44092cc55b
name: python-remote-graphcast-runpod-help
arch: noarch
version: 0.0.21
epoch: 0
release: 1
summary: Development documents and examples for remote-graphcast-runpod
url: https://github.com/CisgenX/remote-graphcast.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-remote-graphcast-runpod-0.0.21-1.src.rpm
location_href: Packages/python-remote-graphcast-runpod-help-0.0.21-1.noarch.rpm
checksum_type: sha256
description:
  Run [graphcast](https://github.com/google-deepmind/graphcast) on a [runpod](https://runpod.io/) GPU server. Output is saved to [s3](https://aws.amazon.com/pm/serv-s3/). Shouldn't cost more than $0.6 USD for a 10 day forcast.



  1. Your input is validated
  2. A secure runpod GPU pod is spun up on your runpod account
  3. Graphcast is installed into that gpu and forecasts of your chosen length are generated for each timestamp, this takes around 10 minutes for a 10 day forcast
  4. These forecasts are saved to your chosen s3 bucket, roughly **6.5GB for 10 days** of forecast
  5. The runpod pod is terminated
  6. The program exits



  - python 3.8+ and pip
  - [cds.climate](https://cds.climate.copernicus.eu/api-how-to) credentials
  - an [AWS](https://aws.amazon.com/console/) s3 bucket, free tier should be fine
  - S3 credentials to go with the bucket
  - [Runpod](https://www.runpod.io/) credentials



  `pip install remote-graphcast`



  ```python

  from remote_graphcast import remote_cast

  remote_cast(
  	aws_access_key_id='YOUR_AWS_ACCESS_KEY_ID',
  	aws_secret_access_key='YOUR_AWS_SECRET_ACCESS_KEY',
  	aws_bucket='YOUR_AWS_BUCKET_NAME',
  	cds_url='https://cds.climate.copernicus.eu/api/v2', # this is probably your CDS URL
  	cds_key='YOUR_CDS_KEY',
  	forcast_list="[{'start': '2023122518', 'hours_to_forcast': 48}]",
  	
  	
  	runpod_key='YOUR_RUNPOD_KEY',
  	gpu_type_id="NVIDIA A100-SXM4-80GB", # graphcast needs at least 61GB GPU ram (unless you want to quantize)
  	container_disk_in_gb=50, # you'll need around 40GB per 10 day forcast + a healthy 10GB buffer
  )




  ```



  In order to make predictions graphcast must request ERA5 reanalysis data from the European Center for Medium Range Weather Forcasts (ECMWF). Usually the download completes in < 2 minutes. However, if their servers are busy your request will be [put in a queue](https://confluence.ecmwf.int/display/UDOC/My+request+is+queued+for+a+long+time+-+Web+API+FAQ). You can view all your open requests [here](https://cds.climate.copernicus.eu/cdsapp#!/yourrequests). Until your request is granted is granted, the graphcast runpod server will be waiting idly (costing you money). This process has taken me > 1 hour in the past.

  You can also check your progress by viewing the runpod logs.


pkgId: 23a4778e19aaa41efe7ccde7d592a5147a05a35cbcc80b4085596bff608cc886
name: python-remote-inria-help
arch: noarch
version: 1.7.3
epoch: 0
release: 1
summary: Development documents and examples for remote-inria
url: https://pypi.org/project/remote-inria/
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-remote-inria-1.7.3-1.src.rpm
location_href: Packages/python-remote-inria-help-1.7.3-1.noarch.rpm
checksum_type: sha256
description:
  **Rem**ote **I**nria\
  Code here, run there !

  _A CLI tool for remotely interacting with Inria computing resources._




  remi is a tool aiming at easing the workflow of Inria researchers when it comes to performing
  computations remotely.
  More precisely, **remi** is configured for each project you might want to
  use it for.\
  Once your preferences are set, you can run your code either on your desktop at Inria or on one the
  cluster nodes.

  If you are tired of messing up with 4-line `oarsub` commands or if you find yourself `commit`ting
  and `push`ing your code each time you want to test it remotely, this tool is for you !

  **Note:** Even though this tool has been made to work from a personal computer different from your
  Inria desktop, it also totally works when running directly from the Inria desktop.\
  Most of the `remi` features are still relevant in this case.

  **Presentation / tutorial video:**\
  https://odysee.com/@GaetanLepage:6/remote-inria:6



  - **Synchronization:** **remi** creates a remote clone of your project on the Inria storage space
    (under `\scratch`) and lets you synchronize it easily.
  - **Remote execution:** The core idea behind **remi** is to provide an easy way to execute code on
    remote computers (regular Inria desktops or cluster servers).
  - **Clusters and singularity support:** The _complex_ way to request computing resources is
    integrated in **remi** to minimize overhead. Singularity container management is also embedded
    (build and use).

  - **Jupyter notebook support:** This tool lets you run a jupyter notebook server on your Inria
    workstation and connect to it locally on the browser.




  Any help to the improvement of **remi** is more than welcome.\
  You may write an issue to warn me of any bug or desired feature by [writing an
  issue](https://gitlab.inria.fr/remote-inria/remi/-/issues/new).




  This project was inspired from [LabML Remote](https://github.com/lab-ml/remote).\
  The latter does not support `ssh` through a bastion because it uses the
  [paramiko](https://www.paramiko.org/) library. RemI, on the other hand, uses traditional calls to
  `ssh` command.\
  The main motivation to start a separate project was to design a tool specifically with the Inria
  computing needs in mind (use of Inria clusters, natively using the available resources etc).


pkgId: ccd5e5e1fe29d0d4b442de33de0660cac0678685e41babec25a14962cb599d30
name: python-remote-job-app-help
arch: noarch
version: 0.1.12
epoch: 0
release: 1
summary: Development documents and examples for remote-job-app
url: https://pypi.org/project/remote-job-app/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-remote-job-app-0.1.12-1.src.rpm
location_href: Packages/python-remote-job-app-help-0.1.12-1.noarch.rpm
checksum_type: sha256
description:
  Provides a best-practices approach to help quickly integrate existing remote services with the Strangeworks platform.


pkgId: e4ce9040830c9fcce7d98eb9b48fd7b260431acc5ea22886c189ee4a634d1d20
name: python-remotemanager-help
arch: noarch
version: 0.13.1
epoch: 0
release: 1
summary: Development documents and examples for remotemanager
url: https://gitlab.com/l_sim/remotemanager/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-remotemanager-0.13.1-1.src.rpm
location_href: Packages/python-remotemanager-help-0.13.1-1.noarch.rpm
checksum_type: sha256
description:
  Modular serialisation and management package for handling the running of functions on remote machines

  Based off of the BigDFT RemoteRunner concept, remotemanager represents an improvement and expansion on the concepts based there.

  Primary usage is via a `Dataset`, which connects to a remote machine via `URL`

  You can think of the `Dataset` as a "container" of sorts for a calculation, to which "runs" are attached. These runs are then executed on the remote machine described by the provided `URL`



  A quick install of the latest stable release can be done via `pip install remotemanager`

  For development, you can clone this repo and install via `cd remotemanager && pip install -e .[dev]`

  Tip: You can clone a specific branch with `git clone -b devel`.

  If you want to build the docs locally a `pandoc` install is required.

  You can install all required python packages with the `[dev]` or `[docs]` optionals.



  Remotemanager exists to facilitate running on High Performance Compute machines (supercomputers). Script generation is ideally done via the `BaseComputer` module.

  Existing Computers can be found at [this repository](https://gitlab.com/l_sim/remotemanager-computers). For creating a new machine class, see the [documentation](https://l_sim.gitlab.io/remotemanager/).



  See the [documentation](https://l_sim.gitlab.io/remotemanager/) for further information, tutorials and api documentation.



  This section will run through running a very basic function on a machine.

  It roughly echoes the [quickstart](https://l_sim.gitlab.io/remotemanager/tutorials/A1_Quickstart.html) page found in the
  docs.



  Start by defining your "calculation" as a python function.

  ```python
  def multiply(a, b):
      import time

      time.sleep(1)

      return a * b
  ```



  We need to be able to connect to a remote machine to run this function.

  Assuming you can connect to a machine with a string like `ssh user@host` or just `ssh machine`, you can directly create
  a connection.

  Use the `URL` module for this.

  ```python
  from remotemanager import URL

  connection = URL("ssh@machine")
  ```



  You can execute commands on this machine using the `cmd` method:

  ```python
  connection.cmd("pwd")
  >> > "/home/user"
  ```



  To execute your function on the specified machine, create a `Dataset`

  ```python
  from remotemanager import Dataset

  ds = Dataset(function=multiply, url=connection, name="test")
  ```



  You can specify the inputs that your function should use by adding `Runner` instances to the `Dataset`

  ```python
  ds.append_run({"a": 10, "b": 7})
  ```



  Now run your `Dataset` with `run()`.

  You can wait for completion with `wait()`

  ```python
  ds.run()

  ds.wait(1, 10)
  ```

  Here, we are waiting for a maximum of 10s, and checking for results every 1s



  Result collection is done in two stages.

  Once a run is complete, we must first fetch the results with `fetch_results`.

  Then we can access the results at the `results` property

  ```python
  ds.fetch_results()

  ds.results

  >> > [70]
  ```



  The `sanzu` functionality allows you to tag a jupyter cell for remote running.

  The cell will be converted into a function, set off to the specified remote machine, and executed there.

  For detailed information, see the
  relevant [section of the docs](https://l_sim.gitlab.io/remotemanager/tutorials/D2_Jupyter_Magic.html)

  To use this functionality, first enable the magic:

  ```python
  %load_ext
  remotemanager
  ```

  You should then create a `URL` instance for your machine:

  ```python
  from remotemanager import URL

  connection = URL(...)
  ```

  And now we can execute any cell on this machine by using the `%sanzu` protocol:

  ```python
  %sanzu
  url = connection
  %sargs
  a = 10
  %sargs
  b = 7

  a * b

  >> > 70
  ```

  This can be useful for doing file operations on the remote machine, however it is possible to access your results.



  A sanzu run will inject a `magic_dataset` object into the jupyter runtime.

  This is the `Dataset` that was used to execute the most recent cell, so you can access the information from there.

  For our last run, we can see our results here:

  ```python
  print(magic_dataset.results)

  >> > [70]
  ```


pkgId: 0ba486995f17d8e3e43180c0e3a1d7a8517ae2432b0ae13a95b1ca744a2b0d67
name: python-render-engine-theme-kjaymiller-help
arch: noarch
version: 2024.12.2
epoch: 0
release: 1
summary: Development documents and examples for render-engine-theme-kjaymiller
url: https://pypi.org/project/render-engine-theme-kjaymiller/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-render-engine-theme-kjaymiller-2024.12.2-1.src.rpm
location_href: Packages/python-render-engine-theme-kjaymiller-help-2024.12.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Github Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2Fkjaymiller%2Frender_engine_theme_kjaymiller%2Fbadge%3Fref%3Dmain&style=flat-square)](https://actions-badge.atrox.dev/kjaymiller/render_engine_theme_kjaymiller/goto?ref=main)

  This is a theme based on the early development of render-engine for kjaymiller.com.

  It relies on Tailwind CSS with support for icons via fontawesome and embeds for analytics, and newsletters.



  1. Install this theme through pip:

  ```bash
  pip install render-engine-theme-kjaymiller
  ```

  2. Import and register your theme:

  ```python
  from render_engine import Site
  from render_engine_theme_kjaymiller import kjaymiller

  app = Site()
  app.register_themes(kjaymiller)
  ```

  3. Add configuration file

  This theme supports styling through [TailwindCSS](https://tailwindcss.com/). To add your own configuration, create a `tailwind.config.js` file in your project root and add your configuration there. You will need the following information in your config:

  ```js
  // tailwind.config.js
  /** @type {import('tailwindcss').Config} */
  module.exports = {
    content: ['output/**/*.{html, js}'],
    plugins: [require('@tailwindcss/typography')]
  }
  ```

  4. Add your theme settings

  This theme supports embeds for many different tools as well as configurations for your tailwindcss settings in your `app.py` module. Here is a basic example of what your site's theme settings might look like:

  ```python

  app = Site()

  settings = {
      "NAVIGATION": {...} ,
      ... # settings for other plugins and your site
      "theme" : {
        ... # Your theme settings
          "colors": {
            "main1": "rose-800", # You can use any valid tailwindcss color here
          }
          "favicon": "https:fav.farm/☕", # url to your favicon
          "colors": {
              "main1": "purple-500",
              "header_gradient_interval": 100,
          },
          "social": {
              "youtube": "https://www.youtube.com/kjaymiller",
              "twitter": "https://twitter.com/kjaymiller",
              "linkedin": "https://linkedin.com/in/kjaymiller",
              "github": "https://github.com/kjaymiller",
              "mastodon": "https://mastodon.social/@kjaymiller",
          },
      }
  }


  app.site_settings.update(theme)

  ```

  5. Build your site
  ```bash
  python -m render_engine serve --build app:app
  ```


pkgId: f71c45bbd5a87e8493f7a3ab54ee44352c32e7055d455605e4ae0754f501e742
name: python-repeng-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for repeng
url: https://pypi.org/project/repeng/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-repeng-0.4.0-1.src.rpm
location_href: Packages/python-repeng-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/vgel/repeng/ci.yml?label=ci)](https://github.com/vgel/repeng/actions)
  [![PyPI - Version](https://img.shields.io/pypi/v/repeng)](https://pypi.org/project/repeng/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/repeng)](https://pypi.org/project/repeng/)
  [![GitHub License](https://img.shields.io/github/license/vgel/repeng)](https://github.com/vgel/repeng/blob/main/LICENSE)

  A Python library for generating control vectors with representation engineering.
  Train a vector in less than sixty seconds!

  _For a full example, see the notebooks folder or [the blog post](https://vgel.me/posts/representation-engineering)._

  ```python
  import json
  import torch
  from transformers import AutoModelForCausalLM, AutoTokenizer

  from repeng import ControlVector, ControlModel, DatasetEntry


  model_name = "mistralai/Mistral-7B-Instruct-v0.1"
  model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16)
  model = ControlModel(model, list(range(-5, -18, -1)))

  def make_dataset(template: str, pos_personas: list[str], neg_personas: list[str], suffixes: list[str]):
      
      ...


  trippy_dataset = make_dataset(
      "Act as if you're extremely {persona}.",
      ["high on psychedelic drugs"],
      ["sober from psychedelic drugs"],
      truncated_output_suffixes,
  )


  trippy_vector = ControlVector.train(model, tokenizer, trippy_dataset)


  for strength in (-2.2, 1, 2.2):
      print(f"strength={strength}")
      model.set_control(trippy_vector, strength)
      out = model.generate(
          **tokenizer(
              f"[INST] Give me a one-sentence pitch for a TV show. [/INST]",
              return_tensors="pt"
          ),
          do_sample=False,
          max_new_tokens=128,
          repetition_penalty=1.1,
      )
      print(tokenizer.decode(out.squeeze()).strip())
      print()
  ```

  > strength=-2.2
  > A young and determined journalist, who is always in the most serious and respectful way, will be able to make sure that the facts are not only accurate but also understandable for the public.
  >
  > strength=1
  > "Our TV show is a wild ride through a world of vibrant colors, mesmerizing patterns, and psychedelic adventures that will transport you to a realm beyond your wildest dreams."
  >
  > strength=2.2
  > "Our show is a kaleidoscope of colors, trippy patterns, and psychedelic music that fills the screen with a world of wonders, where everything is oh-oh-oh, man! ��psy����������oodle����psy��oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

  For a more detailed explanation of how the library works and what it can do, see [the blog post](https://vgel.me/posts/representation-engineering).



  * For a list of changes by version, see the [CHANGELOG](https://github.com/vgel/repeng/blob/main/CHANGELOG).
  * For quantized use, you may be interested in [llama.cpp#5970](https://github.com/ggerganov/llama.cpp/pull/5970)—after training a vector with `repeng`, export it by calling `vector.export_gguf(filename)` and then use it in `llama.cpp` with any quant!
  * Vector training *currently does not work* with MoE models (such as Mixtral). (This is theoretically fixable with some work, let me know if you're interested.)
  * Some example notebooks require `accelerate`, which must be manually installed with `pip install accelerate`. (This can also be done in the notebook with the IPython magic `%pip install accelerate`.)



  Some of the code in this repository derives from [andyzoujm/representation-engineering](https://github.com/andyzoujm/representation-engineering) (MIT license).



  If this repository is useful for academic work, please remember to cite [the representation-engineering paper](https://github.com/andyzoujm/representation-engineering?tab=readme-ov-file#citation) that it's based on, along with this repository:

  ```
  @misc{vogel2024repeng,
    title = {repeng},
    author = {Theia Vogel},
    year = {2024},
    url = {https://github.com/vgel/repeng/}
  }
  ```


pkgId: dc5f59f2d53d66409998d5819aeca1d194b85ddbf2749926350325b1450dedf9
name: python-repo-guide-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for repo-guide
url: https://github.com/wolfmanstout/repo-guide
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-repo-guide-0.2.0-1.src.rpm
location_href: Packages/python-repo-guide-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/repo-guide.svg)](https://pypi.org/project/repo-guide/)
  [![Changelog](https://img.shields.io/github/v/release/wolfmanstout/repo-guide?include_prereleases&label=changelog)](https://github.com/wolfmanstout/repo-guide/releases)
  [![Tests](https://github.com/wolfmanstout/repo-guide/actions/workflows/test.yml/badge.svg)](https://github.com/wolfmanstout/repo-guide/actions/workflows/test.yml)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/wolfmanstout/repo-guide/blob/master/LICENSE)

  Uses AI to help understand repositories and their changes.

  NOTE: this has not yet been released and is still in active development.



  Install this tool using `pip` or `pipx`:

  ```bash
  pip install repo-guide
  ```



  For help, run:

  ```bash
  repo-guide --help
  ```

  You can also use:

  ```bash
  python -m repo_guide --help
  ```



  To contribute to this tool, use uv. The following command will establish the
  venv and run tests:

  ```bash
  uv run pytest
  ```

  To run repo-guide locally, use:

  ```bash
  uv run repo-guide
  ```


pkgId: ff63f4d5dcc75d2224450eb14dbc2da70d1b2bfb68f8602ed7711824528f3daa
name: python-repo-review-help
arch: noarch
version: 0.11.3
epoch: 0
release: 1
summary: Development documents and examples for repo-review
url: https://repo-review.readthedocs.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-repo-review-0.11.3-1.src.rpm
location_href: Packages/python-repo-review-help-0.11.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status][actions-badge]][actions-link]
  [![Documentation Status][docs-badge]][docs-link]

  [![PyPI version][pypi-version]][pypi-link]
  [![Conda-Forge][conda-badge]][conda-link]
  [![PyPI platforms][pypi-platforms]][pypi-link]

  <!-- SPHINX-START -->

  This is a framework for building checks designed to check to see if a
  repository follows guidelines. By itself, it does nothing - it requires at
  least one plugin to be installed.

  With one or more plugins, it will produce a list of results - green checkmarks
  mean this rule is followed, red x’s mean the rule is not. A yellow warning sign
  means that the check was skipped because a previous required check failed. Four
  output formats are supported: `rich`, `svg`, `html`, and `json`.



  These are some known plugins. Feel free to request your plugin be added to this
  list.

  - [sp-repo-review][]: Checks based on the [Scientific-Python Development Guide][] at [scientific-python/cookie][].
  - [validate-pyproject][]: Adds a check to validate pyproject sections, also supports plugins (like [validate-pyproject-schema-store][]).

  `repo-review` itself also acts as a plugin for [validate-pyproject][], allowing
  you to validate the `[tool.repo-review]` section of your `pyproject.toml`.

  A live WebAssembly demo using [sp-repo-review][] and [validate-pyproject][] is
  [available here][repo-review-demo].



  Repo-review supports running multiple ways:

  - [From the command line][cli] on a local folder (or multiple folders).
  - From the command line on a remote repository on GitHub (`gh:org/repo@branch`)
  - [From WebAssembly][webapp] in [Pyodide][] (example in `docs/index.html`)
  - [From pre-commit][intro-pre-commit] (see caveats there)
  - [From GitHub Actions][intro-github-actions]
  - [From Python][programmatic-usage]

  When installing, make sure you also install at least one plugin, as
  `repo-review` has no integrated checks. If you are using the command line
  interface, make sure you include the `cli` extra (`repo-review[cli]`). Some
  plugins, like `sp-repo-review`, support running directly, such as:

  ```bash
  pipx run sp-repo-review[cli] <args>
  ```

  If the root of a package is not the repository root, pass `--package-dir a/b/c`.



  Repo-review [supports configuration][intro-configuring] via `pyproject.toml`:

  ```toml
  [tool.repo-review]
  select = ["A", "B", "C100"]
  ignore = ["A100"]
  ```

  If `--select` or `--ignore` are given on the command line, they will override
  the `pyproject.toml` config.



  Repo-review was inspired by frameworks like [Flake8][] and [Ruff][]. It is
  primarily different in two ways: It was designed to look at configuration files
  rather than Python files; which means it also only needs a subset of the
  repository (since most files are not configuration files). And it was designed
  to be runnable on external repositories, rather than pre-configured and run
  from inside the repository (which it can be). These differences also power the
  WebAssembly/remote version, which only needs to make a few API calls to look at
  the files that interest the plugin in question.

  So if you want to lint Python code, use Flake8 or Ruff. But if you want to
  check Flake8 or Ruff's configuration, use repo-review! Generally, repo-review
  plugins are more about requiring things to be present, like making sure all your
  repos have some [pre-commit][] check.



  This project is intended to be fun and easy to develop and design checks for -
  it requires and uses Python 3.10, and uses a lot of the new features in 3.9 and
  3.10. It's maybe not entirely conventional, but it enables very simple plugin
  development. It works locally, remotely, and in WebAssembly (using
  [Pyodide][]). [See the docs][writing-a-plugin].

  There are a few key designs that are very useful and make this possible. First,
  all paths are handled as Traversables. This allows a simple Traversable
  implementation based on `open_url` to provide a web interface for use in the
  webapp. It also would allow `zipfile.Path` to work just as well, too - no need
  to extract.

  [Checks][] can request [fixtures][] (like [pytest][]) as arguments. Check files
  can add new fixtures as needed. Fixtures are specified with entry points,
  and take any other fixture as arguments as well - the `root` and `package`
  fixtures represents the root of the repository and of the package you are
  checking, respectively, and are the basis for the other fixtures, which are
  topologically sorted and cached. `pyproject` is provided as well. Checks are
  specified via an entrypoint that returns a dict of checks; this can also can
  accept fixtures, allowing dynamic check listings.

  Check files do not depend on the main library, and can be extended (similar to
  Flake8). You register new check files via entry-points - so extending this is
  with custom checks or custom fixtures is easy and trivial. There's no need to
  subclass or do anything with the base library - no dependency on repo-review required.

  Checks are as simple as possible so they are easy to write. A check is a class
  with the name (1-2 letters + number) and a docstring (the check message). It
  should define a set of `requires` with any checks it depends on (by name), and
  have a check classmethod. The docstring of this method is the failure message,
  and supports substitution. Arguments to this method are fixtures, and `root` or
  `package` are built-in providing a Traversable. Any other fixtures are available
  by name. A new fixture can use any other fixtures, and can produce anything;
  fixtures are topologically sorted, pre-computed and cached.

  The runner will topologically sort the checks, and checks that do not run will
  get a `None` result and the check method will not run. The front-end (Rich
  powered CLI or Pyodide webapp) will render the markdown-formatted check
  docstring only if the result is `False`.

  Checks are organized by [Families][]. A plugin can customize the display name,
  change the sort order, and add an optional (dynamic) description. Like the other
  collection functions, the family entry-point also supports fixtures.



  This project inspired [Try-PyHF](https://kratsg.github.io/try-pyhf/), an
  interface for a High Energy Physics package in Scikit-HEP.

  This project inspired [abSENSE](https://princetonuniversity.github.io/abSENSE/), a
  web interface to abSENSE.

  This was developed for [Scikit-HEP][] before moving to Scientific-Python.

  <!-- prettier-ignore-start -->

  [actions-badge]: https://github.com/scientific-python/repo-review/workflows/CI/badge.svg
  [actions-link]: https://github.com/scientific-python/repo-review/actions
  [docs-badge]: https://readthedocs.org/projects/repo-review/badge/?version=latest
  [docs-link]: https://repo-review.readthedocs.io/en/latest/?badge=latest
  [flake8]: https://flake8.pycqa.org
  [pre-commit]: https://pre-commit.com
  [pyodide]: https://pyodide.org
  [pypi-link]: https://pypi.org/project/repo-review/
  [pypi-platforms]: https://img.shields.io/pypi/pyversions/repo-review
  [pypi-version]: https://badge.fury.io/py/repo-review.svg
  [pytest]: https://pytest.org
  [repo-review-demo]: https://scientific-python.github.io/repo-review
  [ruff]: https://beta.ruff.rs
  [scientific-python development guide]: https://learn.scientific-python.org/development
  [scientific-python/cookie]: https://github.com/scientific-python/cookie
  [scikit-hep]: https://scikit-hep.org
  [sp-repo-review]: https://pypi.org/project/sp-repo-review
  [validate-pyproject]: https://validate-pyproject.readthedocs.io
  [validate-pyproject-schema-store]: https://github.com/henryiii/validate-pyproject-schema-store
  [conda-badge]: https://img.shields.io/conda/vn/conda-forge/repo-review
  [conda-link]: https://github.com/conda-forge/repo-review-feedstock

  [intro-pre-commit]: https://repo-review.readthedocs.io/en/latest/intro.html#pre-commit
  [intro-github-actions]: https://repo-review.readthedocs.io/en/latest/intro.html#github-actions
  [cli]: https://repo-review.readthedocs.io/en/latest/cli.html
  [programmatic-usage]: https://repo-review.readthedocs.io/en/latest/programmatic.html
  [webapp]: https://repo-review.readthedocs.io/en/latest/webapp.html
  [intro-configuring]: https://repo-review.readthedocs.io/en/latest/intro.html#configuring
  [writing-a-plugin]: https://repo-review.readthedocs.io/en/latest/plugins.html
  [fixtures]: https://repo-review.readthedocs.io/en/latest/fixtures.html
  [checks]: https://repo-review.readthedocs.io/en/latest/checks.html
  [families]: https://repo-review.readthedocs.io/en/latest/families.html
  [changelog]: https://repo-review.readthedocs.io/en/latest/changelog.html
  [api]: https://repo-review.readthedocs.io/en/latest/api/repo_review.html


  <!-- prettier-ignore-end -->


pkgId: 50a97437905d0e10d65e72273cc5028eab9a3d7d5829a2d55ef77d3a39c39fa8
name: python-repo-to-text-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for repo-to-text
url: https://github.com/kirill-markin/repo-to-text
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-repo-to-text-0.5.1-1.src.rpm
location_href: Packages/python-repo-to-text-help-0.5.1-1.noarch.rpm
checksum_type: sha256
description:
  `repo-to-text` is an open-source project that converts the structure and contents of a directory (repository) into a single text file. By executing a simple command in the terminal, this tool generates a text representation of the directory, including the output of the `tree` command and the contents of each file, formatted for easy reading and sharing. This can be very useful for development and debugging with LLM.



  ![Example Output](https://raw.githubusercontent.com/kirill-markin/repo-to-text/main/examples/screenshot-demo.jpg)

  The generated text file will include the directory structure and contents of each file. For a full example, see the [example output for this repository](https://github.com/kirill-markin/repo-to-text/blob/main/examples/example_repo-to-text_2024-06-09-08-06-31-UTC.txt).

  The same text will appear in your clipboard. You can paste it into a dialog with the LLM and start communicating.



  - Generates a text representation of a directory's structure.
  - Includes the output of the `tree` command.
  - Saves the contents of each file, encapsulated in markdown code blocks.
  - Copies the generated text representation to the clipboard for easy sharing.
  - Easy to install and use via `pip`.





  To install `repo-to-text` via pip, run the following command:

  ```bash
  pip install repo-to-text
  ```

  To upgrade to the latest version, use the following command:

  ```bash
  pip install --upgrade repo-to-text
  ```



  After installation, you can use the `repo-to-text` command in your terminal. Navigate to the directory you want to convert and run:

  ```bash
  repo-to-text
  ```

  or

  ```bash
  flatten
  ```

  This will create a file named `repo-to-text_YYYY-MM-DD-HH-MM-SS-UTC.txt` in the current directory with the text representation of the repository. The contents of this file will also be copied to your clipboard for easy sharing.



  You can customize the behavior of `repo-to-text` with the following options:

  - `--output-dir <path>`: Specify an output directory where the generated text file will be saved. For example:

    ```bash
    repo-to-text --output-dir /path/to/output
    ```

    This will save the file in the specified output directory instead of the current directory.

  - `--create-settings` or `--init`: Create a default `.repo-to-text-settings.yaml` file with predefined settings. This is useful if you want to start with a template settings file and customize it according to your needs. To create the default settings file, run the following command in your terminal:

    ```bash
    repo-to-text --create-settings
    ```

    or

    ```bash
    repo-to-text --init
    ```

    This will create a file named `.repo-to-text-settings.yaml` in the current directory. If the file already exists, an error will be raised to prevent overwriting.

  - `--debug`: Enable DEBUG logging. By default, `repo-to-text` runs with INFO logging level. To enable DEBUG logging, use the `--debug` flag:

    ```bash
    repo-to-text --debug
    ```

    or to save the debug log to a file:

    ```bash
    repo-to-text --debug > debug_log.txt 2>&1
    ```

  - `input_dir`: Specify the directory to process. If not provided, the current directory (`.`) will be used. For example:

    ```bash
    repo-to-text /path/to/input_dir
    ```

  - `--stdout`: Output the generated text to stdout instead of a file. This is useful for piping the output to another command or saving it to a file using shell redirection. For example:

    ```bash
    repo-to-text --stdout > myfile.txt
    ```

    This will write the output directly to `myfile.txt` instead of creating a timestamped file.



  `repo-to-text` also supports configuration via a `.repo-to-text-settings.yaml` file. By default, the tool works without this file, but you can use it to customize what gets included in the final text file.



  To create a settings file, add a file named `.repo-to-text-settings.yaml` at the root of your project with the following content:

  ```yaml




  gitignore-import-and-ignore: True



  ignore-tree-and-content:
    - ".repo-to-text-settings.yaml"
    - "examples/"
    - "MANIFEST.in"
    - "setup.py"


  ignore-content:
    - "README.md"
    - "LICENSE"
    - "tests/"
  ```

  You can copy this file from the [existing example in the project](https://github.com/kirill-markin/repo-to-text/blob/main/.repo-to-text-settings.yaml) and adjust it to your needs. This file allows you to specify rules for what should be ignored when creating the text representation of the repository.



  - **gitignore-import-and-ignore**: Ignore files and directories specified in `.gitignore` for all sections.
  - **ignore-tree-and-content**: Ignore files and directories for the tree and "Contents of ..." sections.
  - **ignore-content**: Ignore files and directories only for the "Contents of ..." section.

  Using these settings, you can control which files and directories are included or excluded from the final text file.



  Using Wildcard Patterns

  - `*.ext`: Matches any file ending with .ext in any directory.
  - `dir/*.ext`: Matches files ending with .ext in the specified directory dir/.
  - `**/*.ext`: Matches files ending with .ext in any subdirectory (recursive).

  If you want to include certain files that would otherwise be ignored, use the ! pattern:

  ```yaml
  ignore-tree-and-content:
    - "*.txt"
    - "!README.txt"
  ```



  To ignore the generated text files, add the following lines to your `.gitignore` file:

  ```gitignore
  repo-to-text_*.txt
  ```



  To install `repo-to-text` locally for development, follow these steps:

  1. Clone the repository:

      ```bash
      git clone https://github.com/kirill-markin/repo-to-text
      cd repo-to-text
      ```

  2. Install the package locally:

      ```bash
      pip install -e .
      ```



  To install all the required dependencies, run the following command:

  ```bash
  pip install -r requirements.txt
  ```



  To run the tests, use the following command:

  ```bash
  pytest
  ```



  To uninstall the package, run the following command from the directory where the repository is located:

  ```bash
  pip uninstall repo-to-text
  ```



  Contributions are welcome! If you have any suggestions or find a bug, please open an issue or submit a pull request.



  This project is licensed under the MIT License - see the [LICENSE](https://github.com/kirill-markin/repo-to-text/blob/main/LICENSE) file for details.



  This project is maintained by [Kirill Markin](https://github.com/kirill-markin). For any inquiries or feedback, please contact [markinkirill@gmail.com](mailto:markinkirill@gmail.com).


pkgId: 2333397b046587e206acdbcabfd64ea2e8e2c953f7f25987e8a1e68dc5b09592
name: python-repominify-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for repominify
url: https://github.com/mikewcasale/repominify
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-repominify-0.1.0-1.src.rpm
location_href: Packages/python-repominify-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A Python package that optimizes codebase representations for Large Language Models (LLMs) by generating compact, context-rich summaries that minimize token usage while preserving essential structural information.

  [![PyPI version](https://badge.fury.io/py/repominify.svg)](https://badge.fury.io/py/repominify)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  repominify helps you provide detailed context about your codebase to LLMs without consuming excessive space in their context windows. It processes Repomix output to create optimized representations that maintain critical structural information while significantly reducing token usage. This enables more efficient and effective code-related conversations with AI models by maximizing the amount of useful context that can fit within token limits.

  ⚠️ Warning: repominify performs deep code analysis which can be resource-intensive for large codebases. Please start with a small subset of your code to understand the process and resource requirements.



  - **Automatic Dependency Management**
    - Checks and installs Node.js and npm dependencies
    - Automatically installs Repomix if not present
    - Handles version compatibility checks

  - **Code Analysis**
    - Parses and analyzes code structure
    - Extracts imports, classes, and functions
    - Builds dependency graphs
    - Performance optimized for large codebases

  - **Multiple Output Formats**
    - GraphML for visualization tools
    - JSON for web-based tools
    - YAML for statistics
    - Text for human-readable analysis

  - **Size Optimization**
    - Generates minified code structure representation
    - Provides detailed size reduction statistics
    - Shows character and token reduction percentages
    - Maintains semantic meaning while reducing size

  - **Security Awareness**
    - Detects potentially sensitive patterns
    - Provides security recommendations
    - Flags suspicious file content
    - Helps maintain security best practices

  - **Debug Support**
    - Comprehensive logging
    - Performance tracking
    - Detailed error messages



  ```bash
  pip install repominify
  ```



  - Python 3.7 or higher
  - Node.js 12+ (will be checked during runtime)
  - npm 6+ (will be checked during runtime)
  - Repomix (will be installed automatically if not present)





  ```bash

  repominify path/to/repomix-output.txt


  repominify path/to/repomix-output.txt -o output_dir


  repominify path/to/repomix-output.txt --debug
  ```



  ```python
  from repominify import CodeGraphBuilder, ensure_dependencies, configure_logging


  configure_logging(debug=True)


  if ensure_dependencies():
      
      builder = CodeGraphBuilder()

      
      file_entries = builder.parser.parse_file("repomix-output.txt")

      
      graph = builder.build_graph(file_entries)

      
      text_content, comparison = builder.save_graph(
          "output_directory",
          input_file="repomix-output.txt"
      )

      
      print(comparison)
  ```



  ```
  Analysis Complete!
  📊 File Stats:
  ────────────────
    Total Files: 18
    Total Chars: 1,091,801
   Total Tokens: 354,159
         Output: repomix-output.txt
       Security: ✔ No suspicious files detected

  📊 File Stats:
  ────────────────
    Total Files: 18
    Total Chars: 245,123
   Total Tokens: 89,456
         Output: code_graph.txt
       Security: ✔ No suspicious files detected

  📈 Comparison:
  ────────────────
   Char Reduction: 77.5%
  Token Reduction: 74.7%
  Security Notes: ✔ No issues found
  ```



  ```
  repominify/
  ├── src/                 # Source code
  │   ├── core/           # Core functionality
  │   │   ├── graph.py    # Graph building and analysis
  │   │   ├── parser.py   # Repomix file parsing
  │   │   └── types.py    # Shared types and data structures
  │   ├── io/             # Input/Output operations
  │   │   ├── exporters.py  # Graph export functionality
  │   │   └── formatters.py # Text representation formatting
  │   ├── utils/          # Utility modules
  │   │   ├── dependency_checker.py  # Dependency management
  │   │   ├── logging.py   # Logging configuration
  │   │   └── stats.py     # Statistics and comparison
  │   ├── cli.py          # Command-line interface
  │   └── __init__.py     # Package initialization
  ├── tests/              # Test suite
  │   ├── test_end2end.py  # End-to-end tests
  │   └── data/          # Test data files
  ├── setup.py           # Package configuration
  ├── pyproject.toml     # Build system requirements
  ├── LICENSE            # MIT License
  └── README.md          # This file
  ```



  When you run repominify, it generates several files in your output directory:

  - `code_graph.graphml`: Graph representation in GraphML format
  - `code_graph.json`: Graph data in JSON format for web visualization
  - `graph_statistics.yaml`: Statistical analysis of the codebase
  - `code_graph.txt`: Human-readable text representation



  repominify is designed to handle large codebases efficiently:

  - Memory usage scales linearly with codebase size
  - File I/O is buffered for efficiency
  - Graph operations are optimized
  - Performance statistics available in debug mode



  The package provides detailed error messages and proper error boundaries:

  - Dependency errors (Node.js, npm, Repomix)
  - File parsing errors
  - Graph building errors
  - Export errors



  To set up for development:

  ```bash

  git clone https://github.com/mikewcasale/repominify.git
  cd repominify


  pip install -e '.[dev]'


  pytest tests/
  ```



  Contributions are welcome! Please feel free to submit a Pull Request. By contributing to this project, you agree to abide by its terms.

  This project has adopted the [Python Style Guide](STYLEGUIDE.md) for consistency and maintainability.



  **Mike Casale**
  - Email: mike@casale.xyz
  - GitHub: [@mikewcasale](https://github.com/mikewcasale)
  - Website: [casale.xyz](https://casale.xyz)



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



  This project makes use of or was influenced by several excellent open source projects:

  - [Repomix](https://github.com/yamadashy/repomix) - Our analysis pipeline integrates with this Node.js tool for initial code scanning
  - [NetworkX](https://networkx.org/) - Core graph algorithms and data structures
  - [PyYAML](https://pyyaml.org/) - YAML file handling
  - [GraphRAG Accelerator](https://github.com/Azure-Samples/graphrag-accelerator) - Graph-based code analysis patterns and implementation concepts



  This project is not an officially supported product. It is provided as-is, without warranty or support. Users should evaluate its suitability for their use case and understand the implications of deep code analysis on their systems.



  - For bugs and feature requests, please [open an issue](https://github.com/mikewcasale/repominify/issues)
  - For usage questions, please [start a discussion](https://github.com/mikewcasale/repominify/discussions)
  - For security concerns, please email security@casale.xyz directly



  Any trademarks or registered trademarks mentioned in this project are the property of their respective owners.


pkgId: f42c5d7c2750df9dca72591dc356fecf0e11b6b18fb58860b35f1ecf6cd21619
name: python-reportportal-client-help
arch: noarch
version: 5.6.0
epoch: 0
release: 1
summary: Development documents and examples for reportportal-client
url: https://github.com/reportportal/client-Python
rpm_license: Apache 2.0.
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reportportal-client-5.6.0-1.src.rpm
location_href: Packages/python-reportportal-client-help-5.6.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/reportportal-client.svg?maxAge=259200)](https://pypi.python.org/pypi/reportportal-client)
  [![Python versions](https://img.shields.io/pypi/pyversions/reportportal-client.svg)](https://pypi.org/project/reportportal-client)
  [![Build Status](https://github.com/reportportal/client-Python/actions/workflows/tests.yml/badge.svg)](https://github.com/reportportal/client-Python/actions/workflows/tests.yml)
  [![codecov.io](https://codecov.io/gh/reportportal/client-Python/branch/develop/graph/badge.svg)](https://codecov.io/gh/reportportal/client-Python)
  [![Join Slack chat!](https://img.shields.io/badge/slack-join-brightgreen.svg)](https://slack.epmrpp.reportportal.io/)
  [![stackoverflow](https://img.shields.io/badge/reportportal-stackoverflow-orange.svg?style=flat)](http://stackoverflow.com/questions/tagged/reportportal)
  [![Build with Love](https://img.shields.io/badge/build%20with-❤%EF%B8%8F%E2%80%8D-lightgrey.svg)](http://reportportal.io?style=flat)

  Library used only for implementors of custom listeners for ReportPortal



  - [PyTest Framework](https://github.com/reportportal/agent-python-pytest)
  - [Robot Framework](https://github.com/reportportal/agent-Python-RobotFramework)
  - [Behave Framework](https://github.com/reportportal/agent-python-behave)
  - [Nose Framework (archived)](https://github.com/reportportal/agent-python-nosetests)



  The latest stable version is available on PyPI:

  ```
  pip install reportportal-client
  ```



  Basic usage example:

  ```python
  import os
  import subprocess
  from mimetypes import guess_type

  from reportportal_client import RPClient
  from reportportal_client.helpers import timestamp

  endpoint = "http://docker.local:8080"
  project = "default"

  api_key = "1adf271d-505f-44a8-ad71-0afbdf8c83bd"
  launch_name = "Test launch"
  launch_doc = "Testing logging with attachment."


  client = RPClient(endpoint=endpoint, project=project,
                    api_key=api_key)


  client.start()


  launch = client.start_launch(name=launch_name,
                               start_time=timestamp(),
                               description=launch_doc)

  item_id = client.start_test_item(name="Test Case",
                                   description="First Test Case",
                                   start_time=timestamp(),
                                   attributes=[{"key": "key", "value": "value"},
                                               {"value", "tag"}],
                                   item_type="STEP",
                                   parameters={"key1": "val1",
                                               "key2": "val2"})


  client.log(time=timestamp(),
             message="Hello World!",
             level="INFO")


  client.log(time=timestamp(),
             message="Too high memory usage!",
             level="WARN",
             attachment={
                 "name": "free_memory.txt",
                 "data": subprocess.check_output("free -h".split()),
                 "mime": "text/plain"
             })


  image = "/tmp/image.png"
  with open(image, "rb") as fh:
      attachment = {
          "name": os.path.basename(image),
          "data": fh.read(),
          "mime": guess_type(image)[0] or "application/octet-stream"
      }
      client.log(timestamp(), "Screen shot of issue.", "INFO", attachment)

  client.finish_test_item(item_id=item_id, end_time=timestamp(), status="PASSED")


  client.finish_launch(end_time=timestamp())




  client.terminate()
  ```



  The client uses `requests` library for working with RP and the same semantics
  to work with attachments (data).

  To log an attachment you need to pass file content and metadata to ``

  ```python
  import logging

  from reportportal_client import RPLogger, RPLogHandler

  logging.setLoggerClass(RPLogger)
  rp_logger = logging.getLogger(__name__)
  rp_logger.setLevel(logging.DEBUG)
  rp_logger.addHandler(RPLogHandler())

  screenshot_file_path = 'path/to/file.png'

  with open(screenshot_file_path, "rb") as image_file:
      file_data = image_file.read()

      
      rp_logger.info(
          "Some Text Here",
          attachment={"name": "test_name_screenshot.png",
                      "data": file_data,
                      "mime": "image/png"}
      )
  ```



  Licensed under the [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0)
  license (see the LICENSE.txt file).


pkgId: 787434bcc30681e5ee16c28d043765d3303c9804b6cdfb17b6039333b5bc8d9b
name: python-reposter-help
arch: noarch
version: 24.3.7
epoch: 0
release: 1
summary: Development documents and examples for reposter
url: https://pypi.org/project/reposter/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-reposter-24.3.7-1.src.rpm
location_href: Packages/python-reposter-help-24.3.7-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://github.com/gmankab/reposter/raw/main/other/img/transparent.png">

  userbot that forwards messages from telegram channels to others in real time



  - [github repo](https://github.com/gmankab/reposter)
  - [gitlab repo](https://gitlab.com/gmanka/reposter)
  - [codeberg repo](https://codeberg.org/gmanka/reposter)
  - [how to run](https://github.com/gmankab/reposter/blob/main/other/docs/run.md)
  - [how to build](https://github.com/gmankab/reposter/blob/main/other/docs/build.md)
  - [config](https://github.com/gmankab/reposter/blob/main/other/docs/config.md)
  - [env](https://github.com/gmankab/reposter/blob/main/other/docs/env.md)
  - [pypi](https://pypi.org/project/reposter)



  - msg edit sync (text only)
  - repost msgs
  - repost restricted content
  - chunk by chunk download and upload big files without writing on disk
  - notify if live stream started
  - logs


  - msg edit sync (media)
  - msg edit history
  - stop stream notifications button
  - msg with multiple media support
  - notify if msg deleted
  - multiple account support
  - reading and posting messages as different accounts
  - configuration with buttons in tg bot



  - this code was rewritten from scratch several times :)
  - [legacy-2021](https://github.com/gmankab/reposter/tree/legacy-2021)
  - [legacy-2022](https://github.com/gmankab/reposter/tree/legacy-2022)



  license is [gnu agpl 3](https://gnu.org/licenses/agpl-3.0.en.html)


pkgId: 3e7c2591b8a5dc9a6ef02c43a2e3ca1b3c5661067e2108a0b9618804b2ed37a9
name: python-repr-rw-help
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Development documents and examples for repr-rw
url: https://github.com/GRV96/repr_rw
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-repr-rw-2.0.1-1.src.rpm
location_href: Packages/python-repr-rw-help-2.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Cette bibliothèque écrit la représentation d'objets Python dans un fichier
  texte et lit le fichier pour recréer les objets. Une représentation d'objet
  est une chaîne de caractères renvoyée par la fonction `repr`.



  La fonction `write_reprs` écrit la représentation d'objets Python dans un
  fichier texte. Chaque ligne du fichier est une représentation d'objet. Si le
  fichier spécifié existe déjà, cette fonction l'écrase.

  Le générateur `read_reprs` lit un fichier texte contenant des représentations
  d'objet Python dans le but de recréer ces objets. Chaque ligne du fichier doit
  être une représentation d'objet. Les lignes vides sont ignorées. Chaque
  itération de ce générateur produit un objet.

  Consultez la documentation des fonctions et les démos dans le dépôt de code
  source pour plus d'informations.



  This library writes Python object representations in a text file and reads the
  file to recreate the objects. An object representation is a string returned by
  function `repr`.



  Function `write_reprs` writes the representation of Python objects in a text
  file. Each line in the file is an object representation. If the specified file
  already exists, this function overwrites it.

  Generator `read_reprs` reads a text file that contains the representation of
  Python objects in order to recreate those objects. Each line in the file must be
  an object representation. Empty lines are ignored. Each iteration of this
  generator yields one object.

  Consult the functions' documentation and the demos in the source code
  repository for the complete information.


pkgId: 9b506c33c20c749888a528c477927f5d569315eeb0c7b2cc8ba6d6c36e65c52a
name: python-requestmodel-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for requestmodel
url: https://github.com/foarsitter/requestmodel
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-requestmodel-0.7.0-1.src.rpm
location_href: Packages/python-requestmodel-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/requestmodel.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/requestmodel.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/requestmodel)][pypi status]
  [![License](https://img.shields.io/pypi/l/requestmodel)][license]

  [![Read the documentation at https://requestmodel.readthedocs.io/](https://img.shields.io/readthedocs/requestmodel/latest.svg?label=Read%20the%20Docs)][read the docs]
  [![Tests](https://github.com/foarsitter/requestmodel/workflows/Tests/badge.svg)][tests]
  [![Codecov](https://codecov.io/gh/foarsitter/requestmodel/branch/main/graph/badge.svg)][codecov]

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]

  [pypi status]: https://pypi.org/project/requestmodel/
  [read the docs]: https://requestmodel.readthedocs.io/
  [tests]: https://github.com/foarsitter/requestmodel/actions?workflow=Tests
  [codecov]: https://app.codecov.io/gh/foarsitter/requestmodel
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black



  - Model your http requests as a pydantic model
  - Annotate your request parameters with fastapi params
  - Support for sync & async requests



  - Create a generator for an OpenAPI spec
  - Support all kinds of http requests



  You can install _requestmodel_ via [pip] from [PyPI]:

  ```console
  $ pip install requestmodel
  ```



  Please see the [implementation detail] for further instructions.



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _requestmodel_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  This project was generated from [@cjolowicz]'s [Hypermodern Python Cookiecutter] template.

  [@cjolowicz]: https://github.com/cjolowicz
  [pypi]: https://pypi.org/
  [hypermodern python cookiecutter]: https://github.com/cjolowicz/cookiecutter-hypermodern-python
  [file an issue]: https://github.com/foarsitter/requestmodel/issues
  [pip]: https://pip.pypa.io/

  <!-- github-only -->

  [license]: https://github.com/foarsitter/requestmodel/blob/main/LICENSE
  [contributor guide]: https://github.com/foarsitter/requestmodel/blob/main/CONTRIBUTING.md
  [implementation detail]: https://requestmodel.readthedocs.io/en/latest/usage.html


pkgId: b20e0967af9ba9d5335b1c85c7db793f79967ce0e09ef6f52f14975bd1a23961
name: python-requests-htmlc-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for requests-htmlc
url: https://pypi.org/project/requests-htmlc/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-requests-htmlc-0.0.8-1.src.rpm
location_href: Packages/python-requests-htmlc-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  ![image](https://farm5.staticflickr.com/4695/39152770914_a3ab8af40d_k_d.jpg)

  This library intends to make parsing HTML (e.g. scraping the web) as
  simple and intuitive as possible.

  When using this library you automatically get:

  - **Full JavaScript support**! (Using Chromium, thanks to playwright)
  - *CSS Selectors* (a.k.a jQuery-style, thanks to PyQuery).
  - *XPath Selectors*, for the faint of heart.
  - Mocked user-agent (like a real web browser).
  - Automatic following of redirects.
  - Connection–pooling and cookie persistence.
  - The Requests experience you know and love, with magical parsing abilities.
  - **Async Support**

  Other nice features include:
  - Markdown export of pages and elements.



  Below is a summary of usage for this package.
  For detailed api documentation, see [here](https://cboin1996.github.io/requests-html)

  Make a GET request to 'python.org', using Requests:

  ```python
      >>> from requests_html import HTMLSession
      >>> session = HTMLSession()
      >>> r = session.get('https://python.org/')
  ```

  Try async and get some sites at the same time:

  ```python

      >>> from requests_html import AsyncHTMLSession
      >>> asession = AsyncHTMLSession()
      >>> async def get_pythonorg():
      ...     r = await asession.get('https://python.org/')
      ...     return r
      ...
      >>> async def get_reddit():
      ...    r = await asession.get('https://reddit.com/')
      ...    return r
      ...
      >>> async def get_google():
      ...    r = await asession.get('https://google.com/')
      ...    return r
      ...
      >>> results = asession.run(get_pythonorg, get_reddit, get_google)
      >>> results # check the requests all returned a 200 (success) code
      [<Response [200]>, <Response [200]>, <Response [200]>]
      >>> # Each item in the results list is a response object and can be interacted with as such
      >>> for result in results:
      ...     print(result.html.url)
      ...
      https://www.python.org/
      https://www.google.com/
      https://www.reddit.com/
  ```

  Note that the order of the objects in the results list represents the
  order they were returned in, not the order that the coroutines are passed
  to the ``run`` method, which is shown in the example by the order being different.

  Grab a list of all links on the page, as–is (anchors excluded):

  ```python
      >>> r.html.links
      {'//docs.python.org/3/tutorial/', '/about/apps/', 'https://github.com/python/pythondotorg/issues', '/accounts/login/', '/dev/peps/', '/about/legal/', '//docs.python.org/3/tutorial/introduction.html#lists', '/download/alternatives', 'http://feedproxy.google.com/~r/PythonInsider/~3/kihd2DW98YY/python-370a4-is-available-for-testing.html', '/download/other/', '/downloads/windows/', 'https://mail.python.org/mailman/listinfo/python-dev', '/doc/av', 'https://devguide.python.org/', '/about/success/#engineering', 'https://wiki.python.org/moin/PythonEventsCalendar#Submitting_an_Event', 'https://www.openstack.org', '/about/gettingstarted/', 'http://feedproxy.google.com/~r/PythonInsider/~3/AMoBel8b8Mc/python-3.html', '/success-stories/industrial-light-magic-runs-python/', 'http://docs.python.org/3/tutorial/introduction.html#using-python-as-a-calculator', '/', 'http://pyfound.blogspot.com/', '/events/python-events/past/', '/downloads/release/python-2714/', 'https://wiki.python.org/moin/PythonBooks', 'http://plus.google.com/+Python', 'https://wiki.python.org/moin/', 'https://status.python.org/', '/community/workshops/', '/community/lists/', 'http://buildbot.net/', '/community/awards', 'http://twitter.com/ThePSF', 'https://docs.python.org/3/license.html', '/psf/donations/', 'http://wiki.python.org/moin/Languages', '/dev/', '/events/python-user-group/', 'https://wiki.qt.io/PySide', '/community/sigs/', 'https://wiki.gnome.org/Projects/PyGObject', 'http://www.ansible.com', 'http://www.saltstack.com', 'http://planetpython.org/', '/events/python-events', '/about/help/', '/events/python-user-group/past/', '/about/success/', '/psf-landing/', '/about/apps', '/about/', 'http://www.wxpython.org/', '/events/python-user-group/665/', 'https://www.python.org/psf/codeofconduct/', '/dev/peps/peps.rss', '/downloads/source/', '/psf/sponsorship/sponsors/', 'http://bottlepy.org', 'http://roundup.sourceforge.net/', 'http://pandas.pydata.org/', 'http://brochure.getpython.info/', 'https://bugs.python.org/', '/community/merchandise/', 'http://tornadoweb.org', '/events/python-user-group/650/', 'http://flask.pocoo.org/', '/downloads/release/python-364/', '/events/python-user-group/660/', '/events/python-user-group/638/', '/psf/', '/doc/', 'http://blog.python.org', '/events/python-events/604/', '/about/success/#government', 'http://python.org/dev/peps/', 'https://docs.python.org', 'http://feedproxy.google.com/~r/PythonInsider/~3/zVC80sq9s00/python-364-is-now-available.html', '/users/membership/', '/about/success/#arts', 'https://wiki.python.org/moin/Python2orPython3', '/downloads/', '/jobs/', 'http://trac.edgewall.org/', 'http://feedproxy.google.com/~r/PythonInsider/~3/wh73_1A-N7Q/python-355rc1-and-python-348rc1-are-now.html', '/privacy/', 'https://pypi.python.org/', 'http://www.riverbankcomputing.co.uk/software/pyqt/intro', 'http://www.scipy.org', '/community/forums/', '/about/success/#scientific', '/about/success/#software-development', '/shell/', '/accounts/signup/', 'http://www.facebook.com/pythonlang?fref=ts', '/community/', 'https://kivy.org/', '/about/quotes/', 'http://www.web2py.com/', '/community/logos/', '/community/diversity/', '/events/calendars/', 'https://wiki.python.org/moin/BeginnersGuide', '/success-stories/', '/doc/essays/', '/dev/core-mentorship/', 'http://ipython.org', '/events/', '//docs.python.org/3/tutorial/controlflow.html', '/about/success/#education', '/blogs/', '/community/irc/', 'http://pycon.blogspot.com/', '//jobs.python.org', 'http://www.pylonsproject.org/', 'http://www.djangoproject.com/', '/downloads/mac-osx/', '/about/success/#business', 'http://feedproxy.google.com/~r/PythonInsider/~3/x_c9D0S-4C4/python-370b1-is-now-available-for.html', 'http://wiki.python.org/moin/TkInter', 'https://docs.python.org/faq/', '//docs.python.org/3/tutorial/controlflow.html#defining-functions'}
  ```

  Grab a list of all links on the page, in absolute form (anchors excluded):

  ```python
      >>> r.html.absolute_links
      {'https://github.com/python/pythondotorg/issues', 'https://docs.python.org/3/tutorial/', 'https://www.python.org/about/success/', 'http://feedproxy.google.com/~r/PythonInsider/~3/kihd2DW98YY/python-370a4-is-available-for-testing.html', 'https://www.python.org/dev/peps/', 'https://mail.python.org/mailman/listinfo/python-dev', 'https://www.python.org/doc/', 'https://www.python.org/', 'https://www.python.org/about/', 'https://www.python.org/events/python-events/past/', 'https://devguide.python.org/', 'https://wiki.python.org/moin/PythonEventsCalendar#Submitting_an_Event', 'https://www.openstack.org', 'http://feedproxy.google.com/~r/PythonInsider/~3/AMoBel8b8Mc/python-3.html', 'https://docs.python.org/3/tutorial/introduction.html#lists', 'http://docs.python.org/3/tutorial/introduction.html#using-python-as-a-calculator', 'http://pyfound.blogspot.com/', 'https://wiki.python.org/moin/PythonBooks', 'http://plus.google.com/+Python', 'https://wiki.python.org/moin/', 'https://www.python.org/events/python-events', 'https://status.python.org/', 'https://www.python.org/about/apps', 'https://www.python.org/downloads/release/python-2714/', 'https://www.python.org/psf/donations/', 'http://buildbot.net/', 'http://twitter.com/ThePSF', 'https://docs.python.org/3/license.html', 'http://wiki.python.org/moin/Languages', 'https://docs.python.org/faq/', 'https://jobs.python.org', 'https://www.python.org/about/success/#software-development', 'https://www.python.org/about/success/#education', 'https://www.python.org/community/logos/', 'https://www.python.org/doc/av', 'https://wiki.qt.io/PySide', 'https://www.python.org/events/python-user-group/660/', 'https://wiki.gnome.org/Projects/PyGObject', 'http://www.ansible.com', 'http://www.saltstack.com', 'https://www.python.org/dev/peps/peps.rss', 'http://planetpython.org/', 'https://www.python.org/events/python-user-group/past/', 'https://docs.python.org/3/tutorial/controlflow.html#defining-functions', 'https://www.python.org/community/diversity/', 'https://docs.python.org/3/tutorial/controlflow.html', 'https://www.python.org/community/awards', 'https://www.python.org/events/python-user-group/638/', 'https://www.python.org/about/legal/', 'https://www.python.org/dev/', 'https://www.python.org/download/alternatives', 'https://www.python.org/downloads/', 'https://www.python.org/community/lists/', 'http://www.wxpython.org/', 'https://www.python.org/about/success/#government', 'https://www.python.org/psf/', 'https://www.python.org/psf/codeofconduct/', 'http://bottlepy.org', 'http://roundup.sourceforge.net/', 'http://pandas.pydata.org/', 'http://brochure.getpython.info/', 'https://www.python.org/downloads/source/', 'https://bugs.python.org/', 'https://www.python.org/downloads/mac-osx/', 'https://www.python.org/about/help/', 'http://tornadoweb.org', 'http://flask.pocoo.org/', 'https://www.python.org/users/membership/', 'http://blog.python.org', 'https://www.python.org/privacy/', 'https://www.python.org/about/gettingstarted/', 'http://python.org/dev/peps/', 'https://www.python.org/about/apps/', 'https://docs.python.org', 'https://www.python.org/success-stories/', 'https://www.python.org/community/forums/', 'http://feedproxy.google.com/~r/PythonInsider/~3/zVC80sq9s00/python-364-is-now-available.html', 'https://www.python.org/community/merchandise/', 'https://www.python.org/about/success/#arts', 'https://wiki.python.org/moin/Python2orPython3', 'http://trac.edgewall.org/', 'http://feedproxy.google.com/~r/PythonInsider/~3/wh73_1A-N7Q/python-355rc1-and-python-348rc1-are-now.html', 'https://pypi.python.org/', 'https://www.python.org/events/python-user-group/650/', 'http://www.riverbankcomputing.co.uk/software/pyqt/intro', 'https://www.python.org/about/quotes/', 'https://www.python.org/downloads/windows/', 'https://www.python.org/events/calendars/', 'http://www.scipy.org', 'https://www.python.org/community/workshops/', 'https://www.python.org/blogs/', 'https://www.python.org/accounts/signup/', 'https://www.python.org/events/', 'https://kivy.org/', 'http://www.facebook.com/pythonlang?fref=ts', 'http://www.web2py.com/', 'https://www.python.org/psf/sponsorship/sponsors/', 'https://www.python.org/community/', 'https://www.python.org/download/other/', 'https://www.python.org/psf-landing/', 'https://www.python.org/events/python-user-group/665/', 'https://wiki.python.org/moin/BeginnersGuide', 'https://www.python.org/accounts/login/', 'https://www.python.org/downloads/release/python-364/', 'https://www.python.org/dev/core-mentorship/', 'https://www.python.org/about/success/#business', 'https://www.python.org/community/sigs/', 'https://www.python.org/events/python-user-group/', 'http://ipython.org', 'https://www.python.org/shell/', 'https://www.python.org/community/irc/', 'https://www.python.org/about/success/#engineering', 'http://www.pylonsproject.org/', 'http://pycon.blogspot.com/', 'https://www.python.org/about/success/#scientific', 'https://www.python.org/doc/essays/', 'http://www.djangoproject.com/', 'https://www.python.org/success-stories/industrial-light-magic-runs-python/', 'http://feedproxy.google.com/~r/PythonInsider/~3/x_c9D0S-4C4/python-370b1-is-now-available-for.html', 'http://wiki.python.org/moin/TkInter', 'https://www.python.org/jobs/', 'https://www.python.org/events/python-events/604/'}

  ```

  Select an element with a CSS Selector:

  ```python
      >>> about = r.html.find('#about', first=True)
  ```

  Grab an element's text contents:

  ```python
      >>> print(about.text)
      About
      Applications
      Quotes
      Getting Started
      Help
      Python Brochure
  ```

  Introspect an Element's attributes:

  ```python
      >>> about.attrs
      {'id': 'about', 'class': ('tier-1', 'element-1'), 'aria-haspopup': 'true'}
  ```

  Render out an Element's HTML:

  ```python
      >>> about.html
      '<li aria-haspopup="true" class="tier-1 element-1 " id="about">\n<a class="" href="/about/" title="">About</a>\n<ul aria-hidden="true" class="subnav menu" role="menu">\n<li class="tier-2 element-1" role="treeitem"><a href="/about/apps/" title="">Applications</a></li>\n<li class="tier-2 element-2" role="treeitem"><a href="/about/quotes/" title="">Quotes</a></li>\n<li class="tier-2 element-3" role="treeitem"><a href="/about/gettingstarted/" title="">Getting Started</a></li>\n<li class="tier-2 element-4" role="treeitem"><a href="/about/help/" title="">Help</a></li>\n<li class="tier-2 element-5" role="treeitem"><a href="http://brochure.getpython.info/" title="">Python Brochure</a></li>\n</ul>\n</li>'
  ```

  Select Elements within Elements:

  ```python
      >>> about.find('a')
      [<Element 'a' href='/about/' title='' class=''>, <Element 'a' href='/about/apps/' title=''>, <Element 'a' href='/about/quotes/' title=''>, <Element 'a' href='/about/gettingstarted/' title=''>, <Element 'a' href='/about/help/' title=''>, <Element 'a' href='http://brochure.getpython.info/' title=''>]
  ```

  Search for links within an element:

  ```python
      >>> about.absolute_links
      {'http://brochure.getpython.info/', 'https://www.python.org/about/gettingstarted/', 'https://www.python.org/about/', 'https://www.python.org/about/quotes/', 'https://www.python.org/about/help/', 'https://www.python.org/about/apps/'}
  ```

  Search for text on the page:

  ```python
      >>> r.html.search('Python is a {} language')[0]
      programming
  ```

  More complex CSS Selector example (copied from Chrome dev tools):

  ```python
      >>> r = session.get('https://github.com/')
      >>> sel = 'body > div.application-main > div.jumbotron.jumbotron-codelines > div > div > div.col-md-7.text-center.text-md-left > p'
      >>> print(r.html.find(sel, first=True).text)
      GitHub is a development platform inspired by the way you work. From open source to business, you can host and review code, manage projects, and build software alongside millions of other developers.
  ```

  XPath is also supported:

  ```python
     >>> r.html.xpath('/html/body/div[1]/a')
     [<Element 'a' class=('px-2', 'py-4', 'show-on-focus', 'js-skip-to-content') href='#start-of-content' tabindex='1'>]
  ```



  Let's grab some text that's rendered by JavaScript. Until 2020, the Python 2.7
  countdown clock (https://pythonclock.org) will serve as a good test page:

  ```python
      >>> r = session.get('https://pythonclock.org')
  ```

  Let's try and see the dynamically rendered code (The countdown clock).
  To do that quickly at first, we'll search between the last text we see
  before it ('Python 2.7 will retire in...') and the first text we see
  after it ('Enable Guido Mode').

  ```python
  	>>> r.html.search('Python 2.7 will retire in...{}Enable Guido Mode')[0]
  	'</h1>\n        </div>\n        <div class="python-27-clock"></div>\n        <div class="center">\n            <div class="guido-button-block">\n                <button class="js-guido-mode guido-button">'
  ```

  Notice the clock is missing. The ``render()`` method takes the response and renders
  the dynamic content just like a web browser would.

  ```python
      >>> r.html.render()
      >>> r.html.search('Python 2.7 will retire in...{}Enable Guido Mode')[0]
      '</h1>\n        </div>\n        <div class="python-27-clock is-countdown"><span class="countdown-row countdown-show6"><span class="countdown-section"><span class="countdown-amount">1</span><span class="countdown-period">Year</span></span><span class="countdown-section"><span class="countdown-amount">2</span><span class="countdown-period">Months</span></span><span class="countdown-section"><span class="countdown-amount">28</span><span class="countdown-period">Days</span></span><span class="countdown-section"><span class="countdown-amount">16</span><span class="countdown-period">Hours</span></span><span class="countdown-section"><span class="countdown-amount">52</span><span class="countdown-period">Minutes</span></span><span class="countdown-section"><span class="countdown-amount">46</span><span class="countdown-period">Seconds</span></span></span></div>\n        <div class="center">\n            <div class="guido-button-block">\n                <button class="js-guido-mode guido-button">'
  ```

  Let's clean it up a bit. This step is not needed, it just makes it a bit easier
  to visualize the returned html to see what we need to target to extract our
  required information.

  ```python
  	>>> from pprint import pprint
  	>>> pprint(r.html.search('Python 2.7 will retire in...{}Enable')[0])
  	('</h1>\n'
   '        </div>\n'
   '        <div class="python-27-clock is-countdown"><span class="countdown-row '
   'countdown-show6"><span class="countdown-section"><span '
   'class="countdown-amount">1</span><span '
   'class="countdown-period">Year</span></span><span '
   'class="countdown-section"><span class="countdown-amount">2</span><span '
   'class="countdown-period">Months</span></span><span '
   'class="countdown-section"><span class="countdown-amount">28</span><span '
   'class="countdown-period">Days</span></span><span '
   'class="countdown-section"><span class="countdown-amount">16</span><span '
   'class="countdown-period">Hours</span></span><span '
   'class="countdown-section"><span class="countdown-amount">52</span><span '
   'class="countdown-period">Minutes</span></span><span '
   'class="countdown-section"><span class="countdown-amount">46</span><span '
   'class="countdown-period">Seconds</span></span></span></div>\n'
   '        <div class="center">\n'
   '            <div class="guido-button-block">\n'
   '                <button class="js-guido-mode guido-button">')
  ```

  The rendered html has all the same methods and attributes as above. Let's extract
  just the data that we want out of the clock into something easy to
  use elsewhere and introspect like a dictionary.

  ```python
  	>>> periods = [element.text for element in r.html.find('.countdown-period')]
  	>>> amounts = [element.text for element in r.html.find('.countdown-amount')]
  	>>> countdown_data = dict(zip(periods, amounts))
  	>>> countdown_data
  	{'Year': '1', 'Months': '2', 'Days': '5', 'Hours': '23', 'Minutes': '34', 'Seconds': '37'}
  ```

  Or you can do this async also:

  ```python
      >>> async def get_pyclock():
      ...     r = await asession.get('https://pythonclock.org/')
      ...     await r.html.arender()
      ...     return r
      ...
      >>> results = asession.run(get_pyclock, get_pyclock, get_pyclock)
  ```

  The rest of the code operates the same way as the synchronous version except
  that `results` is a list containing multiple response objects however the
  same basic processes can be applied as above to extract the data you want.



  You can also use this library without Requests:

  ```python
      >>> from requests_html import HTML
      >>> doc = """<a href='https://httpbin.org'>"""
      >>> html = HTML(html=doc)
      >>> html.links
      {'https://httpbin.org'}
  ```




  ```bash
      $ pip install requests-htmlc
      ✨🍰✨
  ```

  Only **Python 3.11 and above** is supported.

  Ensure you have playwright installed:
  (the below command works because playwright
  is installed via pip during the Installation
  of requests-htmlc)

  ```bash
      $ playwright install
  ```


