# packages

pkgId: 68a9066acc831749be3ce1d4c0a42dbd588f70fb1c305a55d7fdc1ebbd5d2da4
name: python-gqlclient-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for gqlclient
url: https://pypi.org/project/gqlclient/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gqlclient-1.2.0-1.src.rpm
location_href: Packages/python-gqlclient-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  |codecov|
  A pythonic interface for making requests to a GraphQL server using
  standard library or pydantic dataclasses to spare you from string manipulation.


pkgId: 079bdb4c5f3d2770a2c32b2574f48d89c7d9e3422efbb929ec4ed073bd2d3792
name: python-gradio-agentchatbot-5-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for gradio-agentchatbot-5
url: https://pypi.org/project/gradio-agentchatbot-5/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gradio-agentchatbot-5-0.0.8-1.src.rpm
location_href: Packages/python-gradio-agentchatbot-5-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  tags: [gradio-custom-component, Chatbot, chatbot, agents, streaming, tools]
  title: gradio_agentchatbot
  short_description: Chat with agents 🤖 and see their thoughts 💭
  colorFrom: blue
  colorTo: yellow
  sdk: gradio
  pinned: false


pkgId: b16b6fad5a948be4d62dd760a192817ff06fc005396c638ecec42eb97606616a
name: python-gradio-vistimeline-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for gradio-vistimeline
url: https://pypi.org/project/gradio-vistimeline/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gradio-vistimeline-1.0.1-1.src.rpm
location_href: Packages/python-gradio-vistimeline-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <h1 style='text-align: center; margin-bottom: 1rem'> Gradio vis.js Timeline </h1>

  <div style="display: flex; flex-direction: row; justify-content: center">
  <img style="display: block; padding-right: 5px; height: 20px;" alt="Static Badge" src="https://img.shields.io/pypi/v/gradio_vistimeline">
  <a href="https://github.com/Yelorix/gradio-vis-timeline" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/github-white?logo=github&logoColor=black"></a>
  </div>

  A Gradio component that implements the [vis.js Timeline](https://github.com/visjs/vis-timeline) visualization library, allowing you to create interactive timelines in your Gradio apps.

  **Resources:**
  - [Timeline Examples](https://visjs.github.io/vis-timeline/examples/timeline/)
  - [Timeline Documentation](https://visjs.github.io/vis-timeline/docs/timeline/)
  - [Dataset Documentation](https://visjs.github.io/vis-data/data/dataset.html)



  ```bash
  pip install gradio_vistimeline
  ```



  ```python
  import gradio as gr
  from gradio_vistimeline import VisTimeline

  demo = gr.Interface(
      lambda x: x,
      VisTimeline(
          value={
              "items": [
                  {"content": "Item 1", "start": "2024-12-2", "end": "2024-12-10"},
                  {"content": "Item 2", "start": "2024-12-14"}
              ]
          },
          options={
              "start": "2024-12-1",
              "end": "2024-12-15",
              "editable": True
          }
      ),
      "json"
  )

  if __name__ == "__main__":
      demo.launch()
  ```





  - Interactive timeline visualization
  - Integration of vis.js Timeline includes:
      - Items
      - Ranges
      - Points
      - Background items
      - Groups
      - Subgroups
  - Pass options object during instantiation
  - Styled with the gradio style variables
  - Gradio events for editing data and selecting items



  The timeline accepts a value in the following format:

  ```python
  {
      "groups": [
          {
              "id": "group_id",
              "content": "Group Name" # Optional
          }
      ],
      "items": [
          {
              "content": "Item content",
              "start": "2024-01-01",  # ISO date string or Unix timestamp
              "end": "2024-01-05",    # Optional
              "group": "group_id",    # Optional
          }
      ]
  }
  ```

  Or as a VisTimelineData object:

  ```python
  from gradio_vistimeline import VisTimelineGroup, VisTimelineItem, VisTimelineData

  value = VisTimelineData(
      groups=[
          VisTimelineGroup(
              id="group_id",
              content="Group Name"   # Optional
          )
      ],
      items=[
          VisTimelineItem(
              content="Item content",
              start="2024-01-01",    # ISO date string or Unix timestamp
              end="2024-01-05",      # Optional
              group="group_id"       # Optional
          )
      ]
  )
  ```



  | name | description |
  |:-----|:------------|
  | `load` | Triggered when the component is mounted for the first time |
  | `change` | Triggered when the timeline value changes through any means |
  | `input` | Triggered when a user directly modifies timeline items (add/remove/update) |
  | `select` | Triggered when clicking the timeline |
  | `item_select` | Triggered when items are selected or unselected |





  The component accepts all configuration options supported by vis.js Timeline. Some commonly used options:

  ```python
  options = {
      "editable": True,             # Enable item editing
      "multiselect": True,          # Allow selecting multiple items
      "showCurrentTime": True,      # Show a marker for current time
      "stack": True,                # Stack overlapping items
      "zoomable": True              # Allow zooming the timeline
  }
  ```

  For a complete list of options, see the [vis.js Timeline documentation](https://visjs.github.io/vis-timeline/docs/timeline/).



  **Data Synchronization**
  ```python
  VisTimeline(
      value=value,
      preserve_old_content_on_value_change=True  # Default: False
  )
  ```
  Controls how the timeline updates their groups and items DataSets when the component value changes:
  - `False`: Clears and reinitializes all DataSets to ensure perfect sync with the Gradio component value
  - `True`: Merges new data with existing content (updates existing items, adds new ones, removes missing ones)

  Defaulted to false to ensure the value matches the visualization on the timeline.

  Changing it to true reduces visual flicker when dragging items around.
  Desync is only a real risk in this mode when you edit item ID's or add/remove item properties of existing items.

  **JavaScript Integration**
  ```python
  VisTimeline(
      value=value,
      elem_id="my-timeline"  # Optional
  )
  ```
  When `elem_id` is set, the timeline instance becomes available in JavaScript as `window.visTimelineInstances["my-timeline"]`, allowing easy access through custom scripts.

  **Styling Items**
  The component provides pre-defined color classes matching Gradio's theme colors. Apply them by setting an item's `className`:

  ```python
  item = {
      "content": "Colored item",
      "start": "2024-01-01",
      "className": "color-primary-500"  # Uses Gradio's primary-500 color
  }
  ```

  Available color classes follow the pattern:
  - `color-primary-[50-950]`
  - `color-secondary-[50-950]`
  - `color-neutral-[50-950]`

  Custom styles can be applied by defining your own CSS classes.


pkgId: 1c1565e309dafadc3a0b5b341a53644e17066756b0850a0c2ff4f726eda8442a
name: python-grafana-sync-help
arch: noarch
version: 0.9.0
epoch: 0
release: 1
summary: Development documents and examples for grafana-sync
url: https://github.com/elohmeier/grafana-sync
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-grafana-sync-0.9.0-1.src.rpm
location_href: Packages/python-grafana-sync-help-0.9.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/grafana-sync.svg)](https://pypi.org/project/grafana-sync/)
  [![Changelog](https://img.shields.io/github/v/release/elohmeier/grafana-sync?include_prereleases&label=changelog)](https://github.com/elohmeier/grafana-sync/releases)
  [![Tests](https://github.com/elohmeier/grafana-sync/actions/workflows/test.yml/badge.svg)](https://github.com/elohmeier/grafana-sync/actions/workflows/test.yml)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/elohmeier/grafana-sync/blob/master/LICENSE)

  Sync Grafana dashboards and folders



  Install this tool using `pip`:
  ```bash
  pip install grafana-sync
  ```


  For help, run:
  ```bash
  grafana-sync --help
  ```
  You can also use:
  ```bash
  python -m grafana_sync --help
  ```


  To contribute to this tool, first checkout the code. Then create a new virtual environment:
  ```bash
  cd grafana-sync
  python -m venv venv
  source venv/bin/activate
  ```
  Now install the dependencies and test dependencies:
  ```bash
  pip install -e '.[test]'
  ```
  To run the tests:
  ```bash
  python -m pytest
  ```


pkgId: 82700146b5852afe88adcb55e4f32d545c2fbc73997bd518d98553390d6e9ecb
name: python-grape-pi-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for grape-pi
url: https://pypi.org/project/grape-pi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-grape-pi-1.0.2-1.src.rpm
location_href: Packages/python-grape-pi-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  The contribution of Grape-Pi comes in threefold. First, we developed
  a dataloader module designed for loading MS protein data and
  protein-protein-interaction data into dataset format that can be readily
  used by torch-geometry. Second, we customized the graphgym module
  for the purpose of supervised learning in proteomics data. Third, we
  explored the design space and discussed caveats for training such a
  model for the best performance.

  **GrapePi** is built on top of the **PyTorch Geometric**, a geometric
  deep learning extension library for PyTorch.
  It consists of various methods for deep learning on graphs and
  other irregular structures, also known as *[geometric deep learning](http://geometricdeeplearning.com/)*, from a
  variety of published papers.
  In addition, it consists of easy-to-use mini-batch loaders for operating on many small and single giant
  graphs, [multi GPU-support](https://github.com/pyg-team/pytorch_geometric/tree/master/examples/multi_gpu), [`DataPipe` support](https://github.com/pyg-team/pytorch_geometric/blob/master/examples/datapipe.py),
  distributed graph learning via [Quiver](https://github.com/pyg-team/pytorch_geometric/tree/master/examples/quiver), a
  large number of common benchmark datasets (based on simple interfaces to create your own),
  the [GraphGym](https://pytorch-geometric.readthedocs.io/en/latest/advanced/graphgym.html) experiment manager, and
  helpful transforms, both for learning on arbitrary graphs as well as on 3D meshes or point clouds.

  It is highly recommended to use a virtual environment to install the required packages for Grape-Pi.
  Please refer to https://conda.io/projects/conda/en/latest/user-guide/install/index.html for how to install a miniconda
  or anaconda in your local machine.
  To create a virtual environment, for example, if using conda
  ```angular2html
  conda create -n [Name-of-the-Virtual-Environment] python=3.11
  conda activate [Name-of-the-Virtual-Environment]
  ```
  Replace `[Name-of-the-Virtual-Environment]` with your preferred name.
  Currently, Grape-Pi is only available for Python >=3.11, <=3.12.

  To install GrapePi as a command line tool, you can install it via pip.
  ```
  pip install grapepi
  ```
  You don't have to download the entire project to use GrapePi as a command line tool. However, it is recommended for you to download the data/, configs/, and saved_results/ folder to get a better understanding of what the configuration file and data looks like.
  ```
  git clone https://github.com/FDUguchunhui/GrapePi.git
  cd GrapePi
  ```
  To see options for using GrapePi as a command line tool, you can run `grapepi --help`
  ```
  > grapepi --help
  usage: grapepi [-h] --cfg CFG_FILE [--checkpoint CHECKPOINT] [--threshold THRESHOLD]
                 [--num-promoted NUM_PROMOTED] [--output OUTPUT] [--override OVERRIDE]
  GrapePi: Promote unconfident proteins based on prediction probability.
  options:
    -h, --help            show this help message and exit
    --cfg CFG_FILE        The configuration file path.
    --checkpoint CHECKPOINT
                          The checkpoint file path.
    --threshold THRESHOLD
                          The threshold to determine the unconfident proteins based on raw
                          protein probability.
    --num-promoted NUM_PROMOTED
                          The number, N, of proteins to be promoted Top N Proteins will be
                          selected based on the prediction probability from
                          unconfidentproteins.
    --output OUTPUT       The output file path to save the promoted proteins.
    --override OVERRIDE   Override the configurations from the configuration file. This
                          argument must be a single string with the format
                          "key1=value1,key2=value2". For overriding config of list type, use
                          the format it has been additional nested by single quotation marker
                          'key1=[value1,value2]'. Example: "dataset.dir=data/yeast-LCQ
                          'dataset.node_numeric_cols=[protein_probability, mRNA]'
                          run.name=yeast_LCQ_sageconv dataset.label_col=y"
  ```

  ```angular2html
  grapepi --cfg saved_results/gastric_sageconv/config.yaml --checkpoint saved_results/gastric_sageconv/epoch=199-step=11800.ckpt --threshold 0.9 --num-promoted 100 --output saved_results/gastric_sageconv/evaluation
  ```
  The above command will initialize a model which is defined in provided configuration files and  load the trained model from the checkpoint
  file, make prediction on the unconfident proteins,
  which are defined as proteins with raw protein probability below 0.9 and promote
  100 proteins with the highest prediction protein probability. It will also
  The prediction result "promoted_protein.csv" will be
  saved in the root directory of the provided data path.
  You can also overwrite data path by providing
  additional argument in through overwrite argument "-overwrite " key1=value2 key2=value2""  format. Be careful, the key-value pair should be separated by space and key and value should be separated by equal sign and has to be enclosed by double quotation mark. The following code can be used to use the pre-trained model to make prediction on your own data. When you just want to perform prediction task on a new data with label, you can simply set the "dataset.label_col" as any column in your data such as raw protein probability it won't have any effect for the prediction.
  ```angular2html
  grapepi --cfg saved_results/gastric_sageconv/config.yaml --checkpoint saved_results/gastric-graphsage/epoch=199-step=11800.ckpt --threshold 0.9 --num-promoted 100 --output {YOUR_DATA_PATH} --override "dataset.dir={YOUR_DATA_PATH} dataset.label_col={YOUR_LABEL_COLUMN}, dataset.node_numeric_cols=[{YOUR_NODE_NUMERIC_COLS}]"
  ```
  For the best performance, it is recommended to train a new model with your own data. To train a new model, you just
  need to run the same command without the `--checkpoint` argument.
  You can use the following command to train a new model with your own data. Here will use predefined configuration file,
  which use "sageConv" as the
  message-passing layer and hyperparameters that have been optimized for this task.
  Once the training is done, it will
  be saved in the `results` folder by default. Go into the `results` folder, you can find a subfolder name after the
  configuration file name, the ckpt file will be saved in this subfolder under "{random_seed}/ckpt" folder, where
  {random_seed} is the random seed used for this training. Those path are defined in the configuration file and can be overridden similar above.
  ```angular2html

  grapepi --cfg saved_results/gastric_sageconv/config.yaml --threshold 0.9 --num-promoted 100 --output saved_results/gastric_sageconv/evaluation
  ```
  It will first output the entire configuration setting and print the model structure, and start the training process.

  The GraphPi framework features a built-in module for easily load raw
  protein and PPI data into torch.geometry.dataset
  format that can be used for training model. The only things needed is to
  provide a path to the dataset folder.
  The dataset folder structure should look like this, with a sub-folder
  named `raw` inside the `raw` sub-folder, it should have three
  sub-folders: protein, interaction, and reference (optional).
  The  `protein`  folder must contain exact only one **csv** file:
  the first column and second column must be protein ID and raw protein probability, and other columns can contain additional protein features.
  The `interaction` folder must contain exact only one **csv** file: the first
  and second columns must be same type protein ID (e.g. Uniprot
  accession number or gene symbol) refer to the two protein interactors,
  other columns can be additional features for the interaction relationship. The ID system used should be matched with
  the protein ID in the `protein` folder.
  To provide ground-truth labels for the protein existence in the sample, you need to save the ground-true label information in the `protein` csv file and specify the column name of the ground-true label through `dataset.label_col` in config file.  Only labeled proteins will be used for model training, loss calculation, and then
  backward propagation to update model.

  Before you can train a model based on the provided data, a configuration file is needed to for some key information:
  where to find the data, how to parse the data, what features to use, model structure, what loss function to use, how to
  update model weights, etc.
  For example of a configuration file, please refer to `configs/protein/grapepi.yaml` in the project.
  The available options in the configuration file are as follows:
  ```ymal


  accelerator: 'auto'
    
  devices: 1

  num_workers: 8

  out_dir: results

  metric_best: auc

  seed: 1234
  dataset:
    name: protein # dataset type. It should be keep unchanged
    
    dir: data/gastric_all_data
    
    
    
    rebuild: true
    
    label_col: hard_label
      
    node_numeric_cols: [protein_probability] # , mRNA_TPM
    
    
    
    interaction_weight_col : null
    
    interaction_conf_col: null
    
    
    
    interaction_conf_thresh: 0.0
    task: node # Type of task. For Grape-Pi it is a node classification task. It should be keep unchanged
    task_type: classification # Type of task. It should be keep unchanged
    
    node_encoder: false
    
    edge_encoder: false
      
    split: [0.6, 0.2, 0.2]
  share:
    
    dim_in: -1
    
    dim_out: 2

  train:
    
    
    batch_size: 128
    
    ckpt_period: 10
    
    ckpt_clean: false
    
    sampler: neighbor
    
    eval_period: 10
    
    neighbor_sizes: [20, 10, 5]
    
    epoch_resume: 0
    
    early_stop: false
    
    early_stop_patience: 50
  model:
    type: gnn
    loss_fun: cross_entropy
    
  gnn:
    
    layers_pre_mp: 1
    
    layers_mp: 1
    
    layers_post_mp: 1
    
    dim_inner: 10
    
    layer_type: sageconv # sageconv gcnconv
    
    
    stage_type: skipsum
    
    batchnorm: false
    
    act: relu
    
    dropout: 0.0
    
    normalize_adj: false
    
    head: protein
  optim:
    
    optimizer: adam
    
    base_lr: 0.001
    
    weight_decay: 5e-4
    
    max_epoch: 300
    
    scheduler: none
  run:
    
    repeat: 1
    
    
    name: none
    
    mark_done: false
  ```
  During the programming first running, a new "processed" folder will create under the provided data folder which stores
  the
  converted torch_geometry.data.dataset format and additional processed files. This allows a one-time processing and the
  next time data the same data is used, the processed file will be loaded directly to save time.

  When you have more protein-level features and new protein-protein-interaction dataset, you may need to train a new model and explore the hyperparameter space. GrapePi provides a pipeline for hyperparameter tuning. Option 2 is for advanced user since sometime you need to modify the code to fit your system architure, operating system, python version, and shell.

  Clone a copy of Grape-Pi from source and navigate to the root directory of the download folder. See [Cloning a repository](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) for more details about how to make a local copy of project.
  ```angular2html
  git clone https://github.com/FDUguchunhui/GrapePi.git
  cd GrapePi
  ```

  We recommend the installation through Poetry using`pyproject.toml` which a new standard file for declare dependencies and build system information for Python projects. You can also use poetry to install the dependencies. Poetry is recommended to be installed in the global environment. See more t [Poetry](https://python-poetry.org/docs/)
  ```
  cd GrapePi # navigate to the root directory of the project
  poetry install --all-extras
  ```
  Some package may not be installed correctly, you may need to install them manually, including torch, torch_geometric,
  and others packages that torch and torch_geometric depends. Those packages depend on the version of python and
  pytorch, architecture of the system, and operating system. Follow the instruction below to install the required
  packages based on your environment.
  Follow the installation instructions to install additional libraries to using Grape-Pi:
  torch-scatter, torch-sparse, torch-cluster and torch-spline-conv (if you haven't already). Replace {CUDA} with your
  specific CUDA version or cpu.
  ```angular2html
  pip install torch_scatter torch_sparse torch_cluster torch_spline_conv -f https://data.pyg.org/whl/torch-2.4.0+${CUDA}.html
  ```
  If you are using pytorch=2.4.0 cpu only version, run
  ```angular2html
  pip install torch_scatter torch_sparse torch_cluster torch_spline_conv -f https://data.pyg.org/whl/torch-2.4.0+cpu.html
  ```

  ![GrapePi](figures/flowchart.jpg)
  The complete GrapePi training framework consists of three main components: data preparation, hyperparameter training,
  and post-training analysis. We have already touched on the data preparation in Command line tool section. Now, we focus on how to set-up batch experiment for hyperparameter tuning.

  Batch experiment allow user to run multiple experiments with different hyper-parameters in sequential with or without
  parallel. To run a batch experiment, you need to provide three configuration files. The first configuration file is the
  model configuration file as described above. The second configuration file is the grid search configuration file which
  specify the hyper-parameters to be searched. The third configuration file is the batch experiment configuration file
  which
  specify the batch experiment setting such as how many times to repeat the experiment, how many jobs to run in parallel,
  etc.

  Grid search configuration file is a text file with each row specify a hyper-parameter to be searched. The first column
  is the name of the hyper-parameter in the model configuration file, the second column is the alias of the
  hyper-parameter
  which will be used in the output file name, the third column is the range of the hyper-parameter to be searched.
  ```angular2html




  gnn.dropout drop [0.0,0.3,0.6]
  gnn.layers_pre_mp l_pre [1,2]
  gnn.layers_mp l_mp [1,2,3]
  gnn.layers_post_mp l_post [1,2]
  gnn.stage_type stage ['stack','skipsum','skipconcat']
  optim.max_epoch epoch [100,200,300]
  train.ckpt_clean ckpt_clean [True]
  ```

  Batch experiment additional configuration file is a bash file with each row specify a bash variable to be used in the
  batch experiment. The first parameter `CONFIG` is the name of the model configuration file (expect to find it under
  `configs/protein/` folder. The second parameter `GRID` is the name of the grid search configuration file (expect to find
  it under `grids` folder. The third parameter `REPEAT` is the number of times to repeat the experiment. The fourth
  parameter
  `MAX_JOBS` is the number of jobs to run in parallel. The fifth parameter `SLEEP` is the time to sleep between each job.
  The sixth parameter `MAIN` is the name of the main python file to execute each experiment.
  ```angular2html
  CONFIG=${CONFIG:-protein-yeast-gcnconv}
  GRID=${GRID:-protein-yeast-gcnconv}
  REPEAT=${REPEAT:-3}
  MAX_JOBS=${MAX_JOBS:-1}
  SLEEP=${SLEEP:-0}
  MAIN=${MAIN:-main}



  python configs_gen.py --config configs/protein/${CONFIG}.yaml \
    --grid grids/${GRID}.txt \
    --out_dir configs



  bash parallel.sh configs/${CONFIG}_grid_${GRID} $REPEAT $MAX_JOBS $SLEEP $MAIN

  bash parallel.sh configs/${CONFIG}_grid_${GRID} $REPEAT $MAX_JOBS $SLEEP $MAIN

  bash parallel.sh configs/${CONFIG}_grid_${GRID} $REPEAT $MAX_JOBS $SLEEP $MAIN

  python agg_batch.py --dir results/${CONFIG}_grid_${GRID}
  ```

  ```angular2html
  bash run_batch_yeast_gcnconv.sh
  ```

  Run `bash run_batch_yeast_gcnconv.sh` should automatically aggregate batch experiment result into `agg` folder.
  However, in case it is not generated automatically, you can manually aggregate the results by run
  ```angular2html
  python agg_batch.py --dir results/protein-yeast-graphsage_grid_protein-yeast-graphsage
  ```
  The instruction above only aim to provide a start point for user to check how we did our experiment.
  Please refer to https://github.com/snap-stanford/GraphGym for more details about how to config a batch experiment.

  Please cite the following papers if you use this code in your own work::
  [Fast Graph Representation Learning with PyTorch Geometric
  [Fast Graph Representation Learning with PyTorch Geometric
  ](https://arxiv.org/abs/1903.02428)
  ```
  @inproceedings{Fey/Lenssen/2019,
    title={Fast Graph Representation Learning with {PyTorch Geometric}},
    author={Fey, Matthias and Lenssen, Jan E.},
    booktitle={ICLR Workshop on Representation Learning on Graphs and Manifolds},
    year={2019},
  }
  ```
  Common issues:
  1. If you have the following problem during processing the `raw` data into `processed` data
  ```angular2html
  utf8' codec can't decode byte 0x80 in position 3131: invalid start byte
  ```
  This is caused by a hidden `.DS_Store` file created by the Mac OS system
  Use terminal enter the `protein` folder under the `raw` folder
  ```angular2html
  ls -a # check if there is a .DS_Store file
  rm .DS_Store # remove the file
  rm -r ../../processed # remove the ill-created `processed` data
  ```
  2. Mac user may encounter the following problem
  ```angular2html
  /Users/guchunhui/Documents/GNN-PPI/torch_geometric/typing.py:25: UserWarning: An issue occurred while importing 'pyg-lib'. Disabling its usage. Stacktrace: dlopen(/Users/guchunhui/opt/anaconda3/envs/Grape-Pi/lib/python3.10/site-packages/libpyg.so, 0x0006): Library not loaded: '/Users/runner/hostedtoolcache/Python/3.10.8/x64/lib/libpython3.10.dylib'
    Referenced from: '/Users/guchunhui/opt/anaconda3/envs/Grape-Pi/lib/python3.10/site-packages/libpyg.so'
    Reason: tried: '/Users/runner/hostedtoolcache/Python/3.10.8/x64/lib/libpython3.10.dylib' (no such file), '/usr/local/lib/libpython3.10.dylib' (no such file), '/usr/lib/libpython3.10.dylib' (no such file)
    warnings.warn(f"An issue occurred while importing 'pyg-lib'. "
  /Users/guchunhui/Documents/GNN-PPI/torch_geometric/typing.py:76: UserWarning: An issue occurred while importing 'torch-sparse'. Disabling its usage. Stacktrace: dlopen(/Users/guchunhui/opt/anaconda3/envs/Grape-Pi/lib/python3.10/site-packages/libpyg.so, 0x0006): Library not loaded: '/Users/runner/hostedtoolcache/Python/3.10.8/x64/lib/libpython3.10.dylib'
    Referenced from: '/Users/guchunhui/opt/anaconda3/envs/Grape-Pi/lib/python3.10/site-packages/libpyg.so'
    Reason: tried: '/Users/runner/hostedtoolcache/Python/3.10.8/x64/lib/libpython3.10.dylib' (no such file), '/usr/local/lib/libpython3.10.dylib' (no such file), '/usr/lib/libpython3.10.dylib' (no such file)
    warnings.warn(f"An issue occurred while importing 'torch-sparse'. "
  ```
  The solution is to run the following
  ```angular2html
  pip uninstall pyg_lib
  ```
  Source: https://github.com/pyg-team/pyg-lib/issues/217
  3. If you see the following error during batch training, it means there is no enough system resources to performance
     such
     a batch training. Please be aware of the multiplication of `num_workers` in model configuration file and `MAX_JOBS`
     in
     parallel.sh should not exceed the total number of workers (threads) available in the system. For example, if
     `num_workers`: 2 and MAX_JOBS=${MAX_JOBS:-6} will raise error in a computer with only 8 cpu threads.
  ```angular2html
  Sanity Checking: 0it [00:00, ?it/s]Traceback (most recent call last):
    File "/home/user/miniconda3/envs/grape-pi/lib/python3.10/multiprocessing/queues.py", line 244, in _feed
    File "/home/user/miniconda3/envs/grape-pi/lib/python3.10/multiprocessing/reduction.py", line 51, in dumps
    File "/home/user/miniconda3/envs/grape-pi/lib/python3.10/site-packages/torch/multiprocessing/reductions.py", line 369, in reduce_storage
  RuntimeError: user open shared memory object </torch_2070_3445168708_503> in read-write mode: Too many open files (24)
  Traceback (mosusercall last):
    File "/home/user/miniconda3/envs/grape-pi/lib/python3.10/multiprocessing/queues.py", line 244, in _feed
    File "/home/user/miniconda3/envs/grape-pi/lib/python3.10/multiprocessing/reduction.py", line 51, in dumps
    File "/home/user/miniconda3/envs/grape-pi/lib/python3.10/site-packages/torch/multiprocessing/reductions.py", line 370, in reduce_storage
    File "/home/user/miniconda3/envs/grape-pi/lib/python3.10/multiprocessing/reduction.py", line 198, in DupFd
    File "/home/user/miniconda3/envs/grape-pi/lib/python3.10/multiprocessing/resource_sharer.py", line 48, in __init__
  OSError: [Errno 24] Too many open files
  ```
  4.For Mac Apple M1/M2 user, you may encounter the following error when try Grape-Pi-SAGEConv model
  ```angular2html
  Intel MKL FATAL ERROR: This system does not meet the minimum requirements for use of the Intel(R) Math Kernel Library.
  The processor must support the Intel(R) Supplemental Streaming SIMD Extensions 3 (Intel(R) SSSE3) instructions.
  The processor must support the Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) instructions.
  The processor must support the Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.
  ```
  Try to install the following package.
  ```angular2html
  conda install -y clang_osx-arm64 clangxx_osx-arm64 gfortran_osx-arm64
  ```
  Find more details, please refer to https://github.com/rusty1s/pytorch_scatter/issues/241


pkgId: 3f06857d5069fa912cc4f82fc442548b752bf93ff3c57e68581f7ba7daeca100
name: python-grapevne-help
arch: noarch
version: 0.2.5
epoch: 0
release: 1
summary: Development documents and examples for grapevne
url: https://pypi.org/project/grapevne/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-grapevne-0.2.5-1.src.rpm
location_href: Packages/python-grapevne-help-0.2.5-1.noarch.rpm
checksum_type: sha256
description:
  Designed for use with [GRAPEVNE](https://github.com/kraemer-lab/GRAPEVNE), the Graphical Analytical Pipeline Development Environment - an interactive environment for building and validating data processing workflows, built around the Snakemake workflow manager.

  grapevne-py is a python library for grapevne snakemake support. It provides a set of classes and functions to help you build and validate snakemake modules that are compatible with GRAPEVNE. By using grapevne-py, you can easily create snakemake modules that can be imported into GRAPEVNE and used to build complex data processing workflows.

  See [GRAPEVNE](https://grapevne.readthedocs.io/en/latest/?badge=latest) for more information about these tools.



  Each GRAPEVNE module employing grapevne-py will include a `grapevne_helper.py` file that installs the latest version of grapevne-py. To install the package manually you can use pip, or another package manager of your choice:

  ```bash
  pip install grapevne-py
  ```



  grapevne-py provides a set of classes and functions that you can use to build snakemake modules that can be interconnected with one another via GRAPEVNE. Here's an example of how you might use grapevne-py to build a simple snakemake module:

  ```python
  from grapevne_helper import import_grapevne
  gv = import_grapevne(workflow)

  rule all:
      input:
          src = gv.input("input.txt"),
      output
          target = gv.output("output.txt"),
      shell:
          "cp {input.src} {output.target}"
  ```

  grapevne-py uses a helper function that is bundled with each module to bootstrap the latest version of grapevne-py. Once imported the wrapper functions that we will use are available through the `gv` object. In this example we simply copy an input file to an output. Note that the `gv.input` and `gv.output` wrapper functions are used to allow GRAPEVNE to redirect the input and output file paths as required (as-well as providing a number of other benefits, such as automatic remote file support and Snakemake version compatibility checks). There are a number of other wrapper available, outlined below.

  In the next example we will use several more wrappers including `script`, `resource`, `log` and the `params` wrapper to access parameters passed to the module from the configuration file. For convenience, we will expose all wrappers to the global namespace, allowing us to write `output(params("Filename"))` instead of `gv.output(gv.params("Filename"))`.  This module assumes a configuration file that contains a `Filename` parameter along with a `script.sh` script and `payload.txt` resource file that is bundled with the module.

  ```python
  configfile: "config/config.yaml"
  from grapevne_helper import import_grapevne

  grapevne = import_grapevne(workflow)
  globals().update(vars(grapevne))

  rule all:
      input:
          script = script("script.sh"),
          payload = resource("payload.txt")),
      output:
          target = output(params("Filename")),
      log:
          log("log.txt"),
      shell:
          "{input.script} {input.payload} {output.target}"
  ```




  Most wrappers take a single `path` argument and redirect that file path as required by GRAPEVNE:
  - `output()` - Wrapper for output file paths
  - `script()` - Wrapper for scripts that are executed by the workflow (shell, python, R, etc.)
  - `resource()` - Wrapper for resource files (payload items) that are provided by the module
  - `remote()` - Wrapper for remote files (http, s3, etc.)
  - `log()` - Wrapper for log file paths (manages location, which is useful in larger workflows)
  - `env()` - Wrapper for environment file paths
  - `benchmark()` - Wrapper for benchmark file paths

  There are also several wrappers that take multiple inputs:

  - `input(path, port=None)`

    Wrapper for input file paths. When input ports are unnamed (see [GRAPEVNE documentation](https://grapevne.readthedocs.io/en/latest/?badge=latest)) then the `input` wrapper can be used without specifying a port, e.g. `input("input.txt")`.

    When multiple input ports are available, or the input port is named, then the wrapper should be used with a port specifier, e.g. `input("input.txt", "port1")`.

  - `param(*args)`

    References parameters in the configuration file. For example - assume the following parameters:

      ```yaml
      Filename: "input.txt"
      Triggers:
          Start: "2022-01-01"
          End: "2022-12-31"
      ```

      We would access the `Filename` parameter as `params("Filename")` and the `Triggers` parameter as `params("Triggers")`. To access the `Start` parameter we would use `params("Triggers", "Start")`, or `params("Triggers.Start")` as shorthand.

  - `params(*args)`

    Redirects to `param(*args)`.


pkgId: f3e6556a335f54c1b5f34ea7cce0bbb4c0eccc0a3e2f6b6015ba31c0a75ef255
name: python-graph-mkimoni-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for graph-mkimoni
url: https://github.com/alexkimoni/dijkstra.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graph-mkimoni-0.0.2-1.src.rpm
location_href: Packages/python-graph-mkimoni-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python package that implements Dijkstra's shortest path algorithm and includes Kruskal's minimum spanning tree algorithm.

  ```
  pip3 install graph_mkimoni
  ```


pkgId: 3c0fe95d8199e7063d299ecd7ab99e4784ce63628414c2e7c8ee4103f8456f3e
name: python-graph-pes-help
arch: noarch
version: 0.0.16
epoch: 0
release: 1
summary: Development documents and examples for graph-pes
url: https://github.com/jla-gardner/graph-pes
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graph-pes-0.0.16-1.src.rpm
location_href: Packages/python-graph-pes-help-0.0.16-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
      <a href="https://jla-gardner.github.io/graph-pes/">
          <img src="docs/source/_static/logo-text.svg" width="90%"/>
      </a>

  `graph-pes` is a framework built to accelerate the development of machine-learned potential energy surface (PES) models that act on graph representations of atomic structures.

  Links: [Google Colab Quickstart](https://colab.research.google.com/github/jla-gardner/graph-pes/blob/main/docs/source/quickstart/quickstart.ipynb) - [Documentation](https://jla-gardner.github.io/graph-pes/) - [PyPI](https://pypi.org/project/graph-pes/)

  [![PyPI](https://img.shields.io/pypi/v/graph-pes)](https://pypi.org/project/graph-pes/)
  [![Tests](https://github.com/jla-gardner/graph-pes/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/jla-gardner/graph-pes/actions/workflows/tests.yaml)
  [![codecov](https://codecov.io/gh/jla-gardner/graph-pes/branch/main/graph/badge.svg)](https://codecov.io/gh/jla-gardner/graph-pes)
  [![GitHub last commit](https://img.shields.io/github/last-commit/jla-gardner/load-atoms)]()

  </div>




  - Experiment with new model architectures by inheriting from our `GraphPESModel` [base class](https://jla-gardner.github.io/graph-pes/models/root.html).
  - [Train your own](https://jla-gardner.github.io/graph-pes/quickstart/implement-a-model.html) or existing model architectures (e.g., [SchNet](https://jla-gardner.github.io/graph-pes/models/many-body/schnet.html), [NequIP](https://jla-gardner.github.io/graph-pes/models/many-body/nequip.html), [PaiNN](https://jla-gardner.github.io/graph-pes/models/many-body/pinn.html), [MACE](https://jla-gardner.github.io/graph-pes/models/many-body/mace.html), [TensorNet](https://jla-gardner.github.io/graph-pes/models/many-body/tensornet.html), etc.).
  - Easily configure distributed training, learning rate scheduling, weights and biases logging, and other features using our `graph-pes-train` [command line interface](https://jla-gardner.github.io/graph-pes/cli/graph-pes-train.html).
  - Use our data-loading pipeline within your [own training loop](https://jla-gardner.github.io/graph-pes/quickstart/custom-training-loop.html).
  - Run molecular dynamics simulations via [LAMMPS](https://jla-gardner.github.io/graph-pes/tools/lammps.html) (or [ASE](https://jla-gardner.github.io/graph-pes/tools/ase.html)) using `pair_style graph_pes` and any `GraphPESModel` - all classes and functions in `graph-pes` are [TorchScriptable](https://pytorch.org/docs/stable/jit.html) 🔥



  ```bash
  pip install -q graph-pes
  wget https://tinyurl.com/graph-pes-minimal-config -O config.yaml
  graph-pes-train config.yaml
  ```

  Alternatively, for a 0-install quickstart experience, please see [this Google Colab](https://colab.research.google.com/github/jla-gardner/graph-pes/blob/main/docs/source/quickstart/quickstart.ipynb), which you can also find in our [documentation](https://jla-gardner.github.io/graph-pes/quickstart/quickstart.html).




  Contributions are welcome! If you find any issues or have suggestions for new features, please open an issue or submit a pull request on the [GitHub repository](https://github.com/jla-gardner/graph-pes).

rpm_license:
  MIT License  Copyright (c) 2023-24 John Gardner  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: 2ac69586b1d0b4fd07dfb15580713f593233e0c7f200ff97b49585558f290018
name: python-graph-pes-help
arch: noarch
version: 0.0.17
epoch: 0
release: 1
summary: Development documents and examples for graph-pes
url: https://github.com/jla-gardner/graph-pes
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graph-pes-0.0.17-1.src.rpm
location_href: Packages/python-graph-pes-help-0.0.17-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
      <a href="https://jla-gardner.github.io/graph-pes/">
          <img src="docs/source/_static/logo-text.svg" width="90%"/>
      </a>

  `graph-pes` is a framework built to accelerate the development of machine-learned potential energy surface (PES) models that act on graph representations of atomic structures.

  Links: [Google Colab Quickstart](https://colab.research.google.com/github/jla-gardner/graph-pes/blob/main/docs/source/quickstart/quickstart.ipynb) - [Documentation](https://jla-gardner.github.io/graph-pes/) - [PyPI](https://pypi.org/project/graph-pes/)

  [![PyPI](https://img.shields.io/pypi/v/graph-pes)](https://pypi.org/project/graph-pes/)
  [![Conda-forge](https://img.shields.io/conda/vn/conda-forge/graph-pes.svg)](https://github.com/conda-forge/graph-pes-feedstock)
  [![Tests](https://github.com/jla-gardner/graph-pes/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/jla-gardner/graph-pes/actions/workflows/tests.yaml)
  [![codecov](https://codecov.io/gh/jla-gardner/graph-pes/branch/main/graph/badge.svg)](https://codecov.io/gh/jla-gardner/graph-pes)
  [![GitHub last commit](https://img.shields.io/github/last-commit/jla-gardner/load-atoms)]()

  </div>




  - Experiment with new model architectures by inheriting from our `GraphPESModel` [base class](https://jla-gardner.github.io/graph-pes/models/root.html).
  - [Train your own](https://jla-gardner.github.io/graph-pes/quickstart/implement-a-model.html) or existing model architectures (e.g., [SchNet](https://jla-gardner.github.io/graph-pes/models/many-body/schnet.html), [NequIP](https://jla-gardner.github.io/graph-pes/models/many-body/nequip.html), [PaiNN](https://jla-gardner.github.io/graph-pes/models/many-body/pinn.html), [MACE](https://jla-gardner.github.io/graph-pes/models/many-body/mace.html), [TensorNet](https://jla-gardner.github.io/graph-pes/models/many-body/tensornet.html), etc.).
  - Easily configure distributed training, learning rate scheduling, weights and biases logging, and other features using our `graph-pes-train` [command line interface](https://jla-gardner.github.io/graph-pes/cli/graph-pes-train.html).
  - Use our data-loading pipeline within your [own training loop](https://jla-gardner.github.io/graph-pes/quickstart/custom-training-loop.html).
  - Run molecular dynamics simulations via [LAMMPS](https://jla-gardner.github.io/graph-pes/tools/lammps.html) (or [ASE](https://jla-gardner.github.io/graph-pes/tools/ase.html)) using `pair_style graph_pes` and any `GraphPESModel` - all classes and functions in `graph-pes` are [TorchScriptable](https://pytorch.org/docs/stable/jit.html) 🔥



  ```bash
  pip install -q graph-pes
  wget https://tinyurl.com/graph-pes-minimal-config -O config.yaml
  graph-pes-train config.yaml
  ```

  Alternatively, for a 0-install quickstart experience, please see [this Google Colab](https://colab.research.google.com/github/jla-gardner/graph-pes/blob/main/docs/source/quickstart/quickstart.ipynb), which you can also find in our [documentation](https://jla-gardner.github.io/graph-pes/quickstart/quickstart.html).




  Contributions are welcome! If you find any issues or have suggestions for new features, please open an issue or submit a pull request on the [GitHub repository](https://github.com/jla-gardner/graph-pes).

rpm_license:
  MIT License  Copyright (c) 2023-24 John Gardner  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: 30f956296f4b7409f1aa80a9caa1c388bd7f27907f3e453947854c8bcc9cc2f3
name: python-graphfusionai-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for graphfusionai
url: https://github.com/graphfusionai/graphfusion
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graphfusionai-0.1.1-1.src.rpm
location_href: Packages/python-graphfusionai-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  **GraphFusionAI** is a powerful library for integrating **dynamic neural memory** with **knowledge graphs**, enabling intelligent graph-based reasoning, contextual updates, and advanced querying for AI applications. The library is designed for flexibility, scalability, and ease of use across domains like conversational AI, healthcare, recommendation systems, and more.

  - [Introduction](#introduction)
  - [Key Features](#key-features)
  - [Installation](#installation)
  - [Quick Start](#quick-start)
  - [Core Components](#core-components)
    - [Graph](#graph)
    - [Dynamic Memory Cell](#dynamic-memory-cell)
    - [Knowledge Graph Embedding](#knowledge-graph-embedding)
  - [Example Use Cases](#example-use-cases)
  - [Documentation](#documentation)
  - [Contributing](#contributing)
  - [License](#license)

  GraphFusionAI combines two critical components of modern AI:
  1. **Knowledge Graphs** for structured representation of relationships between entities.
  2. **Dynamic Neural Memory** to enable context-aware and real-time updates using neural networks.
  By fusing these components, the library allows for:
  - **Querying and reasoning** over complex knowledge graphs.
  - **Dynamic updates** with contextual embeddings.
  - **Seamless integration** with deep learning workflows.
  This makes GraphFusionAI a robust tool for applications like conversational agents, knowledge-based systems, and more.

  - **Graph Management**: Add, query, and manipulate nodes and edges with ease.
  - **Dynamic Neural Memory**: Context-aware updates using GRU-based memory cells.
  - **Graph Embeddings**: Compute embeddings for nodes, edges, and graphs.
  - **Similarity Computation**: Measure semantic similarity between entities in a knowledge graph.
  - **Visualization**: Easily visualize the structure of knowledge graphs.
  - **Integration**: Compatible with tools like PyTorch and NetworkX for seamless workflows.
  - **Scalable and Modular**: Designed for extensibility and scalability for larger graphs and real-world applications.

  To install the library, run the following command:
  ```bash
  pip install graphfusionai
  ```
  Ensure the following dependencies are installed in your environment:
  - `torch`
  - `networkx`
  - `numpy`
  - `matplotlib`
  - `scikit-learn`
  You can also install directly from the source code:
  ```bash
  git clone https://github.com/yourusername/graphfusionai.git
  cd graphfusionai
  pip install .
  ```

  Here is a simple example to get started with GraphFusionAI:

  ```python
  from graphfusionai.graph import Graph

  graph = Graph()

  graph.add_knowledge('Apple', 'is_fruit', 'Fruit')
  graph.add_knowledge('Fruit', 'is_category', 'Food')

  results = graph.query_graph(source='Apple')
  print(f"Query Results: {results}")

  graph.visualize()
  ```
  **Output**:
  ```
  Query Results: [('Apple', 'is_fruit', 'Fruit')]
  ```

  ```python
  from graphfusionai.memory import DynamicMemoryCell
  import torch

  memory_cell = DynamicMemoryCell(input_dim=256, memory_dim=512, context_dim=128)

  input_tensor = torch.randn(256)
  previous_memory = torch.randn(512)

  updated_memory, attention_weights = memory_cell(input_tensor, previous_memory)
  print("Updated Memory:", updated_memory)
  print("Attention Weights:", attention_weights)
  ```


  The `Graph` class enables users to create and manipulate knowledge graphs:
  - **Add knowledge**:
    ```python
    graph.add_knowledge('Entity1', 'relation', 'Entity2')
    ```
  - **Query knowledge**:
    ```python
    graph.query_graph(source='Entity1', relation='relation')
    ```
  - **Visualize**:
    ```python
    graph.visualize()
    ```

  The `DynamicMemoryCell` class models dynamic neural memory using GRU-based updates:
  - **Initialize**:
    ```python
    memory_cell = DynamicMemoryCell(input_dim=256, memory_dim=512, context_dim=128)
    ```
  - **Update memory**:
    ```python
    updated_memory, attention_weights = memory_cell(input_tensor, previous_memory)
    ```

  The `KnowledgeGraphEmbedder` computes embeddings for nodes, relations, and graphs.
  - **Compute Similarity**:
    ```python
    from graphfusionai.embedder import KnowledgeGraphEmbedder
    embedder = KnowledgeGraphEmbedder(graph)
    similarity = embedder.compute_graph_similarity('Entity1', 'Entity2')
    print(f"Similarity: {similarity}")
    ```


  Build conversational agents that can store and retrieve contextual knowledge dynamically.
  ```python
  from graphfusionai.graph import Graph
  graph = Graph()
  graph.add_knowledge('User123', 'asked_about', 'Weather')
  response = graph.query_graph(source='User123')
  print(f"Response: {response}")
  ```

  Model and query patient medical histories with contextual updates.
  ```python
  graph.add_knowledge('Patient123', 'diagnosed_with', 'Diabetes')
  graph.add_knowledge('Patient123', 'prescribed', 'Metformin')
  history = graph.query_graph(source='Patient123')
  print(f"Patient History: {history}")
  ```

  Leverage graph embeddings to compute similarities and recommend items.
  ```python
  similarity = embedder.compute_graph_similarity('Product1', 'Product2')
  print(f"Product Similarity: {similarity}")
  ```

  For a detailed explanation of all methods, classes, and configurations, please refer to the [official documentation](https://github.com/yourusername/graphfusionai).

  We welcome contributions! To contribute:
  1. Fork the repository.
  2. Create a new branch for your feature or bug fix.
  3. Submit a pull request with a detailed explanation.
  To run tests:
  ```bash
  pytest tests/
  ```

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

  For support or collaboration, feel free to reach out:
  **Email**: [hello@GraphFusion.onmicrosoft.com](mailto:hello@GraphFusion.onmicrosoft.com)
  **GitHub**: [https://github.com/GraphFusion/graphfusion](https://github.com/GraphFusion/graphfusion)
  Join our community on Discord: [GraphFusionAI Community](https://discord.gg/f9HtUN2x)


pkgId: 11feacfa0aeef3ef1103747461e41180bd3a501bb7b17a69d1351eb61069b9dc
name: python-graphistry-help
arch: noarch
version: 0.35.2
epoch: 0
release: 1
summary: Development documents and examples for graphistry
url: https://github.com/graphistry/pygraphistry
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graphistry-0.35.2-1.src.rpm
location_href: Packages/python-graphistry-help-0.35.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Build Status](https://github.com/graphistry/pygraphistry/workflows/CI%20Tests/badge.svg)
  [![CodeQL](https://github.com/graphistry/pygraphistry/workflows/CodeQL/badge.svg)](https://github.com/graphistry/pygraphistry/actions?query=workflow%3ACodeQL)
  [![Documentation Status](https://readthedocs.org/projects/pygraphistry/badge/?version=latest)](https://pygraphistry.readthedocs.io/en/latest/)
  [![Latest Version](https://img.shields.io/pypi/v/graphistry.svg)](https://pypi.python.org/pypi/graphistry)
  [![Latest Version](https://img.shields.io/pypi/pyversions/graphistry.svg)](https://pypi.python.org/pypi/graphistry)
  [![License](https://img.shields.io/pypi/l/graphistry.svg)](https://pypi.python.org/pypi/graphistry)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/graphistry)

  [![Uptime Robot status](https://img.shields.io/uptimerobot/status/m787548531-e9c7b7508fc76fea927e2313?label=hub.graphistry.com)](https://status.graphistry.com/) [<img src="https://img.shields.io/badge/slack-Graphistry%20chat-orange.svg?logo=slack">](https://join.slack.com/t/graphistry-community/shared_invite/zt-53ik36w2-fpP0Ibjbk7IJuVFIRSnr6g)
  [![Twitter Follow](https://img.shields.io/twitter/follow/graphistry)](https://twitter.com/graphistry)


  <table style="width:100%;">
    <tr valign="top">
      <td align="center"><a href="https://hub.graphistry.com/graph/graph.html?dataset=Facebook&splashAfter=true" target="_blank"><img src="https://i.imgur.com/z8SIh2E.png" title="Click to open."></a>
      <a href="https://hub.graphistry.com/graph/graph.html?dataset=Facebook&splashAfter=true" target="_blank">Demo: Interactive visualization of 80,000+ Facebook friendships</a> (<a href="http://snap.stanford.edu" target="_blank">source data</a></em>)
      </td>
    </tr>
  </table>

  PyGraphistry is an open source Python library for data scientists and developers to leverage the power of graph visualization, analytics, AI, including with native GPU acceleration:

  * [**Python dataframe-native graph processing:**](https://pygraphistry.readthedocs.io/en/latest/10min.html) Quickly ingest & prepare data in many formats, shapes, and scales as graphs. Use tools like Pandas, Spark, [RAPIDS (GPU)](https://www.rapids.ai), and [Apache Arrow](https://arrow.apache.org/).

  * [**Integrations:**](https://pygraphistry.readthedocs.io/en/latest/plugins.html) Plug into [Amazon Neptune](https://docs.aws.amazon.com/neptune/latest/userguide/visualization-graphistry.html) ([notebook](https://pygraphistry.readthedocs.io/en/latest/demos/demos_databases_apis/neptune/neptune_cypher_viz_using_bolt.html)), [cuGraph](https://pygraphistry.readthedocs.io/en/latest/demos/demos_databases_apis/gpu_rapids/cugraph.html), [Databricks](https://www.databricks.com/solutions/accelerators/incident-investigation-using-graphistry) ([notebook](https://pygraphistry.readthedocs.io/en/latest/demos/demos_databases_apis/databricks_pyspark/graphistry-notebook-dashboard.html)), [graphviz](https://pygraphistry.readthedocs.io/en/latest/demos/demos_databases_apis/graphviz/graphviz.html), [Neo4j](https://pygraphistry.readthedocs.io/en/latest/demos/demos_databases_apis/neo4j/official/graphistry_bolt_tutorial_public.html), [Splunk](https://www.splunk.com/en_us/blog/security/supercharge-cybersecurity-investigations-with-splunk-and-graphistry-a-powerful-combination-for-interactive-graph-exploration.html) ([notebook](https://pygraphistry.readthedocs.io/en/latest/demos/demos_databases_apis/splunk/splunk_demo_public.html)), [TigerGraph](https://pygraphistry.readthedocs.io/en/latest/demos/demos_databases_apis/tigergraph/tigergraph_pygraphistry_bindings.html), and many more in the [notebook data provider demo gallery](https://pygraphistry.readthedocs.io/en/latest/notebooks/plugins.connectors.html).


  * [**Prototype locally and deploy remotely:**](https://www.graphistry.com/get-started) Prototype from notebooks like Jupyter and Databricks using local CPUs & GPUs, and then power production dashboards & pipelines with Graphistry Hub and your own self-hosted servers.

  * [**Query graphs with GFQL:**](https://pygraphistry.readthedocs.io/en/latest/gfql/index.html) Use GFQL, the first dataframe-native graph query language, to ask relationship questions that are difficult for tabular tools and without requiring a database.

  * [**graphistry[ai]:**](https://pygraphistry.readthedocs.io/en/latest/gfql/combo.html#) Call streamlined graph ML & AI methods to benefit from clustering, UMAP embeddings, graph neural networks, automatic feature engineering, and more.

  * [**Visualize & explore large graphs:**](https://pygraphistry.readthedocs.io/en/latest/visualization/10min.html#) In just a few minutes, create stunning interactive visualizations with millions of edges and many point-and-click built-ins like drilldowns, timebars, and filtering. When ready, customize with Python, JavaScript, and REST APIs.

  * [**Columnar & GPU acceleration:**](https://pygraphistry.readthedocs.io/en/latest/performance.html) CPU-mode ingestion and wrangling is fast due to native use of Apache Arrow and columnar analytics, and the optional RAPIDS-based GPU mode delivers 100X+ speedups.


  From global 10 banks, manufacturers, news agencies, and government agencies, to startups, game companies, scientists, biotechs, and NGOs, many teams are tackling their graph workloads with Graphistry.






  The [notebook demo gallery](https://pygraphistry.readthedocs.io/en/latest/demos/for_analysis.html) shares many more live visualizations, demos, and integration examples

  <table>
      <tr valign="top">
          <td width="33%" align="center"><a href="https://hub.graphistry.com/graph/graph.html?dataset=Twitter&splashAfter=true" target="_blank">Twitter Botnet<br><img width="266" src="https://i.imgur.com/qm5MCqS.jpg"></a></td>
          <td width="33%" align="center">Edit Wars on Wikipedia<br><a href="https://i.imgur.com/074zFve.png" target="_blank"><img width="266" src="https://i.imgur.com/074zFve.png"></a><em>(<a href="https://snap.stanford.edu" target="_blank">data</a></em>)</td>
          <td width="33%" align="center"><a href="https://hub.graphistry.com/graph/graph.html?dataset=bitC&splashAfter=true" target="_blank">100,000 Bitcoin Transactions<br><img width="266" height="266" src="https://i.imgur.com/axIkjfd.png"></a></td>
      </tr>
      <tr valign="top">
          <td width="33%" align="center">Port Scan Attack<br><a href="http://i.imgur.com/vKUDySw.png" target="_blank"><img width="266" src="http://i.imgur.com/vKUDySw.png"></a></td>
          <td width="33%" align="center"><a href="http://hub.graphistry.com/graph/graph.html?dataset=PyGraphistry/M9RL4PQFSF&usertag=github&info=true&static=true&contentKey=Biogrid_Github_Demo&play=3000&center=false&menu=true&goLive=false&left=-2.58e+4&right=4.35e+4&top=-1.72e+4&bottom=2.16e+4&legend={%22title%22:%22%3Ch3%3EBioGRID%20Repository%20of%20Protein%20Interactions%3C/h3%3E%22,%22subtitle%22:%22%3Cp%3EEach%20color%20represents%20an%20organism.%20Humans%20are%20in%20light%20blue.%3C/p%3E%22,%22nodes%22:%22Proteins/Genes%22,%22edges%22:%22Interactions%20reported%20in%20scientific%20publications%22}" target="_blank">Protein Interactions <br><img width="266" src="http://i.imgur.com/nrUHLFz.png" target="_blank"></a><em>(<a href="http://thebiogrid.org" target="_blank">data</a>)</em></td>
          <td width="33%" align="center"><a href="http://hub.graphistry.com/graph/graph.html?&dataset=PyGraphistry/PC7D53HHS5&info=true&static=true&contentKey=SocioPlt_Github_Demo&play=3000&center=false&menu=true&goLive=false&left=-236&right=265&top=-145&bottom=134&usertag=github&legend=%7B%22nodes%22%3A%20%22%3Cspan%20style%3D%5C%22color%3A%23a6cee3%3B%5C%22%3ELanguages%3C/span%3E%20/%20%3Cspan%20style%3D%5C%22color%3Argb%28106%2C%2061%2C%20154%29%3B%5C%22%3EStatements%3C/span%3E%22%2C%20%22edges%22%3A%20%22Strong%20Correlations%22%2C%20%22subtitle%22%3A%20%22%3Cp%3EFor%20more%20information%2C%20check%20out%20the%20%3Ca%20target%3D%5C%22_blank%5C%22%20href%3D%5C%22https%3A//lmeyerov.github.io/projects/socioplt/viz/index.html%5C%22%3ESocio-PLT%3C/a%3E%20project.%20Make%20your%20own%20visualizations%20with%20%3Ca%20target%3D%5C%22_blank%5C%22%20href%3D%5C%22https%3A//github.com/graphistry/pygraphistry%5C%22%3EPyGraphistry%3C/a%3E.%3C/p%3E%22%2C%20%22title%22%3A%20%22%3Ch3%3ECorrelation%20Between%20Statements%20about%20Programming%20Languages%3C/h3%3E%22%7D" target="_blank">Programming Languages<br><img width="266" src="http://i.imgur.com/0T0EKmD.png"></a><em>(<a href="http://lmeyerov.github.io/projects/socioplt/viz/index.html" target="_blank">data</a>)</em></td>
      </tr>
  </table>





  Common configurations:

  * **Minimal core**

    Includes: The GFQL dataframe-native graph query language, built-in layouts, Graphistry visualization server client

    ```python
    pip install graphistry
    ```

    Does not include `graphistry[ai]`, plugins

  * **No dependencies and user-level**

    ```python
    pip install --no-deps --user graphistry
    ```

  * **GPU acceleration** - Optional

    Local GPU: Install [RAPIDS](https://www.rapids.ai) and/or deploy a GPU-ready [Graphistry server](https://www.graphistry.com/get-started)

    Remote GPU: Use the [remote endpoints](https://www.graphistry.com/blog/graphistry-2-41-3).

  For further options, see the [installation guides](https://pygraphistry.readthedocs.io/en/latest/install/index.html)




  Quickly go from raw data to a styled and interactive Graphistry graph visualization:

  ```python
  import graphistry
  import pandas as pd


  df = pd.DataFrame({
      'src': ['Alice', 'Bob', 'Carol'],
      'dst': ['Bob', 'Carol', 'Alice'],
      'friendship': [0.3, 0.95, 0.8]
  })


  g1 = graphistry.edges(df, 'src', 'dst')


  g1_styled = g1.encode_edge_color('friendship', ['blue', 'red'], as_continuous=True)


  graphistry.register(api=3, username='your_username', password='your_password')


  g1_styled.plot()
  ```

  Explore [10 Minutes to Graphistry Visualization](https://pygraphistry.readthedocs.io/en/latest/visualization/10min.html) for more visualization examples and options




  **CPU graph pipeline** combining graph ML, AI, mining, and visualization:

  ```python
  from graphistry import n, e, e_forward, e_reverse


  g2 = g1.compute_igraph('pagerank')
  assert 'pagerank' in g2._nodes.columns


  g3 = g2.umap()
  assert ('x' in g3._nodes.columns) and ('y' in g3._nodes.columns)


  g4 = g3.chain([
      n(query='pagerank > 0.1'), e_forward(), n(query='pagerank > 0.1')
  ])
  assert (g4._nodes.pagerank > 0.1).all()


  g4.plot()
  ```

  The **automatic GPU modes** require almost no code changes:

  ```python
  import cudf
  from graphistry import n, e, e_forward, e_reverse


  g1_gpu = g1.edges(cudf.from_pandas(df))
  g2 = g1_gpu.compute_cugraph('pagerank')


  g3 = g2.umap()
  g4 = g3.chain([
      n(query='pagerank > 0.1'), e_forward(), n(query='pagerank > 0.1')
  ])
  g4.plot()
  ```

  Explore [10 Minutes to PyGraphistry](https://pygraphistry.readthedocs.io/en/latest/10min.html) for a wider variety of graph processing.




  * [Main PyGraphistry documentation](https://pygraphistry.readthedocs.io/en/latest/)
  * 10 Minutes to: [PyGraphistry](https://pygraphistry.readthedocs.io/en/latest/10min.html), [Visualization](https://pygraphistry.readthedocs.io/en/latest/visualization/10min.html), [GFQL](https://pygraphistry.readthedocs.io/en/latest/gfql/about.html)
  * Get started: [Install](https://pygraphistry.readthedocs.io/en/latest/install/index.html), [UI Guide](https://hub.graphistry.com/docs/ui/index/), [Notebooks](https://pygraphistry.readthedocs.io/en/latest/demos/for_analysis.html)
  * Performance: [PyGraphistry CPU+GPU](https://pygraphistry.readthedocs.io/en/latest/performance.html) & [GFQL CPU+GPU](https://pygraphistry.readthedocs.io/en/latest/gfql/performance.html)
  * API References
      - [PyGraphistry API Reference](https://pygraphistry.readthedocs.io/en/latest/api/index.html): [Visualization & Compute](https://pygraphistry.readthedocs.io/en/latest/visualization/index.html), [PyGraphistry Cheatsheet](https://pygraphistry.readthedocs.io/en/latest/cheatsheet.html)
      - [GFQL Documentation](https://pygraphistry.readthedocs.io/en/latest/gfql/index.html):  [GFQL Cheatsheet](https://pygraphistry.readthedocs.io/en/latest/gfql/quick.html) and [GFQL Operator Cheatsheet](https://pygraphistry.readthedocs.io/en/latest/gfql/predicates/quick.html)
      - [Plugins](https://pygraphistry.readthedocs.io/en/latest/plugins.html): Databricks, Splunk, Neptune, Neo4j, RAPIDS, and more
      - Web: [iframe](https://hub.graphistry.com/docs/api/1/rest/url/#urloptions),  [JavaScript](https://hub.graphistry.com/static/js-docs/index.html?path=/docs/introduction--docs), [REST](https://hub.graphistry.com/docs/api/1/rest/auth/)



  - **Graphistry server:**
    - Launch - [Graphistry Hub, Graphistry cloud marketplaces, and self-hosting](https://www.graphistry.com/get-started)
    - Self-hosting: [Administration (including Docker)](https://github.com/graphistry/graphistry-cli) & [Kubernetes](https://github.com/graphistry/graphistry-helm)

  - **Graphistry client APIs:**
    - Web: [iframe](https://hub.graphistry.com/docs/api/1/rest/url/#urloptions), [JavaScript](https://hub.graphistry.com/static/js-docs/index.html?path=/docs/introduction--docs), [REST](https://hub.graphistry.com/docs/api/1/rest/auth/)
    - [PyGraphistry](https://pygraphistry.readthedocs.io/en/latest/index.html)
    - [Graphistry for Microsoft PowerBI](https://hub.graphistry.com/docs/powerbi/pbi/)

  - **Additional projects**:
    - [Louie.ai](https://louie.ai/): GenAI-native notebooks & dashboards to talk to your databases & Graphistry
    - [graph-app-kit](https://github.com/graphistry/graph-app-kit): Streamlit Python dashboards with batteries-include graph packages
    - [cu-cat](https://chat.openai.com/chat): Automatic GPU feature engineering




  - [Blog](https://www.graphistry.com/blog) for tutorials, case studies, and updates
  - [Slack](https://join.slack.com/t/graphistry-community/shared_invite/zt-53ik36w2-fpP0Ibjbk7IJuVFIRSnr6g): Join the Graphistry Community Slack for discussions and support
  - [Twitter](https://twitter.com/graphistry) & [LinkedIn](https://www.linkedin.com/company/graphistry): Follow for updates
  - [GitHub Issues](https://github.com/graphistry/pygraphistry/issues) open source support
  - [Graphistry ZenDesk](https://graphistry.zendesk.com/) dedicated enterprise support



  See [CONTRIBUTE](https://pygraphistry.readthedocs.io/en/latest/CONTRIBUTE.html) and [DEVELOP](https://pygraphistry.readthedocs.io/en/latest/DEVELOP.html) for participating in PyGraphistry development, or reach out to our team


pkgId: a747d7adf18bbe0370265477d820215dce2a48c67bb0d9d8be05d068310fcecd
name: python-graphiti-core-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for graphiti-core
url: https://pypi.org/project/graphiti-core/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graphiti-core-0.5.0-1.src.rpm
location_href: Packages/python-graphiti-core-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  <img width="350" alt="Graphiti-ts-small" src="https://github.com/user-attachments/assets/bbd02947-e435-4a05-b25a-bbbac36d52c8">



  <br />

  [![Discord](https://dcbadge.vercel.app/api/server/W8Kw6bsgXQ?style=flat)](https://discord.com/invite/W8Kw6bsgXQ)
  [![Lint](https://github.com/getzep/Graphiti/actions/workflows/lint.yml/badge.svg)](https://github.com/getzep/Graphiti/actions/workflows/lint.yml)
  [![Unit Tests](https://github.com/getzep/Graphiti/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/getzep/Graphiti/actions/workflows/unit_tests.yml)
  [![MyPy Check](https://github.com/getzep/Graphiti/actions/workflows/typecheck.yml/badge.svg)](https://github.com/getzep/Graphiti/actions/workflows/typecheck.yml)
  [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/getzep/Graphiti)

  <br />

  </div>

  Graphiti builds dynamic, temporally aware Knowledge Graphs that represent complex, evolving relationships between
  entities over time. Graphiti ingests both unstructured and structured data, and the resulting graph may be queried using
  a fusion of time, full-text, semantic, and graph algorithm approaches.

  <br />

  <p align="center">
      <img src="/images/graphiti-graph-intro.gif" alt="Graphiti temporal walkthrough" width="700px">
  </p>

  <br />

  Graphiti helps you create and query Knowledge Graphs that evolve over time. A knowledge graph is a network of
  interconnected facts, such as _“Kendra loves Adidas shoes.”_ Each fact is a “triplet” represented by two entities, or
  nodes (_”Kendra”_, _“Adidas shoes”_), and their relationship, or edge (_”loves”_). Knowledge Graphs have been explored
  extensively for information retrieval. What makes Graphiti unique is its ability to autonomously build a knowledge graph
  while handling changing relationships and maintaining historical context.

  With Graphiti, you can build LLM applications such as:

  - Assistants that learn from user interactions, fusing personal knowledge with dynamic data from business systems like
    CRMs and billing platforms.
  - Agents that autonomously execute complex tasks, reasoning with state changes from multiple dynamic sources.

  Graphiti supports a wide range of applications in sales, customer service, health, finance, and more, enabling long-term
  recall and state-based reasoning for both assistants and agents.



  We were intrigued by Microsoft’s GraphRAG, which expanded on RAG text chunking by using a graph to better model a
  document corpus and making this representation available via semantic and graph search techniques. However, GraphRAG did
  not address our core problem: It's primarily designed for static documents and doesn't inherently handle temporal
  aspects of data.

  Graphiti is designed from the ground up to handle constantly changing information, hybrid semantic and graph search, and
  scale:

  - **Temporal Awareness:** Tracks changes in facts and relationships over time, enabling point-in-time queries. Graph
    edges include temporal metadata to record relationship lifecycles.
  - **Episodic Processing:** Ingests data as discrete episodes, maintaining data provenance and allowing incremental
    entity and relationship extraction.
  - **Hybrid Search:** Combines semantic and BM25 full-text search, with the ability to rerank results by distance from a
    central node e.g. “Kendra”.
  - **Scalable:** Designed for processing large datasets, with parallelization of LLM calls for bulk processing while
    preserving the chronology of events.
  - **Supports Varied Sources:** Can ingest both unstructured text and structured JSON data.

  <p align="center">
      <img src="/images/graphiti-intro-slides-stock-2.gif" alt="Graphiti structured + unstructured demo" width="700px">
  </p>



  Graphiti powers the core of [Zep's memory layer](https://www.getzep.com) for LLM-powered Assistants and Agents.

  We're excited to open-source Graphiti, believing its potential reaches far beyond memory applications.



  Requirements:

  - Python 3.10 or higher
  - Neo4j 5.21 or higher
  - OpenAI API key (for LLM inference and embedding)

  Optional:

  - Anthropic or Groq API key (for alternative LLM providers)

  > [!TIP]
  > The simplest way to install Neo4j is via [Neo4j Desktop](https://neo4j.com/download/). It provides a user-friendly
  > interface to manage Neo4j instances and databases.

  ```bash
  pip install graphiti-core
  ```

  or

  ```bash
  poetry add graphiti-core
  ```



  > [!IMPORTANT]
  > Graphiti uses OpenAI for LLM inference and embedding. Ensure that an `OPENAI_API_KEY` is set in your environment.
  > Support for Anthropic and Groq LLM inferences is available, too.

  ```python
  from graphiti_core import Graphiti
  from graphiti_core.nodes import EpisodeType
  from datetime import datetime, timezone


  graphiti = Graphiti("bolt://localhost:7687", "neo4j", "password")


  graphiti.build_indices_and_constraints()


  episodes = [
      "Kamala Harris is the Attorney General of California. She was previously "
      "the district attorney for San Francisco.",
      "As AG, Harris was in office from January 3, 2011 – January 3, 2017",
  ]
  for i, episode in enumerate(episodes):
      await graphiti.add_episode(
          name=f"Freakonomics Radio {i}",
          episode_body=episode,
          source=EpisodeType.text,
          source_description="podcast",
          reference_time=datetime.now(timezone.utc)
      )




  results = await graphiti.search('Who was the California Attorney General?')
  [
      EntityEdge(
  │   uuid = '3133258f738e487383f07b04e15d4ac0',
  │   source_node_uuid = '2a85789b318d4e418050506879906e62',
  │   target_node_uuid = 'baf7781f445945989d6e4f927f881556',
  │   created_at = datetime.datetime(2024, 8, 26, 13, 13, 24, 861097),
  │   name = 'HELD_POSITION',


  │   fact = 'Kamala Harris was the Attorney General of California',
  │   fact_embedding = [
  │   │   -0.009955154731869698,
  │       ...
  │   │   0.00784289836883545
  │],
  │   episodes = ['b43e98ad0a904088a76c67985caecc22'],
  │   expired_at = datetime.datetime(2024, 8, 26, 20, 18, 1, 53812),

  │   valid_at = datetime.datetime(2011, 1, 3, 0, 0, tzinfo= < UTC >),
  │   invalid_at = datetime.datetime(2017, 1, 3, 0, 0, tzinfo= < UTC >)
  )
  ]




  await graphiti.search('Who was the California Attorney General?', center_node_uuid)


  graphiti.close()
  ```



  The `server` directory contains an API service for interacting with the Graphiti API. It is built using FastAPI.

  Please see the [server README](./server/README.md) for more information.



  In addition to the Neo4j and OpenAi-compatible credentials, Graphiti also has a few optional environment variables.
  If you are using one of our supported models, such as Anthropic or Voyage models, the necessary environment variables
  must be set.

  `USE_PARALLEL_RUNTIME` is an optional boolean variable that can be set to true if you wish
  to enable Neo4j's parallel runtime feature for several of our search queries.
  Note that this feature is not supported for Neo4j Community edition or for smaller AuraDB instances,
  as such this feature is off by default.



  - [Guides and API documentation](https://help.getzep.com/graphiti).
  - [Quick Start](https://help.getzep.com/graphiti/graphiti/quick-start)
  - [Building an agent with LangChain's LangGraph and Graphiti](https://help.getzep.com/graphiti/graphiti/lang-graph-agent)



  Graphiti is under active development. We aim to maintain API stability while working on:

  - [x] Implementing node and edge CRUD operations
  - [ ] Improving performance and scalability
  - [ ] Achieving good performance with different LLM and embedding models
  - [x] Creating a dedicated embedder interface
  - [ ] Supporting custom graph schemas:
      - Allow developers to provide their own defined node and edge classes when ingesting episodes
      - Enable more flexible knowledge representation tailored to specific use cases
  - [x] Enhancing retrieval capabilities with more robust and configurable options
  - [ ] Expanding test coverage to ensure reliability and catch edge cases



  We encourage and appreciate all forms of contributions, whether it's code, documentation, addressing GitHub Issues, or
  answering questions in the Graphiti Discord channel. For detailed guidelines on code contributions, please refer
  to [CONTRIBUTING](CONTRIBUTING.md).



  Join the [Zep Discord server](https://discord.com/invite/W8Kw6bsgXQ) and make your way to the **#Graphiti** channel!


pkgId: 95de97defc3535dc9061881a9ae22e3a917164471d5df3f9c5c4b7028baea892
name: python-graphlit-client-help
arch: noarch
version: 1.0.20241213001
epoch: 0
release: 1
summary: Development documents and examples for graphlit-client
url: https://github.com/graphlit/graphlit-client-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graphlit-client-1.0.20241213001-1.src.rpm
location_href: Packages/python-graphlit-client-help-1.0.20241213001-1.noarch.rpm
checksum_type: sha256
description:
  The Graphlit Client for Python enables easy interaction with the Graphlit API, allowing developers to execute queries and mutations against the Graphlit service. This document outlines the setup process and provides a basic example of using the client.



  Before you begin, ensure you have the following:

  - Python 3.x installed on your system.
  - An active account on the [Graphlit Platform](https://portal.graphlit.dev) with access to the API settings dashboard.



  To install the Graphlit Client, use pip:

  ```bash
  pip install graphlit-client
  ```



  The Graphlit Client supports environment variables to be set for authentication and configuration:

  - `GRAPHLIT_ENVIRONMENT_ID`: Your environment ID.
  - `GRAPHLIT_ORGANIZATION_ID`: Your organization ID.
  - `GRAPHLIT_JWT_SECRET`: Your JWT secret for signing the JWT token.

  Alternately, you can pass these values with the constructor of the Graphlit client.

  You can find these values in the API settings dashboard on the [Graphlit Platform](https://portal.graphlit.dev).

  For example, to use Graphlit in a Google Colab notebook, you need to assign these properties as Colab secrets: GRAPHLIT_ORGANIZATION_ID, GRAPHLIT_ENVIRONMENT_ID and GRAPHLIT_JWT_SECRET.

  ```python
  import os
  from google.colab import userdata
  from graphlit import Graphlit

  os.environ['GRAPHLIT_ORGANIZATION_ID'] = userdata.get('GRAPHLIT_ORGANIZATION_ID')
  os.environ['GRAPHLIT_ENVIRONMENT_ID'] = userdata.get('GRAPHLIT_ENVIRONMENT_ID')
  os.environ['GRAPHLIT_JWT_SECRET'] = userdata.get('GRAPHLIT_JWT_SECRET')

  graphlit = Graphlit()
  ```



  To set these environment variables on your system, use the following commands, replacing `your_value` with the actual values from your account.

  For Unix/Linux/macOS:

  ```bash
  export GRAPHLIT_ENVIRONMENT_ID=your_environment_id_value
  export GRAPHLIT_ORGANIZATION_ID=your_organization_id_value
  export GRAPHLIT_JWT_SECRET=your_secret_key_value
  ```

  For Windows Command Prompt (CMD):

  ```cmd
  set GRAPHLIT_ENVIRONMENT_ID=your_environment_id_value
  set GRAPHLIT_ORGANIZATION_ID=your_organization_id_value
  set GRAPHLIT_JWT_SECRET=your_secret_key_value
  ```

  For Windows PowerShell:

  ```powershell
  $env:GRAPHLIT_ENVIRONMENT_ID="your_environment_id_value"
  $env:GRAPHLIT_ORGANIZATION_ID="your_organization_id_value"
  $env:GRAPHLIT_JWT_SECRET="your_secret_key_value"
  ```



  Please refer to the [Graphlit API Documentation](https://docs.graphlit.dev/).

  For support with the Graphlit Client, please submit a [GitHub Issue](https://github.com/graphlit/graphlit-client-python/issues).

  For further support with the Graphlit Platform, please join our [Discord](https://discord.gg/ygFmfjy3Qx) community.


pkgId: dd253e93a5993beedf9633548819d8c8f9093bd306fa49c4d01117d44cf3f9f0
name: python-graphlit-tools-help
arch: noarch
version: 1.0.20241214004
epoch: 0
release: 1
summary: Development documents and examples for graphlit-tools
url: https://github.com/graphlit/graphlit-tools-python/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graphlit-tools-1.0.20241214004-1.src.rpm
location_href: Packages/python-graphlit-tools-help-1.0.20241214004-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/graphlit-tools.svg)](https://badge.fury.io/py/graphlit-tools)





  The Graphlit Agent Tools for Python enables easy interaction with agent frameworks such as [CrewAI](https://crewai.com), allowing developers to easily integrate the Graphlit service with agentic workflows. This document outlines the setup process and provides a basic example of using the tools.



  Before you begin, ensure you have the following:

  - Python 3.x installed on your system.
  - An active account on the [Graphlit Platform](https://portal.graphlit.dev) with access to the API settings dashboard.



  To install the Graphlit Agent Tools with CrewAI, use pip:

  ```bash
  pip install graphlit-tools[crewai]
  ```



  We have example Google Colab notebooks using CrewAI, which provide an example for [analyzing the web marketing strategy of a company](https://colab.research.google.com/github/graphlit/graphlit-samples/blob/main/python/Notebook%20Examples/Graphlit_2024_12_07_CrewAI_Web_Marketing_Analyzer.ipynb), and for [structured data extraction of products from scraped web pages](https://colab.research.google.com/github/graphlit/graphlit-samples/blob/main/python/Notebook%20Examples/Graphlit_2024_12_08_CrewAI_Product_Data_Extraction.ipynb).

  Once you have configured the Graphlit client, as shown below, you will pass the client to the tool constructor.

  For use in CrewAI, you will need to convert the tool to the CrewAI tool schema with the `CrewAIConverter.from_tool()` function.  We will provide support for additional agent frameworks, such as LangGraph and AutoGen in future.

  ```python
  from graphlit_tools import WebSearchTool, CrewAIConverter

  web_search_tool = CrewAIConverter.from_tool(WebSearchTool(graphlit))

  web_search_agent = Agent(
      role="Web Researcher",
      goal="Find the {company} website.",
      backstory="",
      verbose=True,
      allow_delegation=False,
      tools=[web_search_tool],
  )
  ```



  The Graphlit Client supports environment variables to be set for authentication and configuration:

  - `GRAPHLIT_ENVIRONMENT_ID`: Your environment ID.
  - `GRAPHLIT_ORGANIZATION_ID`: Your organization ID.
  - `GRAPHLIT_JWT_SECRET`: Your JWT secret for signing the JWT token.

  Alternately, you can pass these values with the constructor of the Graphlit client.

  You can find these values in the API settings dashboard on the [Graphlit Platform](https://portal.graphlit.dev).

  For example, to use Graphlit in a Google Colab notebook, you need to assign these properties as Colab secrets: GRAPHLIT_ORGANIZATION_ID, GRAPHLIT_ENVIRONMENT_ID and GRAPHLIT_JWT_SECRET.

  ```python
  import os
  from google.colab import userdata
  from graphlit import Graphlit

  os.environ['GRAPHLIT_ORGANIZATION_ID'] = userdata.get('GRAPHLIT_ORGANIZATION_ID')
  os.environ['GRAPHLIT_ENVIRONMENT_ID'] = userdata.get('GRAPHLIT_ENVIRONMENT_ID')
  os.environ['GRAPHLIT_JWT_SECRET'] = userdata.get('GRAPHLIT_JWT_SECRET')

  graphlit = Graphlit()
  ```



  To set these environment variables on your system, use the following commands, replacing `your_value` with the actual values from your account.

  For Unix/Linux/macOS:

  ```bash
  export GRAPHLIT_ENVIRONMENT_ID=your_environment_id_value
  export GRAPHLIT_ORGANIZATION_ID=your_organization_id_value
  export GRAPHLIT_JWT_SECRET=your_secret_key_value
  ```

  For Windows Command Prompt (CMD):

  ```cmd
  set GRAPHLIT_ENVIRONMENT_ID=your_environment_id_value
  set GRAPHLIT_ORGANIZATION_ID=your_organization_id_value
  set GRAPHLIT_JWT_SECRET=your_secret_key_value
  ```

  For Windows PowerShell:

  ```powershell
  $env:GRAPHLIT_ENVIRONMENT_ID="your_environment_id_value"
  $env:GRAPHLIT_ORGANIZATION_ID="your_organization_id_value"
  $env:GRAPHLIT_JWT_SECRET="your_secret_key_value"
  ```



  - [Content Ingestion](#content-ingestion)
  - [RAG](#rag)
  - [Data Retrieval](#data-retrieval)
  - [Content Generation](#content-generation)
  - [Image Description](#image-description)
  - [Data Extraction](#data-extraction)





  Ingests content from URL.
  Returns extracted Markdown text and metadata from content.
  Can ingest individual Word documents, PDFs, audio recordings, videos, images, or any other unstructured data.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | url | str | URL of cloud-hosted file to be ingested into knowledge base |



  Ingests content from local file.
  Returns extracted Markdown text and metadata from content.
  Can ingest individual Word documents, PDFs, audio recordings, videos, images, or any other unstructured data.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | file_path | str | Path of local file to be ingested into knowledge base |



  Scrapes web page into knowledge base.
  Returns Markdown text and metadata extracted from web page.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | url | str | URL of web page to be scraped and ingested into knowledge base |



  Crawls web pages from web site into knowledge base.
  Returns Markdown text and metadata extracted from web pages.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | url | str | URL of web site to be crawled and ingested into knowledge base |
  | search | Optional[str] | Text to search for within ingested web pages |
  | read_limit | Optional[int] | Maximum number of web pages from web site to be crawled |



  Accepts search query text as string.
  Performs web search based on search query.
  Returns Markdown text and metadata extracted from web pages.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | search | str | Text to search for within web pages across the Internet |
  | search_limit | Optional[int] | Maximum number of web pages to be returned from web search |



  Accepts web page URL as string.
  Enumerates the web pages at or beneath the provided URL using web sitemap.
  Returns list of mapped URIs from web site.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | url | str | URL of the web page to be mapped |



  Ingests posts from Reddit subreddit into knowledge base.
  Returns extracted Markdown text and metadata from Reddit posts.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | subreddit_name | str | Reddit subreddit name to be read and ingested into knowledge base |
  | search | Optional[str] | Text to search for within ingested posts |
  | read_limit | Optional[int] | Maximum number of posts from Reddit subreddit to be read, defaults to 10 |



  Ingests pages from Notion database into knowledge base.
  Returns extracted Markdown text and metadata from Notion pages.

  Requires NOTION_API_KEY to be assigned as environment variable.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | search | Optional[str] | Text to search for within ingested pages |
  | read_limit | Optional[int] | Maximum number of pages from Notion database to be read, defaults to 10 |



  Ingests posts from RSS feed into knowledge base.
  For podcast RSS feeds, audio will be transcribed and ingested into knowledge base.
  Returns extracted or transcribed Markdown text and metadata from RSS posts.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | url | str | RSS URL to be read and ingested into knowledge base |
  | search | Optional[str] | Text to search for within ingested posts and/or transcripts |
  | read_limit | Optional[int] | Maximum number of posts from RSS feed to be read, defaults to 10 |



  Ingests emails from Microsoft Email account into knowledge base.
  Returns extracted Markdown text and metadata from emails.

  Requires MICROSOFT_EMAIL_CLIENT_ID, MICROSOFT_EMAIL_CLIENT_SECRET and MICROSOFT_EMAIL_REFRESH_TOKEN to be assigned as environment variables.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | search | Optional[str] | Text to search for within ingested email |
  | read_limit | Optional[int] | Maximum number of emails from Microsoft Email account to be read, defaults to 10 |



  Ingests emails from Google Email account into knowledge base.
  Returns extracted Markdown text and metadata from emails.

  Requires GOOGLE_EMAIL_CLIENT_ID, GOOGLE_EMAIL_CLIENT_SECRET and GOOGLE_EMAIL_REFRESH_TOKEN to be assigned as environment variables.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | search | Optional[str] | Text to search for within ingested email |
  | read_limit | Optional[int] | Maximum number of emails from Google Email account to be read, defaults to 10 |



  Ingests issues from GitHub repository into knowledge base.
  Accepts GitHub repository owner and repository name.
  For example, for GitHub repository (https://github.com/openai/tiktoken), 'openai' is the repository owner, and 'tiktoken' is the repository name.
  Returns extracted Markdown text and metadata from issues.

  Requires GITHUB_PERSONAL_ACCESS_TOKEN to be assigned as environment variable.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | repository_name | str | GitHub repository name |
  | repository_owner | str | GitHub repository owner |
  | search | Optional[str] | Text to search for within ingested issues |
  | read_limit | Optional[int] | Maximum number of issues from GitHub repository to be read, defaults to 10 |



  Ingests issues from Atlassian Jira into knowledge base.
  Accepts Atlassian Jira server URL and project name.
  Returns extracted Markdown text and metadata from issues.

  Requires JIRA_TOKEN and JIRA_EMAIL to be assigned as environment variables.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | url | str | Atlassian Jira server URL |
  | project | str | Atlassian Jira project name |
  | search | Optional[str] | Text to search for within ingested issues |
  | read_limit | Optional[int] | Maximum number of issues from Jira project to be read, defaults to 10 |



  Ingests issues from Linear project into knowledge base.
  Accepts Linear project name.
  Returns extracted Markdown text and metadata from issues.

  Requires LINEAR_API_KEY to be assigned as environment variable.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | project | str | Linear project name |
  | search | Optional[str] | Text to search for within ingested issues |
  | read_limit | Optional[int] | Maximum number of issues from Linear project to be read, defaults to 10 |



  Ingests messages from Microsoft Teams channel into knowledge base.
  Returns extracted Markdown text and metadata from messages.

  Requires MICROSOFT_TEAMS_CLIENT_ID, MICROSOFT_TEAMS_CLIENT_SECRET and MICROSOFT_TEAMS_REFRESH_TOKEN to be assigned as environment variables.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | team_name | str | Microsoft Teams team name |
  | channel_name | str | Microsoft Teams channel name |
  | search | Optional[str] | Text to search for within ingested messages |
  | read_limit | Optional[int] | Maximum number of messages from Microsoft Teams channel to be read, defaults to 10 |



  Ingests messages from Discord channel into knowledge base.
  Accepts Discord channel name.
  Returns extracted Markdown text and metadata from messages.

  Requires DISCORD_BOT_TOKEN to be assigned as environment variable.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | channel_name | str | Discord channel name |
  | search | Optional[str] | Text to search for within ingested messages |
  | read_limit | Optional[int] | Maximum number of messages from Discord channel to be read, defaults to 10 |



  Ingests messages from Slack channel into knowledge base.
  Accepts Slack channel name.
  Returns extracted Markdown text and metadata from messages.

  Requires SLACK_BOT_TOKEN to be assigned as environment variable.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | channel_name | str | Slack channel name |
  | search | Optional[str] | Text to search for within ingested messages |
  | read_limit | Optional[int] | Maximum number of messages from Slack channel to be read, defaults to 10 |





  Accepts user prompt as string.
  Prompts LLM with relevant content and returns completion from RAG pipeline. Returns Markdown text from LLM completion.
  Uses vector embeddings and similarity search to retrieve relevant content from knowledge base.
  Can search through web pages, PDFs, audio transcripts, and other unstructured data.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | prompt | str | Text prompt which is provided to LLM for completion, via RAG pipeline |





  Accepts search text as string.
  Optionally accepts a list of content types (i.e. FILE, PAGE, EMAIL, ISSUE, MESSAGE) for filtering the result set.
  Retrieves contents based on similarity search from knowledge base.
  Returns extracted Markdown text and metadata from contents relevant to the search text.
  Can search through web pages, PDFs, audio transcripts, Slack messages, emails, or any unstructured data ingested into the knowledge base.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | text | str | Text to search for within the knowledge base |
  | types | Optional[List[ContentTypes]] | List of content types (i.e. FILE, PAGE, EMAIL, ISSUE, MESSAGE) to be returned from knowledge base |
  | limit | Optional[int] | Number of contents to return from search query |



  Accepts search text as string.
  Retrieves persons based on similarity search from knowledge base.
  Returns metadata from persons relevant to the search text.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | search | str | Text to search for within the knowledge base |
  | limit | Optional[int] | Number of persons to return from search query |



  Accepts search text as string.
  Retrieves organizations based on similarity search from knowledge base.
  Returns metadata from organizations relevant to the search text.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | search | str | Text to search for within the knowledge base |
  | limit | Optional[int] | Number of organizations to return from search query |





  Accepts image URL as string.
  Prompts vision LLM and returns completion. Returns Markdown text from LLM completion.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | url | str | URL for image to be described with vision LLM |
  | prompt | str | Text prompt which is provided to vision LLM for completion |



  Screenshots web page from URL and describes web page with vision LLM.
  Returns Markdown description of screenshot and extracted Markdown text from image.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | url | str | URL of web page to screenshot and ingest into knowledge base |
  | prompt | Optional[str] | Text prompt which is provided to vision LLM for screenshot description |





  Accepts text as string.
  Optionally accepts text prompt to be provided to LLM for text summarization.
  Returns summary as text.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | text | str | Text to be summarized |
  | prompt | Optional[str] | Text prompt which is provided to LLM for text summarization |



  Accepts text as string.
  Optionally accepts the count of bullet points to be generated.
  Returns bullet points as text.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | text | str | Text to be summarized into bullet points |
  | count | Optional[int] | Number of bullet points to be generated |



  Accepts text as string.
  Optionally accepts the count of headlines to be generated.
  Returns headlines as text.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | text | str | Text to be summarized into headlines |
  | count | Optional[int] | Number of headlines to be generated |



  Accepts text as string.
  Optionally accepts the count of social media posts to be generated.
  Returns social media posts as text.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | text | str | Text to be summarized into social media posts |
  | count | Optional[int] | Number of social media posts to be generated |



  Accepts text as string.
  Optionally accepts the count of followup questions to be generated.
  Returns followup questions as text.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | text | str | Text to be summarized into followup questions |
  | count | Optional[int] | Number of followup questions to be generated |



  Accepts text as string.
  Optionally accepts the count of keywords to be generated.
  Returns keywords as text.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | text | str | Text to be summarized into keywords |
  | count | Optional[int] | Number of keywords to be generated |



  Accepts transcript as string.
  Returns chapters as text.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | text | str | Transcript to be summarized into chapters. Assumes transcript contains time-stamped text. |





  Extracts JSON data from ingested file using LLM.
  Accepts URL to be ingested, and JSON schema of Pydantic model to be extracted into. JSON schema needs be of type 'object' and include 'properties' and 'required' fields.
  Returns extracted JSON from file.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | uri | str | URL of cloud-hosted file to be ingested into knowledge base |
  | model_schema | str | Pydantic model JSON schema which describes the data which will be extracted. JSON schema needs be of type 'object' and include 'properties' and 'required' fields. |
  | prompt | Optional[str] | Text prompt which is provided to LLM to guide data extraction |



  Extracts JSON data from ingested web page using LLM.
  Accepts URL to be scraped, and JSON schema of Pydantic model to be extracted into. JSON schema needs be of type 'object' and include 'properties' and 'required' fields.
  Returns extracted JSON from web page.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | uri | str | URL of web page to be scraped and ingested into knowledge base |
  | model_schema | str | Pydantic model JSON schema which describes the data which will be extracted. JSON schema needs be of type 'object' and include 'properties' and 'required' fields. |
  | prompt | Optional[str] | Text prompt which is provided to LLM to guide data extraction |



  Extracts JSON data from text using LLM.
  Accepts text to be scraped, and JSON schema of Pydantic model to be extracted into. JSON schema needs be of type 'object' and include 'properties' and 'required' fields.
  Returns extracted JSON from text.


  | Name | Type | Description |
  | ---- | ---- | ---- |
  | text | str | Text to be extracted with LLM |
  | model_schema | str | Pydantic model JSON schema which describes the data which will be extracted. JSON schema needs be of type 'object' and include 'properties' and 'required' fields. |
  | prompt | Optional[str] | Text prompt which is provided to LLM to guide data extraction |



  Please refer to the [Graphlit API Documentation](https://docs.graphlit.dev/).

  For support with the Graphlit Agent Tools or to request an additional tool, please submit a [GitHub Issue](https://github.com/graphlit/graphlit-tools-python/issues).

  For further support with the Graphlit Platform, please join our [Discord](https://discord.gg/ygFmfjy3Qx) community.


pkgId: 898cf3d70c52f8b5542441980ef81f2d9b5ec3efabaa915fc1c1e81be9848bb4
name: python-graphrag_sdk-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for graphrag_sdk
url: http://RAG-SDK.readthedocs.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graphrag_sdk-0.4.0-1.src.rpm
location_href: Packages/python-graphrag_sdk-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Dockerhub](https://img.shields.io/docker/pulls/falkordb/falkordb?label=Docker)](https://hub.docker.com/r/falkordb/falkordb/)
  [![pypi](https://badge.fury.io/py/graphrag_sdk.svg)](https://pypi.org/project/graphrag_sdk/)
  [![Discord](https://img.shields.io/discord/1146782921294884966?style=flat-square)](https://discord.gg/6M4QwDXn2w)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](code_of_conduct.md)
  <p align="center">
    <img alt="FalkorDB GraphRAG-SDK README Banner" src="images/FalkorDB GraphRAG-SDK README Banner.png" width="1500">
  </p>



  Simplify the development of your next GenAI application with GraphRAG-SDK, a specialized toolkit for building Graph Retrieval-Augmented Generation (GraphRAG) systems. It integrates knowledge graphs, ontology management, and state-of-the-art LLMs to deliver accurate, efficient, and customizable RAG workflows.




  [![Try Free](https://img.shields.io/badge/Try%20Free-FalkorDB%20Cloud-FF8101?labelColor=FDE900&style=for-the-badge&link=https://app.falkordb.cloud)](https://app.falkordb.cloud)

  Or use on premise with Docker:

  ```sh
  docker run -p 6379:6379 -p 3000:3000 -it --rm  -v ./data:/data falkordb/falkordb:latest
  ```


  ```sh

  pip install graphrag_sdk[all]


  pip install graphrag_sdk[litellm]
  ```



  * [LiteLLM](https://docs.litellm.ai): A framework supporting inference of large language models, allowing flexibility in deployment and use cases.
  * [OpenAI](https://openai.com/index/openai-api) Recommended model:`gpt-4o`
  * [Google](https://makersuite.google.com/app/apikey) Recommended model:`gemini-2.0-flash-exp`
  * [Azure-OpenAI](https://ai.azure.com) Recommended model:`gpt-4o`
  * [Ollama](https://ollama.com/) Available only to the Q&A step. Recommended models: `llama3`. Ollama models are suitable for the Q&A step only (after the knowledge graph (KG) created).





  Automate ontology creation from unstructured data or define it manually.

  ```python
  from dotenv import load_dotenv

  from graphrag_sdk.source import URL
  from graphrag_sdk import KnowledgeGraph, Ontology
  from graphrag_sdk.models.litellm import LiteModel
  from graphrag_sdk.model_config import KnowledgeGraphModelConfig
  load_dotenv()


  urls = ["https://www.rottentomatoes.com/m/side_by_side_2012",
  "https://www.rottentomatoes.com/m/matrix",
  "https://www.rottentomatoes.com/m/matrix_revolutions",
  "https://www.rottentomatoes.com/m/matrix_reloaded",
  "https://www.rottentomatoes.com/m/speed_1994",
  "https://www.rottentomatoes.com/m/john_wick_chapter_4"]

  sources = [URL(url) for url in urls]


  model = LiteModel(model_name="gemini/gemini-2.0-flash-exp")


  ontology = Ontology.from_sources(
      sources=sources,
      model=model,
  )

  with open("ontology.json", "w", encoding="utf-8") as file:
      file.write(json.dumps(ontology.to_json(), indent=2))
  ```


  Build, query, and manage knowledge graphs optimized for retrieval and augmentation tasks.
  Leverages FalkorDB for high-performance graph querying and multi-tenancy.

  ```python

  ontology_file = "ontology.json"
  with open(ontology_file, "r", encoding="utf-8") as file:
      ontology = Ontology.from_json(json.loads(file.read()))

  kg = KnowledgeGraph(
      name="kg_name",
      model_config=KnowledgeGraphModelConfig.with_model(model),
      ontology=ontology,
      host="127.0.0.1",
      port=6379,
      
      
  )

  kg.process_sources(sources)
  ```



  At this point, you have a Knowledge Graph that can be queried using this SDK. Use the method `chat_session` for start a conversation.

  ```python

  chat = kg.chat_session()
  response = chat.send_message("Who is the director of the movie The Matrix?")
  print(response)
  response = chat.send_message("How this director connected to Keanu Reeves?")
  print(response)
  ```


  With these 3 steps now completed, you're ready to interact and query your knowledge graph.  Here are suggestions for use cases:
  <p align="left">
    <img alt="GraphRAG-SDK Use Cases Banner from FalkorDB" src="images/use-cases.png" width="800">
  </p>

  **Need help with your use case? let's [talk](https://www.falkordb.com/get-demo/)**

  <br />




  The GraphRAG-SDK supports Knowledge Graph-based agents. Each agent is an expert in his domain, and the orchestrator orchestrates the agents.

  Check out the example:

  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/FalkorDB/GraphRAG-SDK/blob/main/examples/trip/demo_orchestrator_trip.ipynb)




  See the [Step 1](#how-to-use) section to understand how to create Knowledge Graph objects for the agents.

  ```python

  model = LiteModel(model_name="gemini/gemini-2.0-flash-exp")



  restaurants_kg = KnowledgeGraph(
      name="restaurants",
      ontology=restaurants_ontology,
      model_config=KnowledgeGraphModelConfig.with_model(model),
      host="127.0.0.1",
      port=6379,
      
      
  )
  attractions_kg = KnowledgeGraph(
      name="attractions",
      ontology=attractions_ontology,
      model_config=KnowledgeGraphModelConfig.with_model(model),
      host="127.0.0.1",
      port=6379,
      
      
  )



  restaurants_agent = KGAgent(
      agent_id="restaurants_agent",
      kg=restaurants_kg,
      introduction="I'm a restaurant agent, specialized in finding the best restaurants for you.",
  )


  attractions_agent = KGAgent(
      agent_id="attractions_agent",
      kg=attractions_kg,
      introduction="I'm an attractions agent, specialized in finding the best tourist attractions for you.",
  )
  ```



  The orchestrator manages the usage of agents and handles questioning.

  ```python

  orchestrator = Orchestrator(
      model,
      backstory="You are a trip planner, and you want to provide the best possible itinerary for your clients.",
  )


  orchestrator.register_agent(restaurants_agent)
  orchestrator.register_agent(attractions_agent)


  runner = orchestrator.ask("Create a two-day itinerary for a trip to Rome. Please don't ask me any questions; just provide the best itinerary you can.")
  print(runner.output)

  ```


  Have questions or feedback? Reach out via:
  - [GitHub Issues](https://github.com/FalkorDB/GraphRAG-SDK/issues)
  - Join our [Discord](https://discord.com/invite/6M4QwDXn2w)

  ⭐️ If you find this repository helpful, please consider giving it a star!


  When creating your Knowledge Graph (KG) agent, you can customize the prompts to tailor its behavior.

  💡 This step is optional but can enhance functionality.

  There are five types of prompts:

  1. **`cypher_system_instruction`**
     - System instructions for the Cypher generation step.
     - **Note:** Ensure your prompt includes `{ontology}`.

  2. **`qa_system_instruction`**
     - System instructions for the Q&A step.

  3. **`cypher_gen_prompt`**
     - The prompt used during the Cypher generation step.
     - **Note:** Include `{question}` in your prompt.

  4. **`cypher_gen_prompt_history`**
     - The prompt for Cypher generation when history needs to be considered.
     - **Note:** Include `{question}` and `{last_answer}` in your prompt.

  5. **`qa_prompt`**
     - The prompt used during the Q&A step.
     - **Note:** Include `{question}`, `{context}`, and `{cypher}` in your prompt.

  Here’s an example configuration:

  ```python
  kg = KnowledgeGraph(
      name="kg_name",
      model_config=KnowledgeGraphModelConfig.with_model(model),
      ontology=ontology,
      cypher_system_instruction=cypher_system_instruction,
      qa_system_instruction=qa_system_instruction,
      cypher_gen_prompt=cypher_gen_prompt,
      cypher_gen_prompt_history=cypher_gen_prompt_history,
      qa_prompt=qa_prompt
      host="127.0.0.1",
      port=6379,
      
      
  )
  ```



  **Which databases are supported?**

  GraphRAG-SDK is optimized for FalkorDB. Other backends may require adapters.

  **How scalable is the SDK?**

  GraphRAG-SDK is designed for multi-tenancy and large-scale applications. Performance depends on FalkorDB deployment configuration.

  **How does this SDK improve retrieval-augmented generation?**

  By leveraging knowledge graphs, GraphRAG-SDK enables semantic relationships and ontology-driven queries that go beyond standard vector similarity.

  **Which file formats does the SDK support?**

  Supported formats include PDF, JSONL, CSV, HTML, TEXT, and URLs.

  **How does the SDK handle latency?**

  The SDK is optimized for low-latency operations through FalkorDB, using techniques like query optimization and in-memory processing.

  **Does the SDK support multi-graph querying?**

  Yes. Multi-graph querying is supported with APIs designed for cross-domain and hierarchical graph exploration.

  <br />



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

  Keywords: RAG, graphrag, Retrieval-Augmented Generation, NLP, AI, Information Retrieval, Natural Language Processing, LLM, Embeddings, Semantic Search


pkgId: f526c5ea4b35f6939922e68f5c5a249551910b3a9e11e4c5a5ba03cc68eb8624
name: python-graphs-mkimoni-help
arch: noarch
version: 0.0.1.1
epoch: 0
release: 1
summary: Development documents and examples for graphs-mkimoni
url: https://github.com/alexkimoni/dijkstra.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graphs-mkimoni-0.0.1.1-1.src.rpm
location_href: Packages/python-graphs-mkimoni-help-0.0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python package that implements Dijkstra's shortest path algorithm and includes Kruskal's minimum spanning tree algorithm.

  ```
  pip install graphs_mkimoni
  ```


pkgId: 8b3f95569d1ce0ac6015980d3c649d4657f47f611bd86eaa625674498b3087ea
name: python-graphysio-help
arch: noarch
version: 2024.12.16
epoch: 0
release: 1
summary: Development documents and examples for graphysio
url: https://github.com/jaj42/GraPhysio
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-graphysio-2024.12.16-1.src.rpm
location_href: Packages/python-graphysio-help-2024.12.16-1.noarch.rpm
checksum_type: sha256
description:
  GraPhysio is a graphical time series visualizer created for biometric data
  signals from ICU patient monitors. It is however not limited to this. It can
  handle low frequency and high frequency data as well as aggregating and
  synchronizing signals from different sources. GraPhysio supports basic
  mathematical operations and filters and can help selecting and exporting time
  periods. GraPhysio can read data from CSV, Parquet and EDF files and can write
  CSV, Parquet, EDF and Matlab files.


  For the best experience, conda is recommended:

  conda install -c conda-forge graphysio

  Alternatively you can then install the latest version of GraPhysio from PyPi by
  tying the following command:

  > python -m pip install graphysio

  You can launch GraPhysio by typing:

  > python -m graphysio


pkgId: a8924553aa82ce72ce8b6ce910e0539e5df70f2f8457a5fddd9c825454d67e18
name: python-grass-gis-helpers-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for grass-gis-helpers
url: https://github.com/mundialis/grass-gis-helpers
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-grass-gis-helpers-2.2.0-1.src.rpm
location_href: Packages/python-grass-gis-helpers-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This library provides functions which can be used for developing GRASS GIS addons and which are used by [mundialis](https://www.mundialis.de/).

  The library usage needs to be in a GRASS GIS session, so that the the module `grass` can be imported.



  ```bash
  pip install grass-gis-helpers
  ```



  Small example how the library can be used inside a GRASS GIS session:

  ```python3
  from grass_gis_helpers import general
  general.set_nprocs(2)
  ```



  pip-tools is required for DEV setup:

  ```bash

  pip3 install pip-tools
  ```

  then install grass-gis-helpers from the local repository:

  ```bash
  pip3 install -e .

  ```


pkgId: 4ae35ad6e47933457a71085f25bd5b643bd34e614d20d1311a235754e9ccb6f9
name: python-grav-toolbox-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for grav-toolbox
url: https://github.com/ahellers/GravTools
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-grav-toolbox-0.3.2-1.src.rpm
location_href: Packages/python-grav-toolbox-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  GravTools is an open source software toolbox for the analysis of relative gravity surveys.
  GravTools is developed at Austria's Federal Office of Metrology and Surveying (BEV).

   - The source code is hosted on github.com: https://github.com/ahellers/GravTools
   - The python package is published on pypi.org: https://pypi.org/project/grav-toolbox/




  The python 3 package is available on the Python package index website (pypi.org) and can be easily installed using pip.


  `pip install grav-toolbox`


  GravTools allows users to export adjustment results to shapefiles for data visualization in external GIS programs (e.g. QGIS).
  To enable these features the optional package "geopandas" needs to be installed by executing:
  `pip install grav-toolbox[gis]`




  Copyright (C) 2021  Andreas Hellerschmied (<andreas.hellerschmied@bev.gv.at>)

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

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.


pkgId: 08934e142cfead089d201cb4b4916fbc16bf10b5f84ebfdce7bf904e4c8053e3
name: python-great-expectations-cloud-help
arch: noarch
version: 20241212.1
epoch: 0
release: 1
summary: Development documents and examples for great-expectations-cloud
url: https://greatexpectations.io
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-great-expectations-cloud-20241212.1-1.src.rpm
location_href: Packages/python-great-expectations-cloud-help-20241212.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/great_expectations_cloud)](https://pypi.org/project/great-expectations_cloud/#history)
  [![Docker Pulls](https://img.shields.io/docker/pulls/greatexpectations/agent)](https://hub.docker.com/r/greatexpectations/agent)
  [![ci](https://github.com/great-expectations/cloud/actions/workflows/ci.yaml/badge.svg?event=schedule)](https://github.com/great-expectations/cloud/actions/workflows/ci.yaml)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/great-expectations/cloud/main.svg)](https://results.pre-commit.ci/latest/github/great-expectations/cloud/main)
  [![codecov](https://codecov.io/gh/great-expectations/cloud/graph/badge.svg?token=8WNA5ti8nm)](https://codecov.io/gh/great-expectations/cloud)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)



  To use the GX Agent, you will need to have a Great Expectations Cloud account. You can sign up for free at [https://app.greatexpectations.io](https://app.greatexpectations.io).

  Deployment instructions for the GX Agent can be found in the [GX Cloud documentation](https://docs.greatexpectations.io/docs/cloud/deploy/deploy_gx_agent).



  The following instructions are for those who are contributing to the GX Agent, to deploy and use the GX agent please see the Quick Start section above.

  See also [CONTRIBUTING.md](https://github.com/great-expectations/cloud/blob/main/CONTRIBUTING.md)

  1. [Install `poetry`](https://python-poetry.org/docs/#installation)
     - [`pipx install poetry`](https://python-poetry.org/docs/#installing-with-pipx)
  2. Set up virtual environment and install dependencies
     - `poetry install --sync`
  3. Activate your virtual environment
     - `poetry shell`
  4. Set up precommit hooks
     - `pre-commit install`



  If you run into issues, you can try `pipx reinstall-all`



  ```console
  $ gx-agent --help
  usage: gx-agent [-h] [--log-level LOG_LEVEL] [--skip-log-file SKIP_LOG_FILE] [--log-cfg-file LOG_CFG_FILE] [--version]

  optional arguments:
    -h, --help            show this help message and exit
    --log-level LOG_LEVEL
                          Level of logging to use. Defaults to WARNING.
    --skip-log-file SKIP_LOG_FILE
                          Skip writing debug logs to a file. Defaults to False. Does not affect logging to stdout/stderr.
    --log-cfg-file LOG_CFG_FILE
                          Path to a logging configuration json file. Supersedes --log-level and --skip-log-file.
    --version             Show the GX Agent version.
  ```



  `GX_CLOUD_ACCESS_TOKEN`
  `GX_CLOUD_ORGANIZATION_ID`



  If you intend to run the GX Agent against local services (Cloud backend or datasources) run the Agent outside of the container.

  ```
  gx-agent
  ```



  Common developer tasks are available via `invoke` (defined in `tasks.py`).

  `invoke --list` to see available tasks.



  To ensure you are using the latest version of the core and development dependencies run `poetry install --sync`.
  Also available as an invoke task.

  ```console
  invoke deps
  ```



  The dependencies installed in our CI and the Docker build step are determined by the [poetry.lock file](https://python-poetry.org/docs/basic-usage/#installing-with-poetrylock).

  [To update only a specific dependency](https://python-poetry.org/docs/cli/#update) (such as `great_expectations`) ...

  ```console
  poetry update great_expectations
  ```

  [To resolve and update all dependencies ...](https://python-poetry.org/docs/cli/#lock)

  ```console
  poetry lock
  ```

  In either case, the updated `poetry.lock` file must be committed and merged to main.



  To build the GX Agent Docker image, run the following in the root dir:

  ```
  invoke docker
  ```

  Running the GX Agent:

  ```
  invoke docker --run
  ```

  or

  ```
  docker run --env GX_CLOUD_ACCESS_TOKEN="<GX_TOKEN>" --env GX_CLOUD_ORGANIZATION_ID="<GX_ORG_ID>" gx/agent
  ```

  Now go into GX Cloud and issue commands for the GX Agent to run, such as generating an Expectation Suite for a Data Source.

  > Note if you are pushing out a new image update the image tag version in `containerize-agent.yaml`. The image will be built and pushed out via GitHub Actions.



  The contents from [/examples/agent/data](https://github.com/great-expectations/cloud/tree/main/examples/agent/data) will be copied to `/data` for the Docker container.



  1. Make a new action in `great_expectations_cloud/agent/actions/` in a separate file.
  2. Register your action in the file it was created in using `great_expectations_cloud.agent.event_handler.register_event_action()`. Register for the major version of GX Core that the action applies to, e.g. `register_event_action("1", RunCheckpointEvent, RunCheckpointAction)` registers the action for major version 1 of GX Core (e.g. 1.0.0).
  3. Import your action in `great_expectations_cloud/agent/actions/__init__.py`

  Note: The Agent is core-version specific but this registration mechanism allows us to preemptively work on actions for future versions of GX Core while still supporting the existing latest major version.





  This is the version that will be used for the Docker image tag as well.

  _Standard Release_:
  The versioning scheme is `YYYYMMDD.{release_number}` where:

  - the date is the date of the release
  - the release number starts at 0 for the first release of the day
  - the release number is incremented for each release within the same day

  For example: `20240402.0`

  _Pre-release_:
  The versioning scheme is `YYYYMMDD.{release_number}.dev{dev_number}`

  - the date is the date of the release
  - the dev number starts at 0 for the first pre-release of the day
  - the dev number is incremented for each pre-release within the same day
  - the release number is the release that this pre-release is for

  For example: `20240403.0.dev0` is the first pre-release for the `20240403.0` release.

  For example, imagine the following sequence of releases given for a day with two releases:

  - `20240403.0.dev0`
  - `20240403.0.dev1`
  - `20240403.0`
  - `20240403.1.dev0`
  - `20240403.1`

  There can be days with no standard releases, only pre-releases or days with no pre-release or standard release at all.



  Pre-releases are completed automatically with each merge to the `main` branch.
  The version is updated in `pyproject.toml` and a pre-release is created on PyPi.
  A new Docker tag will also be generated and pushed to [Docker Hub](https://hub.docker.com/r/greatexpectations/agent)

  **Manual Pre-releases**

  NOTE: CI will automatically create pre-releases on merges to `main`. Instead of manually creating pre-releases, consider using the CI process. This is only for exceptional cases.

  To manually create a pre-release, run the following command to update the version in `pyproject.toml` and then merge it to `main` in a standalone PR:

  ```console
  invoke pre-release
  ```

  This will create a new pre-release version. On the next merge to `main`, the release will be uploaded to PyPi.
  A new Docker tag will also be generated and pushed to [Docker Hub](https://hub.docker.com/r/greatexpectations/agent)



  Releases will be completed on a regular basis by the maintainers of the project and with any release of [GX Core](https://github.com/great-expectations/great_expectations)

  For maintainers, to create a release, run the following command to update the version in `pyproject.toml` and then
  merge it to `main` in a standalone PR:

  ```console
  invoke release
  ```

  This will create a new release version. On the next merge to `main`, the release will be uploaded to PyPi.
  A new Docker tag will also be generated and pushed to [Docker Hub](https://hub.docker.com/r/greatexpectations/agent). In addition, releases will be tagged with `stable` and `latest` tags.



  We use the GitHub Actions workflow to automate the release and pre-release process. There are two workflows involved:

  1. [CI](https://github.com/great-expectations/cloud/blob/main/.github/workflows/ci.yaml) - This workflow runs on each pull request and will update the version in `pyproject.toml` to the pre-release version if the version is not already manually updated in the PR. It will also run the tests and linting.

  2. [Containerize Agent](https://github.com/great-expectations/cloud/blob/main/.github/workflows/containerize-agent.yaml) - This workflows runs on merge with `main` and will create a new Docker image and push it to Docker Hub and PyPi. It uses the version in `pyproject.toml`.

  A visual representation of the workflow is shown [here](https://github.com/great-expectations/cloud/blob/main/.github/workflows/agent_release_workflows.png)



  GitHub's Dependabot regularly checks our dependencies for vulnerabilty-based updates and proposes PRs to update dependency version numbers accordingly.

  Dependabot may only update the `poetry.lock` file. If only changes to `poetry.lock` are made, this may be done in a pre-release.

  For changes to the `pyproject.toml` file:

  - If the version of a tool in the `[tool.poetry.group.dev.dependencies]` group is updated, this may be done without any version bump.
    - While doing this, make sure any version references in the pre-commit config `.pre-commit-config.yaml` are kept in sync (e.g., ruff).
  - For other dependency updates or package build metadata changes, a new release should be orchestrated. This includes updates in the following sections:
    - `[tool.poetry.dependencies]`
    - `[tool.poetry.group.*.dependencies]` where `*` is the name of the group (not including the `dev` group)
  - To stop the auto-version bump add the `no version bump` label to the PR. Use this when:
    - Only modifying dev dependencies.
    - Only modifying tests that do not change functionality.

  NOTE: Dependabot does not have permissions to access secrets in our CI. You may notice that integration tests fail on PRs that dependabot creates. If you add a commit (as a GX member) to the PR, the tests will run again and pass because they now have access to the secrets. That commit can be anything, including an empty commit e.g. `git commit -m "some message" --allow-empty`.


pkgId: e566889a693a969358d8d09d545f580216a0bc0009d0fd1c32812512847328dd
name: python-great-expectations-help
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Development documents and examples for great-expectations
url: https://greatexpectations.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-great-expectations-1.3.0-1.src.rpm
location_href: Packages/python-great-expectations-help-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Always know what to expect from your data. (See https://github.com/great-expectations/great_expectations for full description).


pkgId: 9886097cbb5cacafc64ab87019186ca2bb63c8e58e2d4f4b50a7061dda5e2473
name: python-great-tables-help
arch: noarch
version: 0.15.0
epoch: 0
release: 1
summary: Development documents and examples for great-tables
url: https://pypi.org/project/great-tables/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-great-tables-0.15.0-1.src.rpm
location_href: Packages/python-great-tables-help-0.15.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  <a href="https://posit-dev.github.io/great-tables/"><img src="https://posit-dev.github.io/great-tables/assets/GT_logo.svg" width="350px"/></a>

  _Absolutely Delightful Table-making in Python_

  [![Python Versions](https://img.shields.io/pypi/pyversions/great_tables.svg)](https://pypi.python.org/pypi/great_tables)
  [![PyPI](https://img.shields.io/pypi/v/great_tables)](https://pypi.org/project/great-tables/#history)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/great-tables)](https://pypistats.org/packages/great-tables)
  [![License](https://img.shields.io/github/license/posit-dev/great-tables)](https://img.shields.io/github/license/posit-dev/great-tables)

  [![CI Build](https://github.com/posit-dev/great-tables/actions/workflows/ci-tests.yaml/badge.svg)](https://github.com/posit-dev/great-tables/actions/workflows/ci-tests.yaml)
  [![Codecov branch](https://img.shields.io/codecov/c/github/posit-dev/great-tables/main.svg)](https://codecov.io/gh/posit-dev/great-tables)
  [![Repo Status](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
  [![Documentation](https://img.shields.io/badge/docs-project_website-blue.svg)](https://posit-dev.github.io/great-tables/)

  [![Contributors](https://img.shields.io/github/contributors/posit-dev/great-tables)](https://github.com/posit-dev/great-tables/graphs/contributors)
  [![Discord](https://img.shields.io/discord/1086103944280952992?color=%237289da&label=Discord)](https://discord.com/invite/Ux7nrcXHVV)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.1%20adopted-ff69b4.svg)](https://www.contributor-covenant.org/version/2/1/code_of_conduct.html)

  </div>

  With **Great Tables** anyone can make wonderful-looking tables in Python. The philosophy here is that we can construct a wide variety of useful tables by working with a cohesive set of table components. You can mix and match things like a _header_ and _footer_, attach a _stub_ (which contains row labels), arrange _spanner labels_ over top of the _column labels_, and much more. Not only that, but you can format the cell values in a variety of awesome ways.

  <div align="center">
  <img src="https://posit-dev.github.io/great-tables/assets/the_components_of_a_table.svg" width="800px">
  </div>

  It all begins with **table data** in the form of a Pandas or Polars DataFrame. You then decide how to compose your output table with the elements and formatting you need for the task at hand. Finally, the table is rendered to HTML (the default option) or to an image file.

  The **Great Tables** package is designed to be both straightforward yet powerful. The emphasis is on simple methods for the everyday display table needs (but power when you need it). Here is a brief example of how to use **Great Tables** to create a table from the included `sp500` dataset:

  ```python
  from great_tables import GT
  from great_tables.data import sp500


  start_date = "2010-06-07"
  end_date = "2010-06-14"


  sp500_mini = sp500[(sp500["date"] >= start_date) & (sp500["date"] <= end_date)]


  (
      GT(sp500_mini)
      .tab_header(title="S&P 500", subtitle=f"{start_date} to {end_date}")
      .fmt_currency(columns=["open", "high", "low", "close"])
      .fmt_date(columns="date", date_style="wd_m_day_year")
      .fmt_number(columns="volume", compact=True)
      .cols_hide(columns="adj_close")
  )
  ```

  <div align="center">
  <img src="https://posit-dev.github.io/great-tables/assets/gt_sp500_table.svg" width="800px">
  </div>

  Typically we use Great Tables in an notebook environment or within a [**Quarto**](https://quarto.org) document. Tables won't print to the console, but using the [`show()` method](https://posit-dev.github.io/great-tables/reference/GT.show.html#great_tables.GT.show) on a table object while in the console will open the HTML table in your default browser.

  There are ten datasets provided by **Great Tables**: `countrypops`, `sza`, `gtcars`, `sp500`, `pizzaplace`, `exibble`, `towny`, `metro`, `constants`, and `illness`.

  <div align="center" style="padding-top:20px">
  <img src="https://posit-dev.github.io/great-tables/assets/datasets.png" style="width:100%;">
  </div>

  All of this tabular data is great for experimenting with the functionality available inside **Great Tables** and we make extensive use of these datasets in our documentation.

  Beyond the methods shown in the simple `sp500`-based example, there are many possible ways to create super-customized tables. Check out the [documentation website](https://posit-dev.github.io/great-tables/) to get started via introductory articles for making **Great Tables**. There's a handy _Reference_ section that has detailed help for every method and function in the package.

  [![Documentation Site](https://img.shields.io/badge/Project%20Website-Documentation%20and%20Reference-blue?style=social)](https://posit-dev.github.io/great-tables/)

  Let's talk about how to make **Great Tables**! There are a few locations where there is much potential for discussion.

  One such place is in [_GitHub Discussions_](https://github.com/posit-dev/great-tables/discussions). This discussion board is especially great for Q&A, and many people have had their problems solved in there.

  [![GitHub Discussions](https://img.shields.io/badge/GitHub%20Discussions-Ask%20about%20anything-blue?style=social&logo=github&logoColor=gray)](https://github.com/posit-dev/great-tables/discussions)

  Another fine venue for discussion is in our [_Discord server_](https://discord.com/invite/Ux7nrcXHVV). This is a good option for asking about the development of **Great Tables**, pitching ideas that may become features, and sharing your table creations!

  [![Discord Server](https://img.shields.io/badge/Discord-Chat%20with%20us-blue?style=social&logo=discord&logoColor=purple)](https://discord.com/invite/Ux7nrcXHVV)

  Finally, there is the [_X account_](https://twitter.com/gt_package). There you'll find posts about **Great Tables** (including sneak previews about in-development features) and other table-generation packages.

  [![X Follow](https://img.shields.io/twitter/follow/gt_package?style=social)](https://twitter.com/gt_package)

  These are all great places to ask questions about how to use the package, discuss some ideas, engage with others, and much more!



  The **Great Tables** package can be installed from **PyPI** with:

  ```bash
  $ pip install great_tables
  ```

  You can also install [Great Tables from Conda-Forge](https://anaconda.org/conda-forge/great_tables) by using:

  ```bash
  conda install conda-forge::great_tables
  ```

  If you encounter a bug, have usage questions, or want to share ideas to make this package better, please feel free to file an [issue](https://github.com/posit-dev/great-tables/issues).



  Please note that the **Great Tables** project is released with a [contributor code of conduct](https://www.contributor-covenant.org/version/2/1/code_of_conduct/).<br>By participating in this project you agree to abide by its terms.



  There are many ways to contribute to the ongoing development of the **Great Tables** package. Some contributions can be simple (like fixing typos, improving documentation, filing issues for feature requests or problems, etc.) and others might take more time and care (like answering questions and submitting PRs with code changes). Just know that anything you can do to help would be very much appreciated!

  Please read over the [contributing guidelines](https://github.com/posit-dev/great-tables/blob/main/CONTRIBUTING.md) for information on how to get started.



  **Great Tables** is licensed under the MIT license.

  © Posit Software, PBC.



  If you use **Great Tables** in your research/project/product, we would appreciate a citation to the package. You can cite the package using the following BibTeX entry:

  ```bibtex
  @software{Iannone_great_tables,
  author = {Iannone, Richard and Chow, Michael},
  license = {MIT},
  title = {{great-tables: Make awesome display tables using Python.}},
  url = {https://github.com/posit-dev/great-tables},
  version = {0.14.0}
  }
  ```



  This project is primarily maintained by [Rich Iannone](https://twitter.com/riannone) and [Michael Chow](https://twitter.com/chowthedog).
  Other authors may occasionally assist with some of these duties.

rpm_license:
  MIT License  Copyright (c) 2022-2024 Posit Software, PBC  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: 6b7533d9ebe6ea06e25a6b75abdb2fbbc12a201ba8b2f76fddd75212c784bc1e
name: python-green-cli-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for green-cli
url: https://github.com/Blockstream/green_cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-green-cli-0.7.0-1.src.rpm
location_href: Packages/python-green-cli-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  green-cli is a command line interface to Blockstream Green multisig and singlesig Bitcoin and Liquid wallets, based on the Green gdk library.


pkgId: 2c1fb81d8fb6d410d62ee42996b63a42a823f95aa84ca6a99aa4f51d8bec93b4
name: python-grepsr-cli-help
arch: noarch
version: 0.9.19
epoch: 0
release: 1
summary: Development documents and examples for grepsr-cli
url: https://bitbucket.org/grepsr/grepsr-cli/
rpm_license: unlicensed
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-grepsr-cli-0.9.19-1.src.rpm
location_href: Packages/python-grepsr-cli-help-0.9.19-1.noarch.rpm
checksum_type: sha256
description:
  ```
  $ pip install grepsr-cli
  ```




  ```bash
  gcli crawler test -s amazon_com -p '{"urls":["https://amazon.com/VVUH4HJ","https://amazon.com/FV4434"]}'
  ```


  ```

  {"urls": ["https://amazon.com/VV%20UH4HJ"], "strip": ["'", "\"", "\\"]}

  gcli crawler test -s amazon_com --params-file '/tmp/amazon_params.json'
  ```


  > If the json parameter has a space, it might break parameter parsing.
  > If the json parameter has a dash `-` and any character after it has a space, it will break parameter parsing.
  Cause: no double quoting around $@ in `run_service.php:5:49` [here](https://bitbucket.org/grepsr/vortex-backend/src/09c263fb0bb538003db01e1d6742a43ae6ebc61a/deploy/vortex-backend/scripts/run_service.sh#lines-5)
  > This is fixed hackily by replacing string with its unicode \u0020 sequence. This works beacause $@ does not split on \u0020.


  Say, for example you wanted to a inject a php function so that it could be called from inside you service_code when testing locally.
  Note: All these files should only be created inside `~/.grepsr/tmp`. Creating it outside will not work.

  1. Create a file called `inject.php` inside `~/.grepsr/tmp/`
  2. Implement your function inside `~/.grepsr/tmp/inject.php`
  ```php
  function addRowLocal($arr) {
      ...
      ...
  }
  ```
  3. Create a file called `inject.sh` inside `~/.grepsr/tmp/`
  4. inside inject.sh add:
  ```
  alias php='php -d auto_prepend_file=/tmp/inject.php'
  ```
  Note: the file location is `/tmp/inject.php` instead of `~/.grepsr/tmp/inject.php`.
  This is because, the local path `~/.grepsr/tmp` gets mapped to `/tmp` in the docker container.
  And `inject.sh` runs inside docker, instead of the local filesystem.
  5. Add an entry in `~/.grepst/config.yml` like so:
  ```yml
      php:
          ...
          sdk_image: ...
          pre_entry_run_file: inject.sh      # relative and limited to the tmp/ dir
  ```
  6. Now you can use `addRowLocal()` in your any of your files.
  ```php
  public function main($params) {
      ...
      $arr = $this->dataSet->getEmptyRow();
      addRowLocal($arr); // won't throw error
      ...
  }
  ```

  > Be sure to uninstall gcli first, with
  `pip uninstall grepsr-cli`

  ```bash
  git clone git@bitbucket.org:zznixt07/gcli.git grepsrcli
  cd grepsrcli
  pip install -e .
  ```


  - drop stash after pushed successully. Before this, all stashes were always kept.
  - run a custom shell file before running your crawler. This allows possiblity like always injecting a php function in all your crawlers.
  - auto add `Dependencies: ...` that your crawler class extends (dependecies that are not extended by crawler classes but used elsewhere is upcoming)



  - Experiment with git rebase on deploy fail. `git rebase origin/master --autostash && git push`
  - Handle Prioritization of same plugin name across multiple repo more deterministically. (maybe prioritize cwd path?)
  - node only run crawler if npm install is successfull. (add && between npm install and npm start)
  - run `tsc` before deploying `vortex-ts-registry` packages
  - add option to force update dependecies to latest version for all/specific `vortex-ts-registry` dependencies
  - handle ctrl+c during node package install on docker. (currently it continues running in BG)
  - add new baseclass typescript package and do not include SOP, (do not normalize - to _) change `npm start` to `tsc` and test runs. Also generate .d.ts file in tsconfig.json


pkgId: 2202744febc7b2e104c942b1d7777a6e33b4a73992d9a7e5b519381a0c0b0edd
name: python-gridgs-sdk-help
arch: noarch
version: 1.0.8
epoch: 0
release: 1
summary: Development documents and examples for gridgs-sdk
url: https://github.com/5OKB/grid-python-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gridgs-sdk-1.0.8-1.src.rpm
location_href: Packages/python-gridgs-sdk-help-1.0.8-1.noarch.rpm
checksum_type: sha256
description:
  Python SDK to simplify integration with GRID services: https://gridgs.com

  **It's in beta state now. Please expect changes (we'll try to keep them backward-compatible).**


  GridAuthClient - Used to authorize on GRID SSO server.

  GridApiClient - Client for GRID RespAPI that can work with main Grid entities (right now with sessions only).

  GridEventSubscriber - subscriber to receive real-time events about changes in sessions (creation, deletion, starting and so on).

  GridMQTTClient - Client for GRID MQTT API. It useful for realtime connection (receive downlink frames and send uplink frames).



  ```
  keycloak_openid = KeycloakOpenID(server_url="https://login.gridgs.com", client_id="grid-api", realm_name="grid")
  grid_auth_client = GridAuthClient(open_id_client=keycloak_openid, username="user@gridgs.com", password="userpass", company_id=1, logger=logging.getLogger('grid_auth_client'))
  ```



  ```
  grid_api_client = GridApiClient(base_url="https://api.gridgs.com" auth_client=grid_auth_client, logger=logging.getLogger('grid_api_client'))
  ```


  ```
  sessions = grid_api_client.get_predicted_sessions()
  ```



  ```
  session = Session() # A session from get_predicted_sessions
  session = grid_api_client.create_session(session)
  ```



  Receive statuses of sessions

  ```
  grid_event_subscriber = GridEventSubscriber(host="api.gridgs.com", port=1883, auth_client=grid_auth_client, logger=logging.getLogger('grid_event_subscriber'))

  def on_event(self, event: SessionEvent):
      session = event.session

  grid_event_subscriber.on_event(on_event)

  grid_event_subscriber.run()
  ```



  ```
  grid_mqtt_client = GridMQTTClient(host="api.gridgs.com", port=1883, auth_client=grid_auth_client, logger=logging.getLogger('grid_event_subscriber'))

  def on_downlink_frame(frame: Frame):
      pass

  grid_mqtt_client.on_downlink(on_downlink_frame)

  grid_mqtt_client.connect(session)
  ```



  ```
  grid_mqtt_client.send(b'Uplink frame data')
  ```


pkgId: 05989ac0586883bb2ef10977af83d049cfb8b1bb5a68796af1228e2c60ac2646
name: python-gridmind-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for gridmind
url: https://pypi.org/project/gridmind/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gridmind-0.0.5-1.src.rpm
location_href: Packages/python-gridmind-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  <div align="left">
  <table style="margin: auto;">
  <tr>
  <td style="vertical-align: top; padding-right: 10px;">


     - **Every-Visit MC**: *Prediction*
     - **Exploring Starts**: *Prediction & Control*
     - **Off-Policy MC**: *Prediction & Control*

     - **TD(0)**: *Prediction*
     - **SARSA**: *Control*
     - **Q-Learning**: *Control*

     - **N_Step TD Prediction**: *Prediction*
     - **N_Step SARSA**: *Control*

     - **Semi-gradient TD-0 Prediction**: *Prediction*
     - **Gradient Monte-Carlo Prediction**: *Prediction*
  </td>
  <td style="vertical-align: top;">
  <img src="example_usage/demo.gif" alt="Demo" width="300">
  *Figure: GridMind on different environments.*
  </td>
  </tr>
  </table>

rpm_license:
  MIT License  Copyright (c) 2024 Falguni Das Shuvo  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: f8e3e2c7fa325b046eee0e44b178b8bb94982cd9464d5616f72c501613210e3c
name: python-griptape-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for griptape
url: https://github.com/griptape-ai/griptape
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-griptape-1.0.2-1.src.rpm
location_href: Packages/python-griptape-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Griptape](https://assets-global.website-files.com/65d658559223871198e78bca/65fb8d85c1ab3c9b858ab18a_Griptape%20logo%20dark.svg)

  [![PyPI Version](https://img.shields.io/pypi/v/griptape.svg)](https://pypi.python.org/pypi/griptape)
  [![Tests](https://github.com/griptape-ai/griptape/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/griptape-ai/griptape/actions/workflows/unit-tests.yml)
  [![Docs](https://readthedocs.org/projects/griptape/badge/)](https://griptape.readthedocs.io/)
  [![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)
  [![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)
  [![codecov](https://codecov.io/github/griptape-ai/griptape/graph/badge.svg?token=HUBqUpl3NB)](https://codecov.io/github/griptape-ai/griptape)
  [![Griptape Discord](https://dcbadge.vercel.app/api/server/gnWRz88eym?compact=true&style=flat)](https://discord.gg/griptape)

  Griptape is a modular Python framework for building AI-powered applications that securely connect to your enterprise data and APIs. It offers developers the ability to maintain control and flexibility at every step.





  - 🤖 **Agents** consist of a single Task.
  - 🔄 **Pipelines** organize a sequence of Tasks so that the output from one Task may flow into the next.
  - 🌐 **Workflows** configure Tasks to operate in parallel.



  Tasks are the core building blocks within Structures, enabling interaction with Engines, Tools, and other Griptape components.



  Tools provide capabilities for LLMs to interact with data and services. Griptape includes a variety of built-in Tools, and makes it easy to create custom Tools.



  - 💬 **Conversation Memory** enables LLMs to retain and retrieve information across interactions.
  - 🗃️ **Task Memory** keeps large or sensitive Task outputs off the prompt that is sent to the LLM.
  - 📊 **Meta Memory** enables passing in additional metadata to the LLM, enhancing the context and relevance of the interaction.



  Drivers facilitate interactions with external resources and services:

  - 🗣️ **Prompt Drivers** manage textual and image interactions with LLMs.
  - 🔢 **Embedding Drivers** generate vector embeddings from textual inputs.
  - 💾 **Vector Store Drivers** manage the storage and retrieval of embeddings.
  - 🎨 **Image Generation Drivers** create images from text descriptions.
  - 💼 **SQL Drivers** interact with SQL databases.
  - 🌐 **Web Scraper Drivers** extract information from web pages.
  - 🧠 **Conversation Memory Drivers** manage the storage and retrieval of conversational data.
  - 📡 **Event Listener Drivers** forward framework events to external services.
  - 🏗️ **Structure Run Drivers** execute structures both locally and in the cloud.
  - 🤖 **Assistant Drivers** enable interactions with various "assistant" services.
  - 🗣️ **Text to Speech Drivers** convert text to speech.
  - 🎙️ **Audio Transcription Drivers** convert audio to text.
  - 🔍 **Web Search Drivers** search the web for information.
  - 📈 **Observability Drivers** send trace and event data to observability platforms.
  - 📜 **Ruleset Drivers** load and apply rulesets from external sources.
  - 🗂️ **File Manager Drivers** handle file operations on local and remote storage.



  Engines wrap Drivers and provide use-case-specific functionality:

  - 📊 **RAG Engine** is an abstraction for implementing modular Retrieval Augmented Generation (RAG) pipelines.
  - 🛠️ **Extraction Engine** extracts JSON or CSV data from unstructured text.
  - 📝 **Summary Engine** generates summaries from textual content.



  - 📐 **Rulesets** steer LLM behavior with minimal prompt engineering.
  - 🔄 **Loaders** load data from various sources.
  - 🏺 **Artifacts** allow for passing data of different types between Griptape components.
  - ✂️ **Chunkers** segment texts into manageable pieces for diverse text types.
  - 🔢 **Tokenizers** count the number of tokens in a text to not exceed LLM token limits.



  Please refer to [Griptape Docs](https://docs.griptape.ai/) for:

  - Getting started guides.
  - Core concepts and design overviews.
  - Examples.
  - Contribution guidelines.

  Please check out [Griptape Trade School](https://learn.griptape.ai/) for free online courses.



  First, install **griptape**:

  ```
  pip install "griptape[all]" -U
  ```

  Second, configure an OpenAI client by [getting an API key](https://platform.openai.com/account/api-keys) and adding it to your environment as `OPENAI_API_KEY`. By default, Griptape uses [OpenAI Chat Completions API](https://platform.openai.com/docs/guides/gpt/chat-completions-api) to execute LLM prompts.

  With Griptape, you can create Structures, such as Agents, Pipelines, and Workflows, composed of different types of Tasks. Let's build a simple creative Agent that dynamically uses three tools and moves the data around in Task Memory.

  ```python
  from griptape.structures import Agent
  from griptape.tools import WebScraperTool, FileManagerTool, PromptSummaryTool

  agent = Agent(
      input="Load {{ args[0] }}, summarize it, and store it in a file called {{ args[1] }}.",
      tools=[
          WebScraperTool(off_prompt=True),
          PromptSummaryTool(off_prompt=True),
          FileManagerTool()
      ]
  )
  agent.run("https://griptape.ai", "griptape.txt")
  ```

  And here is the output:

  ```
  [08/12/24 14:48:15] INFO     ToolkitTask c90d263ec69046e8b30323c131ae4ba0
                               Input: Load https://griptape.ai, summarize it, and store it in a file called griptape.txt.
  [08/12/24 14:48:16] INFO     Subtask ebe23832cbe2464fb9ecde9fcee7c30f
                               Actions: [
                                 {
                                   "tag": "call_62kBnkswnk9Y6GH6kn1GIKk6",
                                   "name": "WebScraperTool",
                                   "path": "get_content",
                                   "input": {
                                     "values": {
                                       "url": "https://griptape.ai"
                                     }
                                   }
                                 }
                               ]
  [08/12/24 14:48:17] INFO     Subtask ebe23832cbe2464fb9ecde9fcee7c30f
                               Response: Output of "WebScraperTool.get_content" was stored in memory with memory_name "TaskMemory" and artifact_namespace
                               "cecca28eb0c74bcd8c7119ed7f790c95"
  [08/12/24 14:48:18] INFO     Subtask dca04901436d49d2ade86cd6b4e1038a
                               Actions: [
                                 {
                                   "tag": "call_o9F1taIxHty0mDlWLcAjTAAu",
                                   "name": "PromptSummaryTool",
                                   "path": "summarize",
                                   "input": {
                                     "values": {
                                       "summary": {
                                         "memory_name": "TaskMemory",
                                         "artifact_namespace": "cecca28eb0c74bcd8c7119ed7f790c95"
                                       }
                                     }
                                   }
                                 }
                               ]
  [08/12/24 14:48:21] INFO     Subtask dca04901436d49d2ade86cd6b4e1038a
                               Response: Output of "PromptSummaryTool.summarize" was stored in memory with memory_name "TaskMemory" and artifact_namespace
                               "73765e32b8404e32927822250dc2ae8b"
  [08/12/24 14:48:22] INFO     Subtask c233853450fb4fd6a3e9c04c52b33bf6
                               Actions: [
                                 {
                                   "tag": "call_eKvIUIw45aRYKDBpT1gGKc9b",
                                   "name": "FileManagerTool",
                                   "path": "save_memory_artifacts_to_disk",
                                   "input": {
                                     "values": {
                                       "dir_name": ".",
                                       "file_name": "griptape.txt",
                                       "memory_name": "TaskMemory",
                                       "artifact_namespace": "73765e32b8404e32927822250dc2ae8b"
                                     }
                                   }
                                 }
                               ]
                      INFO     Subtask c233853450fb4fd6a3e9c04c52b33bf6
                               Response: Successfully saved memory artifacts to disk
  [08/12/24 14:48:23] INFO     ToolkitTask c90d263ec69046e8b30323c131ae4ba0
                               Output: The content from https://griptape.ai has been summarized and stored in a file called `griptape.txt`.
  ```

  During the run, the Griptape Agent loaded a webpage with a [Tool](https://docs.griptape.ai/stable/griptape-tools/), stored its full content in [Task Memory](https://docs.griptape.ai/stable/griptape-framework/structures/task-memory.md), queried it to answer the original question, and finally saved the answer to a file.

  The important thing to note here is that no matter how big the webpage is it can never blow up the prompt token limit because the full content of the page never goes back to the LLM. Additionally, no data from the subsequent subtasks were returned back to the prompt either. So, how does it work?

  In the above example, we set [off_prompt](https://docs.griptape.ai/stable/griptape-framework/structures/task-memory.md#off-prompt) to `True`, which means that the LLM can never see the data it manipulates, but can send it to other Tools.

  > [!IMPORTANT]
  > This example uses Griptape's [ToolkitTask](https://docs.griptape.ai/stable/griptape-framework/structures/tasks/#toolkit-task), which requires a highly capable LLM to function correctly. By default, Griptape uses the [OpenAiChatPromptDriver](https://docs.griptape.ai/stable/griptape-framework/drivers/prompt-drivers/#openai-chat); for another powerful LLM try swapping to the [AnthropicPromptDriver](https://docs.griptape.ai/stable/griptape-framework/drivers/prompt-drivers/#anthropic)!
  > If you're using a less powerful LLM, consider using the [ToolTask](https://docs.griptape.ai/stable/griptape-framework/structures/tasks/#tool-task) instead, as the `ToolkitTask` might not work properly or at all.

  [Check out our docs](https://docs.griptape.ai/stable/griptape-framework/drivers/prompt-drivers/) to learn more about how to use Griptape with other LLM providers like Anthropic, Claude, Hugging Face, and Azure.



  Griptape uses [Semantic Versioning](https://semver.org/).



  Thank you for considering contributing to Griptape! Before you start, please read the following guidelines.



  If you have identified a bug, want to propose a new feature, or have a question, please submit an issue through our public [issue tracker](https://github.com/griptape-ai/griptape/issues). Before submitting a new issue, please check the existing issues to ensure it hasn't been reported or discussed before.



  We welcome and encourage pull requests. To streamline the process, please follow these guidelines:

  1. **Existing Issues:** Please submit pull requests only for existing issues. If you want to work on new functionality or fix a bug that hasn't been addressed yet, please first submit an issue. This allows the Griptape team to internally process the request and provide a public response.

  1. **Branch:** Submit all pull requests to the `dev` branch. This helps us manage changes and integrate them smoothly.

  1. **Unit Tests:** Ensure that your pull request passes all existing unit tests. Additionally, if you are introducing new code, please include new unit tests to validate its functionality.

  Run `make test/unit` to execute the test suite locally.

  4. **Documentation:** Every pull request must include updates to documentation or explicitly explain why a documentation update is not required. Documentation is crucial for maintaining a comprehensive and user-friendly project.

  Run `make docs` to build the documentation locally.

  5. **Code Checks:** Griptape a variety of tools to enforce code quality and style. Your code must pass all checks before it can be merged.

  Run `make check` to run all code checks locally.

  6. **Changelog:** If your pull request introduces a notable change, please update the [changelog](https://github.com/griptape-ai/griptape/blob/dev/CHANGELOG.md).



  Griptape's extensibility allows anyone to develop and distribute functionality independently.
  All new integrations, including Tools, Drivers, Tasks, etc., should initially be developed as extensions and then can be upstreamed into Griptape core if discussed and approved.

  The [Griptape Extension Template](https://github.com/griptape-ai/griptape-extension-template) provides the recommended structure, step-by-step instructions, basic automation, and usage examples for new integrations.



  Install all dependencies via Make:

  ```shell
  make install
  ```

  Or install by calling Poetry directly:

  ```shell
  poetry install --all-extras --with dev --with test --with docs
  ```

  Configure pre-commit to ensure that your code is formatted correctly and passes all checks:

  ```shell
  poetry run pre-commit install
  ```



  Griptape is available under the Apache 2.0 License.


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

  The Groq Python library provides convenient access to the Groq REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [console.groq.com](https://console.groq.com/docs). The full API of this library can be found in [api.md](https://github.com/groq/groq-python/tree/main/api.md).



  ```sh

  pip install groq
  ```



  The full API of this library can be found in [api.md](https://github.com/groq/groq-python/tree/main/api.md).

  ```python
  import os
  from groq import Groq

  client = Groq(
      api_key=os.environ.get("GROQ_API_KEY"),  # This is the default and can be omitted
  )

  chat_completion = client.chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "Explain the importance of low latency LLMs",
          }
      ],
      model="llama3-8b-8192",
  )
  print(chat_completion.choices[0].message.content)
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `GROQ_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  Simply import `AsyncGroq` instead of `Groq` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from groq import AsyncGroq

  client = AsyncGroq(
      api_key=os.environ.get("GROQ_API_KEY"),  # This is the default and can be omitted
  )


  async def main() -> None:
      chat_completion = await client.chat.completions.create(
          messages=[
              {
                  "role": "user",
                  "content": "Explain the importance of low latency LLMs",
              }
          ],
          model="llama3-8b-8192",
      )
      print(chat_completion.choices[0].message.content)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `groq.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `groq.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `groq.APIError`.

  ```python
  import groq
  from groq import Groq

  client = Groq()

  try:
      client.chat.completions.create(
          messages=[
              {
                  "role": "system",
                  "content": "You are a helpful assistant.",
              },
              {
                  "role": "user",
                  "content": "Explain the importance of low latency LLMs",
              },
          ],
          model="llama3-8b-8192",
      )
  except groq.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except groq.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except groq.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from groq import Groq


  client = Groq(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).chat.completions.create(
      messages=[
          {
              "role": "system",
              "content": "You are a helpful assistant.",
          },
          {
              "role": "user",
              "content": "Explain the importance of low latency LLMs",
          },
      ],
      model="llama3-8b-8192",
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from groq import Groq


  client = Groq(
      
      timeout=20.0,
  )


  client = Groq(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).chat.completions.create(
      messages=[
          {
              "role": "system",
              "content": "You are a helpful assistant.",
          },
          {
              "role": "user",
              "content": "Explain the importance of low latency LLMs",
          },
      ],
      model="llama3-8b-8192",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/groq/groq-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `GROQ_LOG` to `info`.

  ```shell
  $ export GROQ_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from groq import Groq

  client = Groq()
  response = client.chat.completions.with_raw_response.create(
      messages=[{
          "role": "system",
          "content": "You are a helpful assistant.",
      }, {
          "role": "user",
          "content": "Explain the importance of low latency LLMs",
      }],
      model="llama3-8b-8192",
  )
  print(response.headers.get('X-My-Header'))

  completion = response.parse()  # get the object that `chat.completions.create()` would have returned
  print(completion.id)
  ```

  These methods return an [`APIResponse`](https://github.com/groq/groq-python/tree/main/src/groq/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/groq/groq-python/tree/main/src/groq/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.chat.completions.with_streaming_response.create(
      messages=[
          {
              "role": "system",
              "content": "You are a helpful assistant.",
          },
          {
              "role": "user",
              "content": "Explain the importance of low latency LLMs",
          },
      ],
      model="llama3-8b-8192",
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from groq import Groq, DefaultHttpxClient

  client = Groq(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/groq/groq-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import groq
  print(groq.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/groq/groq-python/tree/main/./CONTRIBUTING.md).


pkgId: 5e534829644f76cd83d9d8c1b8f6d589f89e738977c450e2d7cc6c63bc0f70f2
name: python-groundx-help
arch: noarch
version: 2.1.0
epoch: 0
release: 1
summary: Development documents and examples for groundx
url: https://pypi.org/project/groundx/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-groundx-2.1.0-1.src.rpm
location_href: Packages/python-groundx-help-2.1.0-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%2Feyelevelai%2Fgroundx-python)
  [![pypi](https://img.shields.io/pypi/v/groundx)](https://pypi.python.org/pypi/groundx)

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



  API reference documentation is available [here](https://docs.groundx.ai/reference).



  ```sh
  pip install groundx
  ```



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



  Instantiate and use the client with the following:

  ```python
  from groundx import Document, GroundX

  client = GroundX(
      api_key="YOUR_API_KEY",
  )

  client.ingest(
      documents=[
          Document(
              bucket_id=1234,
              file_name="my_file1.txt",
              file_type="txt",
              source_url="https://my.source.url.com/file1.txt",
          )
      ],
  )
  ```



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

  ```python
  import asyncio

  from groundx import AsyncGroundX, Document

  client = AsyncGroundX(
      api_key="YOUR_API_KEY",
  )

  async def main() -> None:
      await client.ingest(
          documents=[
              Document(
                  bucket_id=1234,
                  file_name="my_file1.txt",
                  file_type="txt",
                  source_url="https://my.source.url.com/file1.txt",
              )
          ],
      )

  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 groundx.core.api_error import ApiError

  try:
      client.ingest(...)
  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.ingest(..., 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 groundx import GroundX

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



  client.ingest(..., 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 groundx import GroundX

  client = GroundX(
      ...,
      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: 5c3b38fe722d3ac015ae1f56b9654b07da0313d28437748328efde9d0f8d4a11
name: python-grpcio-admin-help
arch: noarch
version: 1.68.1
epoch: 0
release: 1
summary: Development documents and examples for grpcio-admin
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-grpcio-admin-1.68.1-1.src.rpm
location_href: Packages/python-grpcio-admin-help-1.68.1-1.noarch.rpm
checksum_type: sha256
description:
  Debugging gRPC library can be a complex task. There are many configurations and
  internal states, which will affect the behavior of the library. This Python
  package will be the collection of admin services that are exposing debug
  information. Currently, it includes:
  * Channel tracing metrics (grpcio-channelz)
  * Client Status Discovery Service (grpcio-csds)
  Here is a snippet to create an admin server on "localhost:50051":
      server = grpc.server(ThreadPoolExecutor())
      port = server.add_insecure_port('localhost:50051')
      grpc_admin.add_admin_servicers(self._server)
      server.start()
  Welcome to explore the admin services with CLI tool "grpcdebug":
  https://github.com/grpc-ecosystem/grpcdebug.
  For any issues or suggestions, please send to
  https://github.com/grpc/grpc/issues.


pkgId: 6032bbf2fbf602935eee609d3dac238853d5ddd6cf6f9d2a71986d1aec111cda
name: python-grpcio-csds-help
arch: noarch
version: 1.68.1
epoch: 0
release: 1
summary: Development documents and examples for grpcio-csds
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-grpcio-csds-1.68.1-1.src.rpm
location_href: Packages/python-grpcio-csds-help-1.68.1-1.noarch.rpm
checksum_type: sha256
description:
  CSDS is part of the Envoy xDS protocol:
  https://www.envoyproxy.io/docs/envoy/latest/api-v3/service/status/v3/csds.proto.
  It allows the gRPC application to programmatically expose the received traffic
  configuration (xDS resources). Welcome to explore with CLI tool "grpcdebug":
  https://github.com/grpc-ecosystem/grpcdebug.
  For any issues or suggestions, please send to https://github.com/grpc/grpc/issues.


pkgId: cb64b2938a436382f31dcef37813008258c146c80e87e29c8357eb7bcb88623f
name: python-grpcio-debuginfo
arch: aarch64
version: 1.68.1
epoch: 0
release: 1
summary: Debug information for package python-grpcio
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-grpcio-1.68.1-1.src.rpm
location_href: Packages/python-grpcio-debuginfo-1.68.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-grpcio.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: e4c1f38fbe2b6b7aa73dcad7ab1150e5339100d9fac9aae328e4d04f20b0f64f
name: python-grpcio-debugsource
arch: aarch64
version: 1.68.1
epoch: 0
release: 1
summary: Debug sources for package python-grpcio
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-grpcio-1.68.1-1.src.rpm
location_href: Packages/python-grpcio-debugsource-1.68.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-grpcio.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: cd34bfa565864e6f9340f57d8313d2a8e86147e874cdbe76de0b3af56c910a44
name: python-grpcio-tools-debuginfo
arch: aarch64
version: 1.68.1
epoch: 0
release: 1
summary: Debug information for package python-grpcio-tools
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-grpcio-tools-1.68.1-1.src.rpm
location_href: Packages/python-grpcio-tools-debuginfo-1.68.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-grpcio-tools.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 337e49cc256488bbe8a84da6afe220f80a6311190b33b45e1919caf9ee4064c2
name: python-grpcio-tools-debugsource
arch: aarch64
version: 1.68.1
epoch: 0
release: 1
summary: Debug sources for package python-grpcio-tools
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-grpcio-tools-1.68.1-1.src.rpm
location_href: Packages/python-grpcio-tools-debugsource-1.68.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-grpcio-tools.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 454c97341213f1b72d22572714b3f6660d4dc036ba6e3e3b17cb0df22752f73d
name: python-grpipe-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for grpipe
url: https://wirhabenzeit.github.io/grpipe/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-grpipe-0.0.4-1.src.rpm
location_href: Packages/python-grpipe-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  GRPipe is a minimalistic and flexible computational pipeline framework for Python that allows you to create complex data processing workflows. It provides a clean and intuitive API for defining, connecting, and executing pipeline steps, with built-in support for caching, argument binding, and parameter management.

  [![Release](https://img.shields.io/github/v/release/wirhabenzeit/grpipe)](https://img.shields.io/github/v/release/wirhabenzeit/grpipe)
  [![Build status](https://img.shields.io/github/actions/workflow/status/wirhabenzeit/grpipe/main.yml?branch=main)](https://github.com/wirhabenzeit/grpipe/actions/workflows/main.yml?query=branch%3Amain)
  [![codecov](https://codecov.io/gh/wirhabenzeit/grpipe/branch/main/graph/badge.svg)](https://codecov.io/gh/wirhabenzeit/grpipe)
  [![Commit activity](https://img.shields.io/github/commit-activity/m/wirhabenzeit/grpipe)](https://img.shields.io/github/commit-activity/m/wirhabenzeit/grpipe)
  [![License](https://img.shields.io/github/license/wirhabenzeit/grpipe)](https://img.shields.io/github/license/wirhabenzeit/grpipe)

  Computation pipelines with non-linear dependency graphs

  - **Github repository**: <https://github.com/wirhabenzeit/grpipe/>
  - **Documentation** <https://wirhabenzeit.github.io/grpipe/>



  - Easy-to-use decorator-based API for defining pipeline steps
  - Automatic dependency resolution between steps
  - Built-in caching mechanism for improved performance
  - Flexible argument binding and parameter management
  - Support for both linear and branching pipelines
  - Verbose logging option for debugging and monitoring



  You can install GRPipe using pip:

  ```bash
  pip install grpipe
  ```





  In GRPipe, there's an important distinction between arguments and parameters:

  - **Arguments** are either external inputs passed to the final pipeline or outputs from other internal steps. They are defined using the `Argument` class and connected between steps.
  - **Parameters** are tunable settings for individual steps. They can be adjusted globally using the `set_params` method of the pipeline.

  Here's an example illustrating the difference:

  ```python

  data = Argument("data")
  threshold = Argument("threshold")



  @step(args={"input_data": data, "cutoff": threshold})
  def process_data(input_data, cutoff, operation="mean"):
      if operation == "mean":
          result = input_data[input_data > cutoff].mean()
      elif operation == "std":
          result = input_data[input_data > cutoff].std()
      else:
          raise ValueError("Invalid operation")
      return result


  @step(args={"processed": process_data})
  def format_result(processed):
      return f"The result is: {processed:.2f}"



  pipeline = format_result


  result1 = pipeline(data=np.arange(100), threshold=2)
  print(result1)


  pipeline.set_params(process_data__operation="std")


  result2 = pipeline(data=np.arange(100), threshold=2)
  print(result2)


  pipeline.bind(threshold=50)

  result3 = pipeline(data=np.arange(100))
  print(result3)
  ```

  In this example, `data` and `threshold` are arguments that can be passed when running the pipeline, while `operation` is a parameter that can be adjusted using `set_params`.



  GRPipe supports creating complex branching pipelines. Here's an example of a more advanced pipeline for data analysis:

  ```python
  import polars as pl
  from grpipe import Argument, step


  data_source = Argument("data_source")
  analysis_type = Argument("analysis_type")

  @step(args={"source": data_source})
  def load_data(source):
      return pl.read_csv(source)

  @step(args={"data": load_data})
  def preprocess(data, fill_value=0):
      return data.drop_nulls().fill_nan(fill_value)

  @step(args={"data": preprocess})
  def calculate_statistics(data):
      return {
          "mean": data.mean().to_dict(),
          "median": data.median().to_dict(),
          "std_dev": data.std().to_dict()
      }

  @step(args={"data": preprocess})
  def perform_clustering(data, n_clusters = 3):
      
      return {"clusters": [f"Cluster {i}" for i in range(n_clusters)]}

  @step(args={"stats": calculate_statistics, "clusters": perform_clustering, "analysis": analysis_type})
  def generate_report(stats, clusters, analysis):
      report = f"Analysis Type: {analysis}\n\n"
      report += "Statistics:\n"
      for key, value in stats.items():
          report += f"  {key}: {value}\n"
      report += f"\nNumber of clusters: {len(clusters['clusters'])}"
      return report


  analysis_pipeline = generate_report


  result = analysis_pipeline(
      data_source="path/to/your/data.csv",
      analysis_type="Exploratory Data Analysis"
  )
  print(result)
  ```

  This example demonstrates how you can create a more complex pipeline that includes data loading, preprocessing, parallel analysis steps (statistics calculation and clustering), and report generation. It also shows how to use both arguments and parameters in a pipeline.



  GRPipe automatically caches the results of each step, improving performance for repeated runs with the same inputs. You can control caching behavior for each argument:

  ```python
  frequently_changing_data = Argument("data", cachable=False)
  stable_parameter = Argument("parameter", cachable=True)

  @step(args={"data": frequently_changing_data, "param": stable_parameter})
  def process_data(data, param):
      
      pass
  ```



  Enable verbose logging for debugging and monitoring:

  ```python
  @step(verbose=True, args={"data": input_data})
  def noisy_step(data):
      
      pass
  ```



  GRPipe allows you to generate flowcharts of your pipeline using the `pipeline.draw()` method. This method generates a flowchart in mermaid markdown format, which can be easily visualized.

  Here's an example of how to generate a flowchart for a simple pipeline:

  ```python
  from grpipe import Argument, step, Pipeline


  data = Argument("data")
  threshold = Argument("threshold")

  @step(args={"input_data": data, "cutoff": threshold})
  def process_data(input_data, cutoff, operation="mean"):
      if operation == "mean":
          result = input_data[input_data > cutoff].mean()
      elif operation == "std":
          result = input_data[input_data > cutoff].std()
      else:
          raise ValueError("Invalid operation")
      return result

  @step(args={"processed": process_data})
  def format_result(processed):
      return f"The result is: {processed:.2f}"


  pipeline = Pipeline(format_result)


  flowchart = pipeline.draw(params=True)
  print(flowchart)
  ```

  This will generate a flowchart in mermaid markdown format, which can be visualized using mermaid tools. The `params` parameter allows you to include parameters in the flowchart.



  GRPipe is released under the MIT License. See the [LICENSE](LICENSE) file for details.


pkgId: 435cf032d04e11636d4641a9d0e1af2395f19af32a4d56538d4f1c64dccc4597
name: python-gru-help
arch: noarch
version: 0.0.1rc16.dev2
epoch: 0
release: 1
summary: Development documents and examples for gru
url: https://pypi.org/project/gru/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gru-0.0.1rc16.dev2-1.src.rpm
location_href: Packages/python-gru-help-0.0.1rc16.dev2-1.noarch.rpm
checksum_type: sha256
description:
  Canso is a Managed Data and Feature Platform for operationalizing Machine Learning initiatives. The goal of Canso is to enable ML Teams (Data Engineers, Data Scientists, ML Engineers) to define their requirements in a declarative and standardized manner via a concise [DSL](https://en.wikipedia.org/wiki/Domain-specific_language) without having to focus on writing custom code for Features, DAGs etc and managing infrastructure. This enables ML teams to
  - Iterate fast i.e. move from development to production in hours/days as opposed to weeks
  - Promote Reliability i.e build standardized ML pipelines


  Canso's core focus is on user experience and speed of iteration, without compromising on reliability -

  - Define data sources where features can be created and computed.
  - Specify data sinks where processed data is stored after a successful ML pipeline run.
  - Define Machine Learning features in a standardized manner on top of existing Datasources and deploy them. These features can be used while Model training as well as for Model inference. Canso supports Raw, Derived and Streaming features currently.
  - Register and deploy features to execute the ML pipeline.








  For installing gru package will need to username and PAT as password.
  - A Personal Access Token (PAT) is a kind of key that authenticates a user across all applications they have access to.

  ```python
  pip3 install git+https://github.com/Yugen-ai/gru.git
  ```




  ```python
  yugen_client = YugenClient(access_token=access_token, config_path="./gru/config.yaml")
  ```




  ```python
  s3_data_source_obj = S3DataSource(
      name="survey_telemetry_data",
      bucket="internal-ml-demos",
      base_key="recsys/survey-data/phase3_3/survey-telemetry/",
      varying_key_suffix_format="%Y-%m-%d/%H%M",
      varying_key_suffix_freq="30min",
      time_offset=0,
      description="random desc of data source",
      owners=["xyz"],
      created_at=datetime.now(),
      file_type=CSVType(header=True),
      schema=schema_obj,
      event_timestamp_field="time",
      event_timestamp_format="yyyy-MM-dd HH:mm:ssXXX",
  )
  ```




  ```python
  yugen_client.register(s3_data_source_obj)
  ```



  ```python
  raw_feature = RawFeature(
      name="avg_order_val_3_days",
      description="Avg order per cusotmer for last 3 days",
      data_type=DataType.FLOAT,
      source_name=["survey_telemetry_data"],
      staging_sink=["s3_sink_ml_yugen_internal"],
      online_sink=["elasticache-redis-yugen"],
      owners=["vanshika@yugen.ai"],
      entity=["test"],
      feature_logic=FeatureLogic(
          field=["ad_id"],
          filter="""ad_id is NOT NULL""",
          transform=SlidingWindowAggregation(
              function="avg",
              partition_by="provider",
              order_by="cpi",
              
              rowsBetween={"frame_start": 1, "frame_end": 2},
          ),
          time_window="3d",
          groupby_keys=["project_id"],
          timestamp_field="time",
          timestamp_format="yyyy-MM-dd HH:mm:ssXXX",
      ),
      online=True,
      offline=True,
      schedule="0 0 * * *",
      active=True,
      start_time=datetime(2023, 4, 1, 0, 0, 0),
  )
  ```



  ```python
  yugen_client.register(raw_feature)
  ```




  ```python
  yugen_client.dry_run("avg_order_val_3_days", entity_type=EntityType.RAW_FEATURE, start_date=datetime(2023, 4, 1, 0, 0, 0), end_date=datetime(2023, 4, 2, 0, 0, 0))
  ```




  ```python
  yugen_client.deploy("avg_order_val_3_days", EntityType.RAW_FEATURE)
  ```



  ```python
  derived_feature = DerivedFeature(
      name="total_purchases",
      description="Total purchase amount for the store",
      staging_sink=["s3_sink_ml_yugen_internal"],
      online_sink=["elasticache-redis-yugen"],
      data_type=DataType.FLOAT,
      owners=["all-ds@company.com"],
      schedule="0 0 * * *",
      entity=["CASE WHEN cpi> 0.5 THEN 10 ELSE 0 END"],
      online=False,
      offline=True,
      transform=multiply("avg_orders_last_3_days", "number_users"),
      start_time=datetime(2022, 8, 26, 0, 0, 0),
  )
  ```



  ```python
  yugen_client.register(derived_feature)
  ```



  ```python
  yugen_client.dry_run("total_purchases", entity_type=EntityType.DERIVED_FEATURE, start_date=datetime(2022, 8, 26, 0, 0, 0), end_date=datetime(2022, 8, 27, 0, 0, 0))
  ```



  ```python
  yugen_client.deploy("total_purchases", EntityType.DERIVED_FEATURE)
  ```



  ```python
  ppt = PreProcessingTransform(
      transform_name="user_avg_spend_transform_final_testing_for_dry_run",
      description="test preprocess transform",
      data_source_names=["marketing_survey_data_info", "data_telemetry_info"],
      data_source_lookback_config={
          "marketing_survey_data_info": "1d",
          "data_telemetry_info": "1d",
      },
      staging_sink=["s3_sink_ml_yugen_internal"],
      logic=sql_logic,
      schedule="0 0 * * *",
      output_schema=schema_obj,
      owners=["john.doe@company.ai"],
      active=True,
      transform_start_time=datetime(2022, 8, 27, 0, 0, 0),
  )
  ```



  ```python
  yugen_client.register(ppt)
  ```



  ```python
  yugen_client.dry_run(
      "user_avg_spend_transform_final_testing_for_dry_run",
      entity_type=EntityType.PRE_PROCESSING_TRANSFORM,
      start_date=datetime(2022, 8, 27, 0, 0, 0),
      end_date=datetime(2022, 8, 28, 0, 0, 0),
  )
  ```



  ```python
  yugen_client.deploy(
      "user_avg_spend_transform_final_testing_for_dry_run", EntityType.PRE_PROCESSING_TRANSFORM
  )
  ```



  ```python
  training_run = TrainingData(
      name="example_training_run",
      description="A sample run to generate training data",
      historical_data_source="user_events",
      entities=["project_id","cpi"],
      features=["raw_for_testing_gtd","raw_for_testing_gtd_for_telemetry","raw_for_testing_gtd_for_survey","raw_for_testing_gtd_for_user_events","raw_for_testing_gtd_for_weather_forecats"],
      ttl=5,
      owners=["john.doe@company.ai"],
  )
  ```



  ```python
  yugen_client.register(training_run)
  ```



  ```python
  yugen_client.deploy("example_training_run", EntityType.TRAINING_DATA)
  ```



  ```python
  register_infrastructure = RegisterInfrastructure(
      client_id="platform-release-1",
      cloud_provider="aws",
      cluster_name="yugen-platform-v2",
      region="ap-south-1",
      subnet_ids=["subnet-4b250507", "subnet-fac53691", "subnet-86cea5fd"],
      resource_node_group_instance_types={
          "instance_types": {"node_group_1": "t3.medium", "node_group_2": "t3.large",}
      },
      resource_node_group_scaling_config={
          "scaling_config": {
              "node_group_1": {"max_size": 6, "min_size": 2, "desired_size": 3},
              "node_group_2": {"max_size": 6, "min_size": 2, "desired_size": 3,},
          }
      },
      admins=[
          "arn:aws:iam::832344679060:user/ashish.prajapati@yugen.ai",
          "arn:aws:iam::832344679060:user/john.doe@company.ai",
          "arn:aws:iam::832344679060:user/sandeep.mishra@yugen.ai",
          "arn:aws:iam::832344679060:user/shaktimaan@yugen.ai",
          "arn:aws:iam::832344679060:user/shashank.mishra@yugen.ai",
          "arn:aws:iam::832344679060:user/soumanta@yugen.ai",
          "arn:aws:iam::832344679060:user/vanshika.agrawal@yugen.ai",
      ],
      airflow_users={
          "admin": {
              "username": "admin",
              "password": "yugen@123",
              "email": "admin@example.com",
              "firstName": "admin",
              "lastName": "admin",
          }
      },
      slack_details={
          "failure_alerts": {
              "host_url": "https://hooks.slack.com/services",
              "host_password": "/TSRAELEL9/B04Q09X9W75/PhfxMaFBE81ZBXjeAktTTIyN",
          },
          "notifications": {
              "host_url": "https://hooks.slack.com/services",
              "host_password": "/TSRAELEL9/B04Q09X9W75/PhfxMaFBE81ZBXjeAktTTIyN",
          },
      },
      created_at =datetime(2023, 4, 28, 0, 0, 0),

  )


  ```



  ```python
  yugen_client.register(register_infrastructure)
  ```



  ```python
  yugen_client.deploy("platform-release-1_yugen-platform-v2_2023-04-28 00:00:00", EntityType.INFRASTRUCTURE)
  ```






  - [x] S3
  - [ ] GCS
  - [ ] RedShift
  - [ ] BigQuery
  - [ ] Snowflake


  - [x] Kafka





  Online data sinks offers real-time data storage for fast write operations.
  It ensures low-latency access to data,
  making it suitable for applications requiring immediate data retrieval and updates,
  such as retrieval for ML predictions.
  Currently, Canso supports Redis cache for storing data online.



  Offline data sinks provides durable and scalable storage for batch-processed and historical data.
  It supports large volumes of data with high reliability,
  making it ideal for data warehousing and archival storage.
  Currently, Canso supports S3 storing data offline.


  - [x] S3
  - [x] Redis
  - [ ] RedShift
  - [ ] DynamoDB


  - [ ] Kafka



  - [x] Elasticache for Redis (AWS)
  - [ ] Memorystore for Redis (GCP)
  - [ ] DynamoDB
  - [ ] Bigtable

rpm_license:
  MIT LICENSE  Copyright (c) 2023 Canso Platform Python Package  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: f48d8c15c0a6b7efeba36df77fb966830c220d69ac3113bf4b3a9b86ae86c927
name: python-gs-quant-help
arch: noarch
version: 1.2.12
epoch: 0
release: 1
summary: Development documents and examples for gs-quant
url: https://marquee.gs.com
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gs-quant-1.2.12-1.src.rpm
location_href: Packages/python-gs-quant-help-1.2.12-1.noarch.rpm
checksum_type: sha256
description:
  **GS Quant** is a Python toolkit for quantitative finance, created on top of one of the world’s most powerful risk transfer platforms. Designed to accelerate development of quantitative trading strategies and risk management solutions, crafted over 25 years of experience navigating global markets.

  It is created and maintained by quantitative developers (quants) at Goldman Sachs to enable the development of trading strategies and analysis of derivative products. GS Quant can be used to facilitate derivative structuring, trading, and risk management, or as a set of statistical packages for data analytics applications.

  In order to access the APIs you will need a client id and secret.  These are available to institutional clients of Goldman Sachs.  Please speak to your sales coverage or Marquee Sales for further information.

  Please refer to [Goldman Sachs Developer](https://developer.gs.com/docs/gsquant/) for additional information.



  * Python 3.8 or greater
  * Access to PIP package manager



  ```
  pip install gs-quant
  ```



  You can find examples, guides and tutorials in the respective folders as well as on [Goldman Sachs Developer](https://developer.gs.com/docs/gsquant/).



  Contributions are encouraged! Please see [CONTRIBUTING](CONTRIBUTING.md) for more details.



  Please reach out to `gs-quant@gs.com` with any questions, comments or feedback.


pkgId: 382e688d665a5b263533bbcb6f7349281ed29f7a37a57102e68d34affc5fe5f5
name: python-gshapa-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for gshapa
url: https://gitlab.com/bf2i/gshapa
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gshapa-0.1.1-1.src.rpm
location_href: Packages/python-gshapa-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <div style="display: flex; justify-content: center;">
   <img src="logo.webp" height="250">
  </div>

  This Python package Gene Set Analysis for Single-Cell RNA-seq Using Random Forest and SHAP Values



  `pip install gshapa`



  [grenadine.readthedocs.io](https://grenadine.readthedocs.io/en/latest/)



  Check the jupyter notebook tutorials located in the __tutorial__ folder
  + `simulator.ipynb` for the assessment of the method on synthetic data
  + `MS-dataset-RF-1percent.ipynb`, `DN-RF-1percent.ipynb`, `DII-RF-1percent.ipynb`, `COVID-RF-1percent.ipynb` and `AD-RF-1percent.ipynb` for different bio-medical applications



  For bug reports and feedback do not hesitate to contact the authors

  + Sergio Peignier: sergio.peignier AT insa-lyon.fr
  + Sara Khademioureh: khademio AT ualberta.ca



  + Sergio Peignier: sergio.peignier AT insa-lyon.fr


pkgId: e2917c657eb09a0c516b0b87395c2e1087226925bcab323bd8f5641778176603
name: python-gsplot-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for gsplot
url: https://soichiroyamane.github.io/gsplot/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gsplot-0.0.2-1.src.rpm
location_href: Packages/python-gsplot-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center" style="font-weight: bold; font-size: 1.2em; margin: 20px 0;">
    <a href="https://soichiroyamane.github.io/gsplot/" style="text-decoration: none;">Docs</a> |
    <a href="#authors" style="text-decoration: none;">Authors</a> |
    <a href="#license" style="text-decoration: none;">License</a>
  </p>
  Welcome to **gsplot** (general-scientific plot), a toolkit designed to enhance the capabilities of data visualization based on [matplotlib](https://matplotlib.org). This package is specifically tailored for creating high-quality figures aimed at the scientific field.

  - **Better Plot, Less Code**: Simplify the process of creating high-quality figures ⚛️
  - **Compatibility**: Compatible with [matplotlib](https://matplotlib.org) 📊
  - **Customization**: Customize your configuration to fit your needs 🎨
  - **Reproducibility**: Save your package status to make plots reproducible 📦

  [See more details](https://soichiroyamane.github.io/gsplot/guides/demo/4_paper_plot.html)
  ![example](docs/_static/SC_cal.png)

  [See more details](https://soichiroyamane.github.io/gsplot/guides/demo/13_REPL.html)
  ![repl_tutorial](./docs/_static/repl_tutorial_sp.gif)


  To use **gsplot**, ensure that you have `Python 3.10+` installed. You can install the package using `pip`:
  ```bash
  pip install gsplot
  ```

  This repository was forked from codes developed by Giordano Mattoni.
  - Giordano Mattoni
  - Soichiro Yamane

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


pkgId: 0ae5cddb6d642b444d970d8e3b0df2cdd0008f23c089ce84753f039c1b59fb9c
name: python-gsplot-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for gsplot
url: https://soichiroyamane.github.io/gsplot/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gsplot-0.0.4-1.src.rpm
location_href: Packages/python-gsplot-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center" style="font-weight: bold; font-size: 1.2em; margin: 20px 0;">
    <a href="https://soichiroyamane.github.io/gsplot/" style="text-decoration: none;">Docs</a> |
    <a href="#authors" style="text-decoration: none;">Authors</a> |
    <a href="#license" style="text-decoration: none;">License</a>
  </p>
  Welcome to **gsplot** (general-scientific plot), a toolkit designed to enhance the capabilities of data visualization based on [matplotlib](https://matplotlib.org). This package is specifically tailored for creating high-quality figures aimed at the scientific field.

  - **Better Plot, Less Code**: Simplify the process of creating high-quality figures ⚛️
  - **Compatibility**: Compatible with [matplotlib](https://matplotlib.org) 📊
  - **Customization**: Customize your configuration to fit your needs 🎨
  - **Reproducibility**: Save your package status to make plots reproducible 📦

  [See more details](https://soichiroyamane.github.io/gsplot/guides/demo/4_paper_plot.html)
  ![example](docs/_static/tutorial/SC_cal.png)

  [See more details](https://soichiroyamane.github.io/gsplot/guides/demo/13_REPL.html)
  ![repl_tutorial](./docs/_static/tutorial/repl_tutorial_sp.gif)

  To use **gsplot**, ensure that you have `Python 3.10+` installed. You can install the package using `pip`:
  ```bash
  pip install gsplot
  ```

  This repository was forked from codes developed by Giordano Mattoni.
  - Giordano Mattoni
  - Soichiro Yamane

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


pkgId: 7661ff556bde05d9faee630fe92e45744d281b75c2b548d124a13e9adda21d70
name: python-gspreadplusplus-help
arch: noarch
version: 2.1.1
epoch: 0
release: 1
summary: Development documents and examples for gspreadplusplus
url: https://github.com/daniel-simanek/gspreadplusplus
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gspreadplusplus-2.1.1-1.src.rpm
location_href: Packages/python-gspreadplusplus-help-2.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python library that enhances Google Sheets operations with additional functionality and improved data type handling.



  - Transfer Spark DataFrames to Google Sheets with proper type conversion
  - Intelligent handling of various data types (numbers, dates, timestamps, etc.)
  - Preserve or update sheet headers
  - Selective column clearing options
  - Automatic date formatting
  - Sheet dimension management
  - Configuration management with key-value storage



  ```bash
  pip install gspreadplusplus
  ```



  - Python 3.7+
  - gspread
  - pyspark
  - google-auth





  ```python
  from gspreadplusplus import GPP
  from pyspark.sql import SparkSession


  spark = SparkSession.builder.appName("example").getOrCreate()
  df = spark.createDataFrame([
      ("2024-01-01", 100, "Complete"),
      ("2024-01-02", 150, "Pending")
  ], ["date", "amount", "status"])


  creds_json = {
      "type": "service_account",
      
  }


  GPP.df_to_sheets(
      df=df,
      spreadsheet_id="your_spreadsheet_id",
      sheet_name="Sheet1",
      creds_json=creds_json
  )
  ```



  ```python
  GPP.df_to_sheets(
      df=df,
      spreadsheet_id="your_spreadsheet_id",
      sheet_name="Sheet1",
      creds_json=creds_json,
      english_locale=True,  # Use '.' as decimal separator
      keep_header=True,     # Preserve existing header row
      erase_whole=False     # Clear only necessary columns
  )
  ```



  The library provides functionality to store and update configuration values in a Google Sheet. By default, it uses a sheet named "CONFIG" with keys in column A and values in column B.

  ```python

  result = GPP.set_config(
      spreadsheet_id="your_spreadsheet_id",
      key="api_endpoint",
      value="https://api.example.com",
      creds_json=creds_json,
      sheet_name="CONFIG"  # Optional, defaults to "CONFIG"
  )

  if result == 0:
      print("Configuration updated successfully")
  else:
      print("Error updating configuration")
  ```

  The `set_config` function will:
  - Search for the key in column A
  - If found, update the corresponding value in column B
  - If not found, append a new row with the key-value pair
  - Return 0 on success, 1 on error



  The library automatically handles conversion of various data types:

  - Strings
  - Integers (regular, long, bigint)
  - Floating point numbers (double, float)
  - Decimals
  - Dates
  - Timestamps
  - Booleans

  Null values are converted to:
  - 0 for numeric types
  - Empty string for other types



  The library implements comprehensive error handling:
  - Returns status codes for operations (0 for success, 1 for failure)
  - Prints detailed error messages for debugging
  - Gracefully handles missing keys, sheet access issues, and credential problems



  Contributions are welcome! Please feel free to submit a Pull Request.



  This project is licensed under the MIT License - see the LICENSE file for details.


pkgId: 1c4da9b0ea4929d6ffe28a8d7d79e8738c657327521030f9362982c5f102ae89
name: python-gtecble-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for gtecble
url: https://www.gtec.at
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gtecble-0.0.4-1.src.rpm
location_href: Packages/python-gtecble-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  This python library allows to communicate with Gtec.BLE devices.



  ```pip install gtecble```



  This example shows how to setup a data acquisition with a Gtec.BLE device.

  ``` Python
  import gtecble as gble

  discovered_devices = []
  def on_devices_discovered(devices):
      global discovered_devices
      cnt = 0
      discovered_devices = devices
      for device in discovered_devices:
          print('#' + str(cnt) + ': ' + device)
          cnt = cnt+1

  def on_data_available(device, data):
      print(data)

  ver = gble.GtecBLE.GetApiVersion()
  print('API version: ' + str(ver))

  gble.GtecBLE.AddDevicesDiscoveredEventhandler(on_devices_discovered)
  gble.GtecBLE.StartScanning()
  print('Scanning for devices...')

  selectedId = int(input('Select device by id:\n'))

  gble.GtecBLE.StopScanning()
  gble.GtecBLE.RemoveDevicesDiscoveredEventhandler()
  print('Stopped scanning for devices...')

  device = gble.GtecBLE(discovered_devices[selectedId])
  print('Serial number: ' + device.SerialNumber)
  print('ModelNumber: '+ device.ModelNumber)
  print('FirmwareRevision: '+ device.FirmwareRevision)
  print('HardwareRevision: '+ device.HardwareRevision)
  print('ManufacturerName: ' + device.ManufacturerName)
  print('NumberOfAcquiredChannels: ' + str(device.NumberOfAcquiredChannels))
  print('SamplingRate: ' + str(device.SamplingRate))
  print('ChannelTypes: ' + str(device.ChannelTypes))

  device.AddDataAvailableEventhandler(on_data_available)
  input('Press ENTER to stop acquisition.')
  device.RemoveDataAvailableEventhandler()

  del device
  ```


pkgId: 8ee24de4151aa16e1f86166400e7e4e313a06b77f8680d80fbdf01b70e90c5c5
name: python-guan-help
arch: noarch
version: 0.1.131
epoch: 0
release: 1
summary: Development documents and examples for guan
url: https://py.guanjihuan.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-guan-0.1.131-1.src.rpm
location_href: Packages/python-guan-help-0.1.131-1.noarch.rpm
checksum_type: sha256
description:
  Guan is an open-source python package developed and maintained by https://www.guanjihuan.com/about (Ji-Huan Guan, 关济寰). The primary location of this package is on website https://py.guanjihuan.com. The GitHub location of this package is on https://github.com/guanjihuan/py.guanjihuan.com.


pkgId: 8473d063feb756f629efde547377bde119f5863d2e19d4fa6d9a5cfec2facf4d
name: python-guardian-client-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for guardian-client
url: https://pypi.org/project/guardian-client/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-guardian-client-1.1.0-1.src.rpm
location_href: Packages/python-guardian-client-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A CLI and SDK client for Protect AI's Guardian service. You can find more information about this service here: https://protectai.com/guardian



  The Guardian Scanner's CLI offers a convenient way of submitting a scan and receiving the scan report along with an exit code that can be used to block model deployment depending upon the discovered vulnerabilities.



  ``` shell
  pip install guardian-client
  ```



  These environment variables are required for setting up the authorization with the API. The admin of your account should be able to provide you with these.

  ``` shell


  export GUARDIAN_ENDPOINT=


  export GUARDIAN_SCANNER_CLIENT_ID=


  export GUARDIAN_SCANNER_CLIENT_SECRET=
  ```



  That's it! Now you should be all set to start scanning your models.

  ``` shell

  guardian-client scan <model_uri> \
         [--base-url <base-url>] \
         [--block-on-errors] \
         [--report-only] \
         [--log-level <log-level>] \
         [--poll-interval-secs <n_secs>] \
         [--silent] || echo $?
  ```



  ``` shell
  guardian-client get-scan <scan_id> \
         [--base-url <base-url>] \
         [--block-on-errors] \
         [--report-only] \
         [--log-level <log-level>] \
         [--silent] || echo $?
  ```



  - `--base-url` The API URL if not set as environment variable (required)

  - `model_uri` The Path where the model is stored e.g. S3 bucket (required)

  - `--block-on-errors` A boolean flag indicating the error in scanning should also lead to a block. These errors are only specific to model scanning.

  - `--log-level` Can be set to any of the following: error, info, or debug

  - `--silent` Disable all logging / reporting

  - `--report-only` Print out the scan report and skip evaluating it for blocking.

  - `--poll-interval-secs` The interval in seconds to wait before polling the server for scan status. Default is 5.


  The CLI returns following exit codes that can be used by the downstream applications to block a deployment.

  - **0** Successful scan without violating any of your organization's policies

  - **1** Successful scan with issues violating your organization's policies

  - **2** Scan failed for any reason





  ``` shell
  guardian-client scan s3://a-bucket/path/ || echo $?
  ```


  ```
  guardian-client scan s3://a-bucket/path/ --report-only

  ```



  ```
  guardian-client get-scan c4fb7d8c-fc8c-422e-814c-c4441982e726 --report-only
  ```



  In addition to the CLI, you can also integrate the scanner within your python application. The installation and environment setup is same as CLI when using the SDK.

  Example for submitting a scan:

  ``` python

  from guardian_client import GuardianAPIClient


  base_url = "<ADD_YOUR_SERVICE_URL>"
  model_uri = "<ADD_YOUR_MODEL_URL>"


  guardian = GuardianAPIClient(base_url=base_url)


  response = guardian.scan(model_uri=model_uri)



  assert response.get("http_status_code") == 200
  assert response.get("scan_status_json") != None
  assert response.get("scan_status_json").get("aggregate_eval_outcome") != "ERROR"

  if response.get("scan_status_json").get("aggregate_eval_outcome") == "FAIL":
    print(f"Model {model_uri} was blocked because it failed your organization's security policies")
  ```

  Example for retrieving a previous scan's results:

  ```python

  from guardian_client import GuardianAPIClient


  base_url = "<ADD_YOUR_SERVICE_URL>"


  guardian = GuardianAPIClient(base_url=base_url)


  retrieved = guardian.get_scan(scan_uuid="c4fb7d8c-fc8c-422e-814c-c4441982e726")

  print(retrieved.get("scan_status_json"))
  ```





  ``` python
  def __init__(
      self,
      base_url: str,
      scan_endpoint: str = "scans",
      api_version: str = "v1",
      log_level: str = "INFO",
  ) -> None:
      """
      Initializes the Guardian API client.

      Args:
          base_url (str): The base URL of the Guardian API.
          scan_endpoint (str, optional): The endpoint for scanning. Defaults to "scans".
          api_version (str, optional): The API version. Defaults to "v1".
          log_level (str, optional): The log level. Defaults to "INFO".

      Raises:
          ValueError: If the log level is not one of "DEBUG", "INFO", "ERROR", or "CRITICAL".

      """
  ```




  ``` python
  def scan(self, model_uri: str, poll_interval_secs: int = 5) -> Dict[str, Any]:
      """
      Submits a scan request for the given URI and polls for the scan status until it is completed.

      Args:
          uri (str): The URI to be scanned.
          poll_interval_secs (int, optional): The interval in seconds to poll for the scan status.
              If <= 0, the function returns immediately after submitting the scan. Defaults to 5.

      Returns:
          dict: A dictionary containing the HTTP status code and the scan status JSON.
                  If an error occurs during the scan submission or polling, the dictionary
                  will also contain the error details.
      """
  ```


  ```python
  def get_scan(self, scan_uuid: str) -> Dict[str, Any]:
      """
      Retrieves the scan results for a given past scan.

      Args:
          scan_uuid (str): The ID of the scan to retrieve.

      Returns:
          dict: A dictionary containing the HTTP status code and the scan status JSON.
                  If an error occurred during the scan, the dictionary
                  will contain the error details instead of the scan status.
      """
  ```


pkgId: 28b7197a5a6106696e5c6a80d8fc659fc59d70946b1f0cc2621be32ea5f0135b
name: python-guardian-client-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for guardian-client
url: https://pypi.org/project/guardian-client/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-guardian-client-1.1.1-1.src.rpm
location_href: Packages/python-guardian-client-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A CLI and SDK client for Protect AI's Guardian service. You can find more information about this service here: https://protectai.com/guardian



  The Guardian Scanner's CLI offers a convenient way of submitting a scan and receiving the scan report along with an exit code that can be used to block model deployment depending upon the discovered vulnerabilities.



  ``` shell
  pip install guardian-client
  ```



  These environment variables are required for setting up the authorization with the API. The admin of your account should be able to provide you with these.

  ``` shell


  export GUARDIAN_ENDPOINT=


  export GUARDIAN_SCANNER_CLIENT_ID=


  export GUARDIAN_SCANNER_CLIENT_SECRET=
  ```



  That's it! Now you should be all set to start scanning your models.

  ``` shell
  guardian-client scan <model_uri> \
         [--base-url <base-url>] \
         [--block-on-errors] \
         [--report-only] \
         [--log-level <log-level>] \
         [--poll-interval-secs <n_secs>] \
         [--silent] || echo $?
  ```



  ``` shell
  guardian-client get-scan <scan_id> \
         [--base-url <base-url>] \
         [--block-on-errors] \
         [--report-only] \
         [--log-level <log-level>] \
         [--silent] || echo $?
  ```



  - `--base-url` The API URL if not set as environment variable (required)

  - `model_uri` The Path where the model is stored e.g. S3 bucket (required)

  - `--block-on-errors` A boolean flag indicating the error in scanning should also lead to a block. These errors are only specific to model scanning.

  - `--log-level` Can be set to any of the following: error, info, or debug

  - `--silent` Disable all logging / reporting

  - `--report-only` Print out the scan report and skip evaluating it for blocking.

  - `--poll-interval-secs` The interval in seconds to wait before polling the server for scan status. Default is 5.



  The CLI returns following exit codes that can be used by the downstream applications to block a deployment.

  - **0** Successful scan without violating any of your organization's policies

  - **1** Successful scan with issues violating your organization's policies

  - **2** Scan failed for any reason





  ``` shell
  guardian-client scan s3://a-bucket/path/ || echo $?
  ```



  ```shell
  guardian-client scan s3://a-bucket/path/ --report-only

  ```



  ```shell
  guardian-client get-scan c4fb7d8c-fc8c-422e-814c-c4441982e726 --report-only
  ```



  In addition to the CLI, you can also integrate the scanner within your python application. The installation and environment setup is same as CLI when using the SDK.

  Example for submitting a scan:

  ``` python

  from guardian_client import GuardianAPIClient


  base_url = "<ADD_YOUR_SERVICE_URL>"
  model_uri = "<ADD_YOUR_MODEL_URL>"


  guardian = GuardianAPIClient(base_url=base_url)


  response = guardian.scan(model_uri=model_uri)



  assert response.get("http_status_code") == 200
  assert response.get("scan_status_json") != None
  assert response.get("scan_status_json").get("aggregate_eval_outcome") != "ERROR"

  if response.get("scan_status_json").get("aggregate_eval_outcome") == "FAIL":
    print(f"Model {model_uri} was blocked because it failed your organization's security policies")
  ```

  Example for retrieving a previous scan's results:

  ```python

  from guardian_client import GuardianAPIClient


  base_url = "<ADD_YOUR_SERVICE_URL>"


  guardian = GuardianAPIClient(base_url=base_url)


  retrieved = guardian.get_scan(scan_uuid="c4fb7d8c-fc8c-422e-814c-c4441982e726")

  print(retrieved.get("scan_status_json"))
  ```





  ``` python
  def __init__(
      self,
      base_url: str,
      scan_endpoint: str = "scans",
      api_version: str = "v1",
      log_level: str = "INFO",
  ) -> None:
      """
      Initializes the Guardian API client.

      Args:
          base_url (str): The base URL of the Guardian API.
          scan_endpoint (str, optional): The endpoint for scanning. Defaults to "scans".
          api_version (str, optional): The API version. Defaults to "v1".
          log_level (str, optional): The log level. Defaults to "INFO".

      Raises:
          ValueError: If the log level is not one of "DEBUG", "INFO", "ERROR", or "CRITICAL".

      """
  ```





  ``` python
  def scan(self, model_uri: str, poll_interval_secs: int = 5) -> Dict[str, Any]:
      """
      Submits a scan request for the given URI and polls for the scan status until it is completed.

      Args:
          uri (str): The URI to be scanned.
          poll_interval_secs (int, optional): The interval in seconds to poll for the scan status.
              If <= 0, the function returns immediately after submitting the scan. Defaults to 5.

      Returns:
          dict: A dictionary containing the HTTP status code and the scan status JSON.
                  If an error occurs during the scan submission or polling, the dictionary
                  will also contain the error details.
      """
  ```



  ```python
  def get_scan(self, scan_uuid: str) -> Dict[str, Any]:
      """
      Retrieves the scan results for a given past scan.

      Args:
          scan_uuid (str): The ID of the scan to retrieve.

      Returns:
          dict: A dictionary containing the HTTP status code and the scan status JSON.
                  If an error occurred during the scan, the dictionary
                  will contain the error details instead of the scan status.
      """
  ```


pkgId: 5a6bb0091fc35a3afae55729c48b1c2611a74203d8e44eb139b17ca5f299215e
name: python-guiguts-help
arch: noarch
version: 2.0.0a11
epoch: 0
release: 1
summary: Development documents and examples for guiguts
url: https://pypi.org/project/guiguts/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-guiguts-2.0.0a11-1.src.rpm
location_href: Packages/python-guiguts-help-2.0.0a11-1.noarch.rpm
checksum_type: sha256
description:
  Guiguts - an application to support creation of ebooks for PG

  **If you want to use Guiguts for PPing, rather than to develop the code, see below for [User Installation Notes](#user-installation-notes).**



  1. Install Python & Poetry, clone the repo and create a virtual environment,
     using the OS-specific instructions below.
  2. After following the OS-specific instructions, in the cloned GG2 directory,
     install the GG2 python dependencies in the virtual environment. This will
     install GG2 as an editable package that you can develop and run directly.
     ```bash
     poetry install
     ```
     If additional dependencies are added to GG2, or you use pyenv to switch
     to a new version of python, you will need to re-run this command.
  3. You can then run GG2 directly with `poetry run guiguts`. Alternatively,
     you can start a virtual environment shell with `poetry shell`, then run
     GG2 with `guiguts`.







  1. Download Python 3.11 from [python.org](https://www.python.org/).
  2. Install – default dir is `C:\Users\<username>\AppData\Local\Programs\Python\Python311`
  3. Ensure this dir is in PATH variable



  [pyenv](https://github.com/pyenv/pyenv/blob/master/README.md) lets you easily switch between
  multiple versions of Python, if that would be useful for development/testing.

  1. Clone the pyenv-win repo: `git clone https://github.com/pyenv-win/pyenv-win.git "$HOME\.pyenv"`
  2. Add environment variables (can execute these in a Powershell window):
      ```powershell
      [System.Environment]::SetEnvironmentVariable('PYENV',$env:USERPROFILE + "\.pyenv\pyenv-win\","User")
      [System.Environment]::SetEnvironmentVariable('PYENV_ROOT',$env:USERPROFILE + "\.pyenv\pyenv-win\","User")
      [System.Environment]::SetEnvironmentVariable('PYENV_HOME',$env:USERPROFILE + "\.pyenv\pyenv-win\","User")
      [System.Environment]::SetEnvironmentVariable('path', $env:USERPROFILE + "\.pyenv\pyenv-win\bin;" + $env:USERPROFILE + "\.pyenv\pyenv-win\shims;" + [System.Environment]::GetEnvironmentVariable('path', "User"),"User")
      ```
  3. In a new shell, install version(s) of Python, e.g. `pyenv install 3.11.7`,
  `pyenv install 3.12.0`, etc.
  4. To set python version, use `pyenv global 3.11.7`, for example.



  1. https://python-poetry.org/docs/#installing-with-the-official-installer
  2. `(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -`
  3. Installs into `C:\Users\<username>\AppData\Roaming`
  4. Adds top-level “poetry” wrapper in `C:\Users\<username>\AppData\Roaming\Python\Scripts`
  5. Ensure the latter is in PATH variable



  Either clone the [GG2 Github repo](https://github.com/DistributedProofreaders/guiguts-py)
  or a fork thereof.



  In the cloned GG2 directory, create a virtual environment using a version of
  python you installed above.
     * Single python version (in git bash shell)
       ```bash
       poetry env use ~/AppData/Local/Programs/Python/Python311/python.exe
       ```
     * If using pyenv (in git bash shell)
       ```bash
       poetry config virtualenvs.prefer-active-python true
       ```



  Developing Guiguts on macOS requires installing [Homebrew](https://brew.sh/) first.



  Install python and python-tk using Homebrew. Note that we install and use a
  specific version in the commands below for consistency with other developers.

  ```bash
  brew install python@3.11 python-tk@3.11
  ```



  We also install poetry using Homebrew.

  ```bash
  brew install poetry
  ```



  Either clone the [GG2 Github repo](https://github.com/DistributedProofreaders/guiguts-py)
  or a fork thereof.



  In the cloned GG2 directory, create a virtual environment using a version of
  python you installed above.

  ```bash
  poetry env use $(brew --prefix)/bin/python3.11
  ```



  1. Install Python, Poetry, etc.
     * Example from Ubuntu 22.04 -- adapt to your own Linux distro
       ```bash
       sudo apt install python3.11 python3-pip python3-tk idle-python3.11 git
       sudo python3.11 -m pip install poetry
       
       python3.11 -m tkinter
       ```
     * The last line above tests that Tk is working with Python. It should open a small
       window on your screen. Click the `Click me!` button to test mouse clicks, and
       `QUIT` to close the window, ending the test.
  2. Clone the [GG2 Github repo](https://github.com/DistributedProofreaders/guiguts-py)
     or a fork thereof.
  3. In the cloned GG2 directory, create a virtual environment using a version of
     python you installed above.
       ```bash
       poetry env use $(which python3.11)
       ```



  Guiguts 2 uses [flake8](https://pypi.org/project/flake8) and
  [pylint](https://www.pylint.org) for static code analysis, and
  [black](https://pypi.org/project/black) for consistent styling.  All use default
  settings, with the exception of maximum line length checking which is adjusted
  in the recommended manner (using the `.flake8` file and the `tool.pylint`
  section of `pyproject.toml`) to avoid conflicts with black.

  All of the above tools will be installed via `poetry` as described above.

  `poetry run flake8 .` will check all `src` & `tests` python files.

  `poetry run pylint --recursive y .` will check all `src` & `tests` python files.

  `poetry run black .` will reformat all `src` & `tests` python files where necessary.

  This project uses Github Actions to ensure none of the above tools report any
  error.

  Naming conventions from [PEP8](https://pep8.org/#prescriptive-naming-conventions)
  are used. To summarize, class names use CapWords; constants are ALL_UPPERCASE;
  most other variables, functions and methods are all_lowercase.



  [Google-style docstrings](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings)
  are used to document modules, classes, functions, etc.

  [Sphinx](https://www.sphinx-doc.org/en/master/index.html) will be installed by
  poetry (above) and can be used to create HTML documentation by running the following command:
  ```bash
  poetry run python -m sphinx -b html docs docs/build`
  ```

  HTML docs will appear in the `docs/build` directory.

  Sphinx can also be used to check coverage, i.e. that docstrings have been used everywhere
  appropriate:
  ```bash
  poetry run python -m sphinx -M coverage docs docs/build`
  ```

  This project uses Github Actions to ensure running sphinx does not report an error, and
  that the coverage check does not report any undocumented items.



  [Mypy](https://mypy.readthedocs.io/en/stable/index.html) will be installed by
  poetry (above) and is used for static type checking. Where developers have added
  [type hints](https://peps.python.org/pep-0484/), mypy will issue warnings when those
  types are used incorrectly.

  It is not intended that every variable should have its type annotated, but developers
  are encouraged to add type hints to function definitions, e.g.
  ```python
  def myfunc(num: int) -> str:
      ...
  ```
  Note that functions without type annotation will not be type checked. The
  [type hints cheat sheet](https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html)
  has a summary of how to use type annotations for various common situations.

  To type check the Guiguts package and the test routines:
  ```bash
  poetry run mypy -p guiguts
  poetry run mypy tests
  ```



  [Pytest](https://docs.pytest.org) will be installed by poetry (above) and is used for testing.

  All tests can be run using the following command:
  `poetry run pytest`

  Developers are encouraged to add tests (as appropriate) when new code is added to the project.

  This project uses Github Actions to ensure running `pytest` does not report an error.





  Three debugger configs are provided.

  - "Guiguts"
      - Run Guiguts with debug output enabled
  - "Guiguts (most recent file)"
      - Run Guiguts with debug output enabled
      - Open the most recently opened file
  - "Guiguts (no debug output)"
      - Run Guiguts without debug output

  Requirement: [Python Debugger][vsc_debugpy] extension

  [vsc_debugpy]: https://marketplace.visualstudio.com/items?itemName=ms-python.debugpy

  Use the "Python: Select Interpreter" command to choose the appropriate Python environment. Your Poetry config should be detected and available to choose. If the Poetry config is not auto-detected, use `poetry env info -e` in the shell to find the Poetry-configured python interpreter. Then in the "Python: Select Interpreter" command, choose "Enter interpreter path..." and paste the full path to the `python` executable.



  This section contains notes from users who have installed Guiguts 2 on various platforms to use for PPing. **If you are a developer, you probably want the [Development Installation Notes](#common-development-setup).**

  Note that although the developers' installation notes specify Python 3.11,
  Guiguts 2 also works with version 3.12 if that is more convenient



  1. Install Python 3.11 (or 3.12) from [Python.org](https://www.python.org/downloads/windows/)
  if you haven't already done that.
  2. Type `pip install guiguts` (or `pip install guiguts --upgrade` to upgrade from a
  previous version of GG2).
  3. Type `guiguts` to run GG2



  Check you have python3:

      python3 --version

  If not:

      sudo apt install python3

  Next, check you have pip:

      python3 -m pip --version

  If not:

      sudo apt install python3-pip

  Now try this command:

      python3 -m pip install guiguts

  You might come across this error:

      error: externally-managed-environment

      × This environment is externally managed
      ╰─> To install Python packages system-wide, try apt install
          python3-xyz, where xyz is the package you are trying to
          install.

          If you wish to install a non-Debian-packaged Python package,
          create a virtual environment using python3 -m venv path/to/venv.
          Then use path/to/venv/bin/python and path/to/venv/bin/pip. Make
          sure you have python3-full installed.

          If you wish to install a non-Debian packaged Python application,
          it may be easiest to use pipx install xyz, which will manage a
          virtual environment for you. Make sure you have pipx installed.

          See /usr/share/doc/python3.11/README.venv for more information.

  Let's go with the third option, and see if you have pipx:

      pipx install guiguts

  If you get this error:

      -bash: pipx: command not found

  You need to install pipx:

      sudo apt install pipx

  Then run this command before you install anything using pipx:

      pipx ensurepath

  Open a new terminal or re-login and try this command:

      pipx install --include-deps guiguts

  If you get an error saying no IdleLib module could be found:

      sudo apt-get install python3-Tk
      sudo apt-get install idle3

  Now try the install command again:

      pipx install --include-deps guiguts

  You'll need to use this command to open GG2 each time:

      pipx run guiguts

  To update, you can use:

      pipx upgrade guiguts



  https://stackoverflow.com/questions/6587507/how-to-install-pip-with-python-3
  https://stackoverflow.com/questions/43987444/install-pip-for-python-3
  https://realpython.com/python-pipx/
  https://askubuntu.com/questions/1183317/modulenotfounderror-no-module-named-idlelib




  Copyright Contributors to the [Guiguts-py](https://github.com/DistributedProofreaders/guiguts-py) project

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

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.


pkgId: 6ead1f9a596f423447694580a8c8521ee5f23bc94c8499e0ee9e227600d96806
name: python-gunfireapi-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for gunfireapi
url: https://github.com/ihateapples/gunfireapi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gunfireapi-0.1.0-1.src.rpm
location_href: Packages/python-gunfireapi-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A simple Python module to interact with the Gunfire API for uploading files and handling responses. This module allows easy file uploads to the Gunfire API and retrieval of the corresponding URL.



  You can install the package via pip:

  ```bash
  pip install gunfireapi


  ```python

  from gunfireapi import upload_file

  file_path = "path/to/your/file.png"

  file_url = upload_file(file_path)

  if file_url:
      print("upload success")
      print("uploaded url:", file_url)
  else:
      print("upload failed")


pkgId: 0ec8ce3f2941f7fd39c610503d7ee0daced5e1b0734ad1c4968c212dc4c20daa
name: python-gupy-framework-help
arch: noarch
version: 0.2.5
epoch: 0
release: 1
summary: Development documents and examples for gupy-framework
url: https://github.com/speartech/gupy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gupy-framework-0.2.5-1.src.rpm
location_href: Packages/python-gupy-framework-help-0.2.5-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://github.com/SPEARTECH/Gupy/blob/main/gupy_logo.png" alt="Welcome to Gupy :)" width="50%">


  Gupy is a CLI tool for generating templates of cross-platform applications based on Go, Vue, and Python!

  Templates include:
  - PWAs                 - **Vue,Go Web Assembly**
  - Django Websites      - **Vue, Python, Go Extensions, Go Web Assembly, Cython Extensions**
  - Desktop Applications - **Gin/Flask, Go Extensions, Go Web Assembly, Cython Extensions**
  - CLI Tools            - **Python, Go Extensions, Cython Extensions**

  Future roadmap:
  - Mobile projects & compilation with Go build
  - API creation (flask, fastapi, gin)
  - Postgres instead of sqlite
  - Go website projects


pkgId: ab683f74c847f6485698f85784cd4c09b9ac42c968c7d3bff694ec6e1af195f4
name: python-gurobi-logtools-help
arch: noarch
version: 3.2.0
epoch: 0
release: 1
summary: Development documents and examples for gurobi-logtools
url: https://github.com/Gurobi/gurobi-logtools
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gurobi-logtools-3.2.0-1.src.rpm
location_href: Packages/python-gurobi-logtools-help-3.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/gurobi-logtools?label=PyPI)](https://pypi.python.org/pypi/gurobi-logtools)
  [![License](https://img.shields.io/github/license/Gurobi/gurobi-logtools?color=blue&label=License)](https://github.com/Gurobi/gurobi-logtools/blob/master/LICENSE)
  [![Test Python Package](https://github.com/Gurobi/gurobi-logtools/actions/workflows/python-tox.yml/badge.svg?branch=master)](https://github.com/Gurobi/gurobi-logtools/actions/workflows/python-tox.yml)

  Extract information from Gurobi log files and generate [pandas DataFrames](https://pandas.pydata.org/) or Excel worksheets for further processing. Also includes a wrapper for out-of-the-box interactive visualizations using the plotting library [Plotly](https://plotly.com/python/).

  > [!NOTE]
  > We have renamed the project to `gurobi-logtools`, so please also adapt the import statement accordingly:
  >
  > `import gurobi_logtools as glt`

  ![performance plot](https://github.com/Gurobi/gurobi-logtools/raw/master/assets/performance-plot.png)



  ```
  python -m pip install gurobi-logtools
  ```

  It is recommended to prepend the `pip install` command with `python -m` to ensure that the package is installed using the correct Python version currently active in your environment.

  See [CHANGELOG](https://github.com/Gurobi/gurobi-logtools/blob/master/CHANGELOG.md) for added, removed or fixed functionality.



  First, you need a set of Gurobi log files to compare, e.g.,
    - results from several model instances
    - comparisons of different parameter settings
    - performance variability experiments involving multiple random seed runs
    - ...

  You may also use the provided [gurobi-logtools.ipynb notebook](https://github.com/Gurobi/gurobi-logtools/blob/master/gurobi-logtools.ipynb) with the [example data set](https://github.com/Gurobi/gurobi-logtools/tree/master/data) to get started.
  Additionally, there is a [Gurobi TechTalk demonstrating how to use it (YouTube)](https://youtu.be/wbg4Zr_A1s8):

  [![](https://github.com/Gurobi/gurobi-logtools/raw/master/assets/youtube-thumbnail.png)](https://youtu.be/wbg4Zr_A1s8)


  1. parse log files:
      ```Python
      import gurobi_logtools as glt

      results = glt.parse(["run1/*.log", "run2/*.log"])
      summary = results.summary()
      nodelog_progress = results.progress("nodelog")
      ```
      Depending on your requirements, you may need to filter or modify the resulting DataFrames.

  2. draw interactive charts, preferably in a [Jupyter Notebook](https://jupyter.org/):

      - final results from the individual runs:
      ```Python
      glt.plot(summary, type="box")
      ```

      - progress charts for the individual runs:
      ```Python
      glt.plot(nodelog_progress, y="Gap", color="Log", type="line")
      ```

      - progress of the norel heuristic (note, the time recorded here is since the start of norel, and does not include presolve + read time):
      ```Python
      glt.plot(results.progress("norel"), x="Time", y="Incumbent", color="Log", type="line")
      ```

      These are just examples using the [Plotly Python library](https://plotly.com/python/) - of course, any other plotting library of your choice can be used to work with these DataFrames.


  Convert your log files to Excel worksheets right on the command-line:

  ```
  python -m gurobi_logtools myrun.xlsx data/*.log
  ```

  List all available options and how to use the command-line tool:

  ```
  python -m gurobi_logtools --help
  ```


  The command line tool can also rename log files according to the parameters set and model solved in a given run. This is useful if your log files do not have a consistent naming scheme, or if multiple runs are logged per file and you want to extract the individual runs.

  For example:

  ```
  python -m gurobi_logtools --write-to-dir nicenames summary.xlsx tests/assets/combined/*.log
  ```

  separates logs for individual runs in the input files and writes copies to the 'nicenames' folder with a consistent naming scheme:

  ```
  > ls nicenames
  912-MIPFocus1-Presolve1-TimeLimit600-glass4-0.log
  912-MIPFocus1-Presolve1-TimeLimit600-glass4-1.log
  912-MIPFocus1-Presolve1-TimeLimit600-glass4-2.log
  912-MIPFocus2-Presolve1-TimeLimit600-glass4-0.log
  912-MIPFocus2-Presolve1-TimeLimit600-glass4-1.log
  912-MIPFocus2-Presolve1-TimeLimit600-glass4-2.log
  912-Presolve1-TimeLimit600-glass4-0.log
  912-Presolve1-TimeLimit600-glass4-1.log
  912-Presolve1-TimeLimit600-glass4-2.log
  ```


pkgId: ab021b7f31671a433c6142331445676be505cc56964a8f2e0f6057ad994fe697
name: python-gurux-dlms-agent-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for gurux-dlms-agent
url: https://github.com/intelmeter/Gurux.DLMS.Python
rpm_license: GPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gurux-dlms-agent-1.0.1-1.src.rpm
location_href: Packages/python-gurux-dlms-agent-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  See An [Gurux](http://www.gurux.org/ "Gurux") for an overview.
  Join the Gurux Community or follow [@Gurux](https://twitter.com/guruxorg "@Gurux") for project updates.
  gurux_dlms library is a high-performance Python component that helps you to read you DLMS/COSEM compatible electricity, gas or water meters. We have try to make component so easy to use that you do not need understand protocol at all.
  For more info check out [Gurux.DLMS](http://www.gurux.fi/index.php?q=Gurux.DLMS "Gurux.DLMS").
  We are updating documentation on Gurux web page.
  Read should read [DLMS/COSEM FAQ](http://www.gurux.org/index.php?q=DLMSCOSEMFAQ) first to get started. Read Instructions for making your own [meter reading application](http://www.gurux.org/index.php?q=DLMSIntro) or build own
  DLMS/COSEM [meter/simulator/proxy](http://www.gurux.org/index.php?q=OwnDLMSMeter).
  If you have problems you can ask your questions in Gurux [Forum](http://www.gurux.org/forum).
  Before start the client example go Gurux.DLMS.Client.Example.python directory and run
  ```Python
  pip install -r requirements.txt
  ```
  You can use any connection (TCP, serial, PLC) library you want to.
  Gurux.DLMS classes only parse the data.


pkgId: 4af4a9bec1e915e47375c5eb15b2e85b36916a25ea2515279577d759ad7a5879
name: python-gutmetrics-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for gutmetrics
url: https://github.com/yourusername/gutmetrics
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gutmetrics-0.1.2-1.src.rpm
location_href: Packages/python-gutmetrics-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for predicting gut microbiome α-diversity from blood metabolomics data, based on the research published in Blood metabolome predicts gut microbiome α-diversity in humans.


pkgId: 6a6c285e08346548e92a46567996d54993c0ea40ed74e02303d8c0919cc311ec
name: python-gwcs-help
arch: noarch
version: 0.22.0
epoch: 0
release: 1
summary: Development documents and examples for gwcs
url: https://github.com/spacetelescope/gwcs
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gwcs-0.22.0-1.src.rpm
location_href: Packages/python-gwcs-help-0.22.0-1.noarch.rpm
checksum_type: sha256
description:
  Generalized World Coordinate System (GWCS) is an `Astropy`_ affiliated package providing tools for managing the World Coordinate System of astronomical data.
  GWCS takes a general approach to the problem of expressing transformations between pixel and world coordinates. It supports a data model which includes the entire transformation pipeline from input coordinates (detector by default) to world coordinates. It is tightly integrated with `Astropy`_.
  - Transforms are instances of ``astropy.Model``. They can be chained, joined or combined with arithmetic operators using the flexible framework of compound models in `astropy.modeling`_.
  - Celestial coordinates are instances of ``astropy.SkyCoord`` and are transformed to other standard celestial frames using `astropy.coordinates`_.
  - Time coordinates are represented by ``astropy.Time`` and can be further manipulated using the tools in `astropy.time`_
  - Spectral coordinates are ``astropy.Quantity`` objects and can be converted to other units using the tools in `astropy.units`_.
  For complete features and usage examples see the `documentation`_ site.

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


pkgId: 2710edb7c0306ac0897370fa96d52f515429944b195412dd24625526a0618969
name: python-gwosc-help
arch: noarch
version: 0.7.2
epoch: 0
release: 1
summary: Development documents and examples for gwosc
url: https://gwosc.readthedocs.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gwosc-0.7.2-1.src.rpm
location_href: Packages/python-gwosc-help-0.7.2-1.noarch.rpm
checksum_type: sha256
description:
  The `gwosc` package provides an interface to querying the open data
  releases hosted on <https://gwosc.org> from the GEO, LIGO,
  and Virgo gravitational-wave observatories.



  [![PyPI version](https://badge.fury.io/py/gwosc.svg)](http://badge.fury.io/py/gwosc)
  [![Conda version](https://img.shields.io/conda/vn/conda-forge/gwosc.svg)](https://anaconda.org/conda-forge/gwosc/)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1196306.svg)](https://doi.org/10.5281/zenodo.1196306)
  [![License](https://img.shields.io/pypi/l/gwosc.svg)](https://choosealicense.com/licenses/mit/)
  ![Supported Python versions](https://img.shields.io/pypi/pyversions/gwosc.svg)



  [![Build status](https://git.ligo.org/gwosc/client/badges/main/pipeline.svg)](https://git.ligo.org/gwosc/client/-/pipelines)
  ![Code coverage](https://git.ligo.org/gwosc/client/badges/main/coverage.svg)
  [![Documentation](https://readthedocs.org/projects/gwosc/badge/?version=latest)](https://gwosc.readthedocs.io/en/latest/?badge=latest)



  To install:

      conda install -c conda-forge gwosc

  or

      pip install gwosc



  To search for available datasets (correct as of March 14 2018):

  ```python
  >>> from gwosc import datasets
  >>> datasets.find_datasets()
  ['GW150914', 'GW151226', 'GW170104', 'GW170608', 'GW170814', 'GW170817', 'LVT151012', 'O1', 'S5', 'S6']
  >>> datasets.find_datasets(detector='V1')
  ['GW170814', 'GW170817']
  >>> datasets.find_datasets(type='run')
  ['O1', 'S5', 'S6']
  ```

  To query for the GPS time of an event dataset (or vice-versa):

  ```python
  >>> datasets.event_gps('GW170817')
  1187008882.43
  >>> datasets.event_at_gps(1187008882)
  'GW170817'
  ```

  Similar queries are available for observing run datasets:

  ```python
  >>> datasets.run_segment('O1')
  (1126051217, 1137254417)
  >>> datasets.run_at_gps(1135136350)  # event_gps('GW151226')
  'O1'
  ```



  You can search for remote data URLS based on the event name:

  ```python
  >>> from gwosc.locate import get_event_urls
  >>> get_event_urls('GW150914')
  ['https://gwosc.org/eventapi/json/GWTC-1-confident/GW150914/v3/H-H1_GWOSC_4KHZ_R1-1126259447-32.hdf5', 'https://gwosc.org/eventapi/json/GWTC-1-confident/GW150914/v3/H-H1_GWOSC_4KHZ_R1-1126257415-4096.hdf5', 'https://gwosc.org/eventapi/json/GWTC-1-confident/GW150914/v3/L-L1_GWOSC_4KHZ_R1-1126259447-32.hdf5', 'https://gwosc.org/eventapi/json/GWTC-1-confident/GW150914/v3/L-L1_GWOSC_4KHZ_R1-1126257415-4096.hdf5']
  ```

  You can down-select the URLs using keyword arguments:

  ```python
  >>> get_event_urls('GW150914', detector='L1', duration=32)
  ['https://gwosc.org/eventapi/json/GWTC-1-confident/GW150914/v3/L-L1_GWOSC_4KHZ_R1-1126259447-32.hdf5']
  ```



  You can search for remote data URLs based on the GPS time interval as
  follows:

  ```python
  >>> from gwosc.locate import get_urls
  >>> get_urls('L1', 968650000, 968660000)
  ['https://gwosc.org/archive/data/S6/967835648/L-L1_LOSC_4_V1-968646656-4096.hdf5', 'https://gwosc.org/archive/data/S6/967835648/L-L1_LOSC_4_V1-968650752-4096.hdf5', 'https://gwosc.org/archive/data/S6/967835648/L-L1_LOSC_4_V1-968654848-4096.hdf5', 'https://gwosc.org/archive/data/S6/967835648/L-L1_LOSC_4_V1-968658944-4096.hdf5']
  ```

  This arguments for this function are as follows

  -   `detector` : the prefix of the relevant gravitational-wave
      interferometer, either `'H1'` for LIGO-Hanford, or `'L1'` for LIGO
      Livingston,
  -   `start`: the GPS start time of the interval of interest
  -   `end`: the GPS end time of the interval of interest

  By default, this method will return the paths to HDF5 files for the 4
  kHz sample-rate data, these can be specified as keyword arguments. For
  full information, run

  ```python
  >>> help(get_urls)
  ```



  You can also search for Timeline segments, based on a flag name, and a
  GPS time interval as follows:

  ```python
  >>> from gwosc.timeline import get_segments
  >>> get_segments('H1_DATA', 1126051217, 1126151217)
  [(1126073529, 1126114861), (1126121462, 1126123267), (1126123553, 1126126832), (1126139205, 1126139266), (1126149058, 1126151217)]
  ```

  The output is a `list` of `(start, end)` 2-tuples which each represent a
  semi-open time interval.

  For documentation on what flags are available, for example for the O1
  science run, see [the O1 data release page](https://gwosc.org/O1/)
  (*Data Quality*).


pkgId: d9ccbb25d309923c3256854c8a207f41090e51b74782c030a9b1d664950eeb0a
name: python-gyjd-help
arch: noarch
version: 0.1.0.dev12
epoch: 0
release: 1
summary: Development documents and examples for gyjd
url: https://pypi.org/project/gyjd/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gyjd-0.1.0.dev12-1.src.rpm
location_href: Packages/python-gyjd-help-0.1.0.dev12-1.noarch.rpm
checksum_type: sha256
description:
  **Gyjd** (Get Your Job Done) is an extremely extensible mini framework designed to enhance your productivity in Python. With a simple and effective approach, Gyjd adds a powerful layer for managing configurations, loggers, dependency injection, retries, automatic CLI generation, and executable creation.



  - **Configuration Management**: Easily handle your project's configuration without hassle.
  - **Integrated Logger**: Monitor and log your application's activities effortlessly.
  - **Dependency Injection**: Simplify the management of your project's dependencies.
  - **Retries**: Automatically configure retries for calls that may fail.
  - **Automatic CLI**: Generate a command-line interface with ease.
  - **Executable Generation**: Create executables to distribute your project without complications.



  To install Gyjd, simply run the following command:

  ```bash
  pip install gyjd
  ```



  With Gyjd, you can focus on what truly matters: developing your project. The combination of all these features in a single package makes Python development faster and more efficient. Try it out and see the difference!


pkgId: de43bafd07f699099cbbb76e6310d6bed3e2f92cac844af5cf781e8b01c710e9
name: python-gypsum-client-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for gypsum-client
url: https://github.com/ArtifactDB/gypsum-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gypsum-client-0.2.0-1.src.rpm
location_href: Packages/python-gypsum-client-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- These are examples of badges you might want to add to your README:
       please update the URLs accordingly

  [![Built Status](https://api.cirrus-ci.com/github/<USER>/gypsum-client.svg?branch=main)](https://cirrus-ci.com/github/<USER>/gypsum-client)
  [![ReadTheDocs](https://readthedocs.org/projects/gypsum-client/badge/?version=latest)](https://gypsum-client.readthedocs.io/en/stable/)
  [![Coveralls](https://img.shields.io/coveralls/github/<USER>/gypsum-client/main.svg)](https://coveralls.io/r/<USER>/gypsum-client)

  [![Conda-Forge](https://img.shields.io/conda/vn/conda-forge/gypsum-client.svg)](https://anaconda.org/conda-forge/gypsum-client)

  [![Twitter](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter)](https://twitter.com/gypsum-client)
  -->

  [![Project generated with PyScaffold](https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold)](https://pyscaffold.org/)
  [![PyPI-Server](https://img.shields.io/pypi/v/gypsum-client.svg)](https://pypi.org/project/gypsum-client/)




  The `gypsum_client` package provides the Python client to any instance of the [gypsum REST API](https://gypsum.artifactdb.com). This allows client (both in **R** and **Python**) packages to easily store and retrieve resources from the **gypsum** backend.
  It also provides mechanisms to allow package maintainers to easily manage upload authorizations and third-party contributions.

  Readers are referred to [API's documentation](https://github.com/ArtifactDB/gypsum-worker) for a description of the concepts; this guide will strictly focus on the usage of the `gypsum_client` package.

  **Note: check out the R/Bioconductor package for the gypsum REST API [here](https://github.com/ArtifactDB/gypsum-R).**



  Package is published to [PyPI](https://pypi.org/project/gypsum-client/),

  ```sh
  pip install gypsum_client
  ```

  Check out the [documentation](https://artifactdb.github.io/gypsum-py/) for more information.

  <!-- pyscaffold-notes -->



  This project has been set up using PyScaffold 4.5. For details and usage
  information on PyScaffold see https://pyscaffold.org/.


pkgId: ba299d19a7affe75117eab5313ecc68cdb0f77b1a2bd1f0fa15dd3e6f5416119
name: python-h2hdb-downloader-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for h2hdb-downloader
url: https://github.com/Kuan-Lun/h2hdb-downloader
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-h2hdb-downloader-0.0.3-1.src.rpm
location_href: Packages/python-h2hdb-downloader-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Here's a quick example of how to use H@HDB Downloader:

  ```python
  from h2hdb_downloader import PreLinks, Downloader
  from hbrowser import ExHDriver

  gallery = GalleryURLParser("https://exhentai.org/g/123/456/")
  prelinks = PreLinks()
  with ExHDriver("username", "password", headless=True) as driver:
      downloader = Downloader(driver, prelinks)
      downloader.download_gallery(gallery)
      downloader.deep_download_gid(gallery,
          filters=["artist", "group"],
          conditions=["language:chinese$", "language:speechless$"],
          )
      downloader.download_gid(666) # download gid:666
  ```



  This project is distributed under the terms of the GNU General Public Licence (GPL). For detailed licence terms, see the `LICENSE` file included in this distribution.


pkgId: b5c1f3322d9e89bfdfac0d31fc2d5d00971d6f78a613135e354ca1cc474a1f54
name: python-h2w-aztools-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for h2w-aztools
description: Python Library for Interacting with Azure API's
url: https://github.com/harveywargo2/h2w-aztools
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-h2w-aztools-1.0.0-1.src.rpm
location_href: Packages/python-h2w-aztools-help-1.0.0-1.noarch.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 Harvey Wargo 2  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: f775812fc60df7ebbd440e707c2ac85ed4b9b6bc8b99b5c770ce154aa91c76ea
name: python-h5rdmtoolbox-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for h5rdmtoolbox
url: https://h5rdmtoolbox.readthedocs.io/en/latest/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-h5rdmtoolbox-1.6.0-1.src.rpm
location_href: Packages/python-h5rdmtoolbox-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/matthiasprobst/h5RDMtoolbox/actions/workflows/tests.yml/badge.svg)
  ![DOCS](https://codecov.io/gh/matthiasprobst/h5RDMtoolbox/branch/dev/graph/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/h5rdmtoolbox/badge/?version=latest)](https://h5rdmtoolbox.readthedocs.io/en/latest/?badge=latest)
  ![pyvers](https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)

  *Note, that the project is still under development!*

  The "HDF5 Research Data Management Toolbox" (h5RDMtoolbox) is a Python package supporting everybody who is working with
  HDF5 to achieve a sustainable data lifecycle which follows
  the [FAIR (Findable, Accessible, Interoperable, Reusable)](https://www.nature.com/articles/sdata201618)
  principles. It specifically supports the five main steps of *planning*, *collecting*, *analyzing*, *sharing* and
  *reusing* data. Please visit the [documentation](https://h5rdmtoolbox.readthedocs.io/en/latest/) for detailed
  information of try the [quickstart using colab](#quickstart).



  - Combining HDF5 and [xarray](https://docs.xarray.dev/en/stable/) to allow easy access to metadata and data during
    analysis and processing (
    see [here](https://h5rdmtoolbox.readthedocs.io/en/latest/gettingstarted/quickoverview.html#datasets-xarray-interface)).
  - Assigning [metadata with "globally unique and persistent identifiers"]() as required
    by [F1 of the FAIR principles](https://www.go-fair.org/fair-principles/f1-meta-data-assigned-globally-unique-persistent-identifiers/).
    This can be achieved by using [RDF triples](https://www.w3.org/RDF/), which removes "ambiguity in the meaning of your
    published data".
  - Define standard attributes through
    [conventions](https://h5rdmtoolbox.readthedocs.io/en/latest/userguide/convention/index.html) and enforce users to use
    certain attributes in their HDF5 files, such as units and a description, for example.
  - Upload HDF5 files directly
    to [repositories](https://h5rdmtoolbox.readthedocs.io/en/latest/userguide/repository/index.html)
    like [Zenodo](https://zenodo.org/)
    or [use them with noSQL databases](https://h5rdmtoolbox.readthedocs.io/en/latest/userguide/database/index.html) like
    [mongoDB](https://www.mongodb.com/).



  For everybody, who is...

  - ... looking for a management approach for his or her data.
  - ... community has not yet established a stable convention.
  - ... working with small and big data, that fits into HDF5 files.
  - ... looking for an easy way to work with HDF5, especially through [Jupyter Notebooks](https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html).
  - ... trying to integrate HDF5 with repositories and databases.
  - ... wishing to enrich data semantically with the RDF standard.
  - ... looking for a way to do all the above whiles not needing to learn a new syntax.
  - ... new to HDF5 and wants to learn about it, especially with respect to the FAIR principles and data management.



  For everybody, who ...

  - ... is looking for a management approach which at the same time allows high-performance and/or parallel work with HDF5
  - ... has already well-established conventions and managements approaches in his or her community



  The toolbox implements five modules, which are shown below. The numbers reference to their main usage in the stages in
  the data lifecycle above. Except the wrapper module, which uses the convention module, all other modules are independent
  of each other.

  <a href="https://h5rdmtoolbox.readthedocs.io/en/latest/"><img src="docs/_static/h5tbx_modules.svg" alt="H5TBX modules" style="widht:600px;"></a>

  Current implementation highlights in the modules:

  - The **wrapper** module adds functionality on top of the `h5py` package. It allows to include so-called standard names,
    which are defined in conventions. And it implements interfaces, such as to the package `xarray`, which allows to carry
    metadata from HDF5 to the user. Other high-level interfaces like `.rdf` allows assigning semantic information to the
    HDF5 file.
  - For the **database** module, `hdfDB` and `mongoDB` are implemented. The `hdfDB` module allows to use HDF5 files as a
    database. The `mongoDB` module allows to use mongoDB as a database by mapping the metadata of HDF5 files to the
    database.
  - For the **repository** module, a Zenodo interface is implemented. Zenodo is a repository, which allows to upload and
    download data with a persistent identifier.
  - For the **convention** module,
    the [standard attributes](https://h5rdmtoolbox.readthedocs.io/en/latest/conventions/standard_attributes_and_conventions.html)
    are implemented.
  - The **layout** module allows to define expectations on the internal layout (object names, location, attributes,
    properties) of HDF5 files.



  A quickstart notebook can be tested by clicking on the following badge:

  [![Open Quickstart Notebook](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/matthiasprobst/h5RDMtoolbox/blob/main/docs/colab/quickstart.ipynb)



  Please find a comprehensive documentation with many examples [here](https://h5rdmtoolbox.readthedocs.io/en/latest/) or
  by click on the image, which shows the research data lifecycle in the center and the respective toolbox features on the
  outside:

  A paper is published in the journal [inggrid](https://preprints.inggrid.org/repository/view/23/).



  Use python 3.8 or higher (automatic testing is performed until 3.12). If you are a regular user, you can install the
  package via pip:

      pip install h5RDMtoolbox



  Developers may clone the repository and install the package from source. Clone the repository first:

      git clone https://github.com/matthiasprobst/h5RDMtoolbox.git@main

  Then, run

      pip install h5RDMtoolbox/

  Add `--user` if you do not have root access.

  For development installation run

      pip install -e h5RDMtoolbox/



  The core functionality depends on the following packages. Some of them are for general management others are very
  specific to the features of the package:

  **General dependencies are ...**

  - `numpy>=1.20`: Scientific computing, handling of arrays
  - `matplotlib>=3.5.2`: Plotting
  - `appdirs>=1.4.4`: Managing user and application directories
  - `packaging`: Version handling
  - `IPython>=8.4.0`: Pretty display of data in notebooks
  - `regex>=2020.7.9`: Working with regular expressions

  **Specific to the package are ...**

  - `h5py=3.7.0`: HDF5 file interface
  - `xarray>=2022.3.0`: Working with scientific arrays in combination with attributes. Allows carrying metadata from HDF5
    to user
  - `pint>=0.19.2`: Allows working with units
  - `pint_xarray>=0.2.1`: Working with units for usage with xarray
  - `python-forge==18.6.0`: Used to update function signatures when using
    the [standard attributes](https://h5rdmtoolbox.readthedocs.io/en/latest/conventions/standard_attributes_and_conventions.html)
  - `pydantic`: Used to
    validate [standard attributes](https://h5rdmtoolbox.readthedocs.io/en/latest/conventions/standard_attributes_and_conventions.html)
  - `pyyaml>6.0.0`: Reading and writing of yaml files, e.g. metadata definitions (conventions). Note, lower versions
    collide with python 3.11
  - `requests`: Used to download files from the internet or validate URLs, e.g. metadata definitions (conventions)
  - `rdflib`: Used to enable working with RDF
  - `ontolutils`: Required to work with RDF and derive semantic description of HDF5 file content



  To run unit tests or to enable certain features, additional dependencies must be installed.

  Install optional dependencies by specifying them in square brackets after the package name, e.g.:

      pip install h5RDMtoolbox[mongodb]

  [mongodb]

  - `pymongo>=4.2.0`: Database solution for HDF5 files

  [csv]

  - `pandas>=1.4.3`: Mainly used for reading csv and pretty printing

  [snt]

  - `xmltodict`: Reading of xml files
  - `tabulate>=0.8.10`: Pretty printing of tables
  - `python-gitlab`: Access to gitlab repositories
  - `pypandoc>=2.3`: Conversion of markdown files to html



  If you intend to use the package in your work, you may cite the paper in the
  journal [inggrid](https://preprints.inggrid.org/repository/view/23/)

  Here's the bibtext to it:

  ```
  @article{probst2023h5rdmtoolbox,
    title={h5RDMtoolbox-A Python Toolbox for FAIR Data Management around HDF5},
    author={Probst, Matthias and Pritz, Balazs},
    year={2023},
    publisher={ing. grid Preprint Repository}
  }
  ```



  Feel free to contribute. Make sure to write `docstrings` to your methods and classes and please write tests and use PEP
  8 (https://peps.python.org/pep-0008/)

  Please write tests for your code and put them into the `test/` folder. Visit the [README file](./tests/README.md) in the
  test-folder for more information.

  Pleas also add a jupyter notebook in the `docs/` folder in order to document your code. Please visit
  the [README file](./docs/README.md) in the docs-folder for more information on how to compile the documentation.

  Please use the **numpy style for the docstrings**:
  https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_numpy.html#example-numpy


pkgId: 37e475bea6d587a527972d12e32406528d5278c42a9b2ba53adda17a74403dc0
name: python-ha-mqtt-discoverable-cli-help
arch: noarch
version: 0.16.2
epoch: 0
release: 1
summary: Development documents and examples for ha-mqtt-discoverable-cli
url: https://pypi.org/project/ha-mqtt-discoverable-cli/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ha-mqtt-discoverable-cli-0.16.2-1.src.rpm
location_href: Packages/python-ha-mqtt-discoverable-cli-help-0.16.2-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/unixorn/ha-mqtt-discoverable-cli.svg)](https://opensource.org/license/apache-2-0/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![GitHub last commit (branch)](https://img.shields.io/github/last-commit/unixorn/ha-mqtt-discoverable-cli/main.svg)](https://github.com/unixorn/ha-mqtt-discoverable-cli)
  [![Downloads](https://static.pepy.tech/badge/ha-mqtt-discoverable-cli)](https://pepy.tech/project/ha-mqtt-discoverable-cli)

  <!-- START doctoc generated TOC please keep comment here to allow auto update -->
  <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->


  - [Installing](#installing)
    - [Native install](#native-install)
    - [Docker](#docker)
    - [ZSH Frameworks](#zsh-frameworks)
  - [Scripts Provided](#scripts-provided)
    - [`hmd`](#hmd)
    - [`hmd create binary sensor`](#hmd-create-binary-sensor)
    - [`hmd create device`](#hmd-create-device)
  - [Contributing](#contributing)
  - [Contributors](#contributors)

  <!-- END doctoc generated TOC please keep comment here to allow auto update -->

  This repository contains CLI scripts for CRUD operations on MQTT entities that will be autodetected by Home Assistant.

  It is a set of wrapper scripts for the [ha-mqtt-discoverable](https://github.com/unixorn/ha-mqtt-discoverable) python module.





  `pip install ha-mqtt-discoverable-cli` will install the cli tools. If you prefer to keep your system python clear of extra modules, you can use the `unixorn/ha-mqtt-discoverable-cli` docker image instead.



  If you only need to use the command line tools, the simplest way is to use them with `docker` or `nerdctl`. It won't interfere with your system python and potentially cause you issues there.

  You can use the [unixorn/ha-mqtt-discoverable-cli](https://hub.docker.com/repository/docker/unixorn/ha-mqtt-discoverable-cli) image on dockerhub directly, but if you add `$reporoot/bin` to your `$PATH`, the `hmd` script there will automatically run the command line tools inside a docker container with `docker` or `nerdctl`, depending on what it finds in your `$PATH`.



  You can load the tools with your ZSH framework of choice by referring to `unixorn/ha-mqtt-discoverable-cli`.

  If you're using [Zgenom](https://github.com/jandamm/zgenom):

  1. Add `zgenom load unixorn/ha-mqtt-discoverable-cli` to your `.zshrc` along with your other `zgenom load` commands.
  2. `zgenom reset && zgenom save`




  The `ha_mqtt_discoverable-cli` module installs the following helper scripts you can use in your own shell scripts.



  Uses the [gitlike-commands](https://github.com/unixorn/gitlike-commands/) module to find and execute `hmd` subcommands. Allows you to run `hmd create binary sensor` and `hmd` will find and run `hmd-create-binary-sensor` and pass it all the command line options.



  Create/Update a binary sensor and set its state.

  Usage: `hmd create binary sensor --device-name mfsmaster --device-id 8675309 --mqtt-user HASS_MQTT_USER --mqtt-password HASS_MQTT_PASSWORD --client-name inquisition --mqtt-server mqtt.unixorn.net --metric-name tamper --device-class motion --state off`



  Create/Update a device and set the state of multiple metrics on it.

  Usage: `hmd create device --device-name coyote --device-id 8675309 --mqtt-user HASS_MQTT_USER --mqtt-password HASS_MQTT_PASSWORD --mqtt-server mqtt.example.com --model 'Rocket Skates' --manufacturer 'Acme Products' --metric-data '{"name":"Left Rocket Skate","value":93}' --metric-data '{"name":"Right Rocket Skate","value":155}' --unique-id 'hmd-26536'`



  Please run `black` on your code before submitting. There are `git` hooks already configured to run `black` and other checks before every commit, please run `pre-commit install` to enable them.



  <a href="https://github.com/unixorn/ha-mqtt-discoverable-cli/graphs/contributors">
    <img src="https://contributors-img.web.app/image?repo=unixorn/ha-mqtt-discoverable-cli" />
  </a>

  Made with [contributors-img](https://contributors-img.web.app).


pkgId: b2f804f5ea4f696122df64ee9edc1796712732bc5c55ba6f0068cb3ae6f7cc59
name: python-ha-mqtt-discoverable-help
arch: noarch
version: 0.16.2
epoch: 0
release: 1
summary: Development documents and examples for ha-mqtt-discoverable
url: https://pypi.org/project/ha-mqtt-discoverable/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ha-mqtt-discoverable-0.16.2-1.src.rpm
location_href: Packages/python-ha-mqtt-discoverable-help-0.16.2-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/unixorn/ha-mqtt-discoverable.svg)](https://opensource.org/license/apache-2-0/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![GitHub last commit (branch)](https://img.shields.io/github/last-commit/unixorn/ha-mqtt-discoverable/main.svg)](https://github.com/unixorn/ha-mqtt-discoverable)
  [![Downloads](https://static.pepy.tech/badge/ha-mqtt-discoverable)](https://pepy.tech/project/ha-mqtt-discoverable)

  A Python 3 module that takes advantage of Home Assistant's [MQTT discovery protocol](https://www.home-assistant.io/integrations/mqtt/#mqtt-discovery) to create sensors without having to define anything on the HA side.

  Using MQTT discoverable devices lets us add new sensors and devices to HA without having to restart HA. The [ha-mqtt-discoverable-cli](https://github.com/unixorn/ha-mqtt-discoverable-cli/) module includes scripts to make it easy to create discoverable devices from the command line if you don't want to bother writing Python.

  <!-- START doctoc generated TOC please keep comment here to allow auto update -->
  <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->


  - [Installing](#installing)
    - [Python](#python)
  - [Supported entities](#supported-entities)
    - [Binary sensor](#binary-sensor)
      - [Usage](#usage)
    - [Button](#button)
    - [Camera](#camera)
      - [Usage](#usage-1)
    - [Covers](#covers)
      - [Usage](#usage-2)
    - [Device](#device)
      - [Usage](#usage-3)
    - [Device trigger](#device-trigger)
        - [Usage](#usage-4)
    - [Image](#image)
      - [Usage](#usage-5)
    - [Light](#light)
      - [Usage](#usage-6)
    - [Number](#number)
      - [Usage](#usage-7)
    - [Sensor](#sensor)
      - [Usage](#usage-8)
    - [Select](#select)
      - [Usage](#usage-9)
    - [Switch](#switch)
      - [Usage](#usage-10)
    - [Text](#text)
      - [Usage](#usage-11)
  - [FAQ](#faq)
    - [Using an existing MQTT client](#using-an-existing-mqtt-client)
    - [I'm having problems on 32 bit ARM](#im-having-problems-on-32-bit-arm)
  - [Contributing](#contributing)
  - [Users of ha-mqtt-discoverable](#users-of-ha-mqtt-discoverable)
  - [Contributors](#contributors)

  <!-- END doctoc generated TOC please keep comment here to allow auto update -->





  ha-mqtt-discoverable runs on Python 3.10 or later.

  `pip install ha-mqtt-discoverable` if you want to use it in your own python scripts. `pip install ha-mqtt-discoverable-cli` to install the `hmd` utility scripts.

  <!-- Please keep the entities in alphabetical order -->


  The following Home Assistant entities are currently implemented:

  - Binary sensor
  - Button
  - Camera
  - Cover
  - Device
  - Device trigger
  - Image
  - Light
  - Number
  - Sensor
  - Select
  - Switch
  - Text

  Each entity can associated to a device. See below for details.





  The following example creates a binary sensor and sets its state:

  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import BinarySensor, BinarySensorInfo



  mqtt_settings = Settings.MQTT(host="localhost")


  sensor_info = BinarySensorInfo(name="MySensor", device_class="motion")

  settings = Settings(mqtt=mqtt_settings, entity=sensor_info)


  mysensor = BinarySensor(settings)


  mysensor.on()
  mysensor.off()


  mysensor.update_state(True)
  mysensor.update_state(False)


  mysensor.set_attributes({"my attribute": "awesome"})

  ```



  The button publishes no state, it simply receives a command from HA.

  You must call `write_config` on a Button after creating it to make it discoverable.

  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Button, ButtonInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  button_info = ButtonInfo(name="test")

  settings = Settings(mqtt=mqtt_settings, entity=button_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      perform_my_custom_action()


  user_data = "Some custom data"


  my_button = Button(settings, my_callback, user_data)


  my_button.write_config()

  ```



  The following example creates an camera entity with a topic to an image.



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Camera, CameraInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  camera_info = CameraInfo(name="test", topic="zanzito/shared_locations/my-device")

  settings = Settings(mqtt=mqtt_settings, entity=camera_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      payload = message.payload.decode()
      perform_my_custom_action()


  user_data = "Some custom data"


  my_camera = Camera(settings, my_callback, user_data)


  my_camera.set_topic("zanzito/shared_locations/my-device")	# not needed if already defined
  ```



  A cover has five possible states `open`, `closed`, `opening`, `closing` and `stopped`. Most other entities use the states as command payload, but covers differentiate on this. The HA user can either open, close or stop it in the covers current position.

  Covers do not currently support tilt.

  A `callback` function is needed in order to parse the commands sent from HA, as the following
  example shows:



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Cover, CoverInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  cover_info = CoverInfo(name="test")

  settings = Settings(mqtt=mqtt_settings, entity=cover_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      payload = message.payload.decode()
      if payload == "OPEN":
      
      my_cover.opening()
      
          open_my_custom_cover()
          
      my_cover.open()
      if payload == "CLOSE":
      
      my_cover.closing()
      
          close_my_custom_cover()
          
      my_cover.closed()
      if payload == "STOP":
      
          stop_my_custom_cover()
          
      my_cover.stopped()


  user_data = "Some custom data"


  my_cover = Cover(settings, my_callback, user_data)


  my_cover.closed()
  ```


  From the [Home Assistant documentation](https://developers.home-assistant.io/docs/device_registry_index):
  > A device is a special entity in Home Assistant that is represented by one or more entities.
  A device is automatically created when an entity defines its `device` property.
  A device will be matched up with an existing device via supplied identifiers or connections, like serial numbers or MAC addresses.



  The following example create a device, by associating multiple sensors to the same `DeviceInfo` instance.

  ```py
  from ha_mqtt_discoverable import Settings, DeviceInfo
  from ha_mqtt_discoverable.sensors import BinarySensor, BinarySensorInfo


  mqtt_settings = Settings.MQTT(host="localhost")


  device_info = DeviceInfo(name="My device", identifiers="device_id")



  motion_sensor_info = BinarySensorInfo(name="My motion sensor", device_class="motion", unique_id="my_motion_sensor", device=device_info)

  motion_settings = Settings(mqtt=mqtt_settings, entity=motion_sensor_info)


  motion_sensor = BinarySensor(motion_settings)


  motion_sensor.on()


  door_sensor_info = BinarySensorInfo(name="My door sensor", device_class="door", unique_id="my_door_sensor", device=device_info)
  door_settings = Settings(mqtt=mqtt_settings, entity=door_sensor_info)


  door_sensor = BinarySensor(settings)


  door_sensor.on()


  ```



  The following example creates a device trigger and generates a trigger event:


  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import DeviceInfo, DeviceTriggerInfo, DeviceTrigger


  mqtt_settings = Settings.MQTT(host="localhost")


  device_info = DeviceInfo(name="My device", identifiers="device_id")


  trigger_info = DeviceTriggerInfo(name="MyTrigger", type="button_press", subtype="button_1", unique_id="my_device_trigger", device=device_info)

  settings = Settings(mqtt=mqtt_settings, entity=trigger_info)


  mytrigger = DeviceTrigger(settings)



  mytrigger.trigger("My custom payload")
  ```



  The following example creates an entity to an image url.



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Image, ImageInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  image_info = ImageInfo(name="test", url_topic ="http://camera.local/latest.jpg")

  settings = Settings(mqtt=mqtt_settings, entity=image_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      payload = message.payload.decode()
      perform_my_custom_action()


  user_data = "Some custom data"


  my_image = Image(settings, my_callback, user_data)


  my_image.set_url("http://camera.local/latest.jpg")	# not needed if already defined
  ```



  The light is different from other current sensor as it needs its payload encoded/decoded as json.
  It is possible to set brightness, effects and the color of the light. Similar to a _switch_ it can
  also receive 'commands' from HA that request a state change.
  It is possible to act upon reception of this 'command', by defining a `callback` function, as the following example shows:



  ```py
  import json
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Light, LightInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  light_info = LightInfo(
      name="test_light",
      brightness=True,
      color_mode=True,
      supported_color_modes=["rgb"],
      effect=True,
      effect_list=["blink", "my_cusom_effect"])

  settings = Settings(mqtt=mqtt_settings, entity=light_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):

      
      try:
          payload = json.loads(message.payload.decode())
      except ValueError as error:
          print("Ony JSON schema is supported for light entities!")
          return

      
      if "color" in payload:
          set_color_of_my_light()
          my_light.color("rgb", payload["color"])
      elif "brightness" in payload:
          set_brightness_of_my_light()
          my_light.brightness(payload["brightness"])
      elif "effect" in payload:
          set_effect_of_my_light()
          my_light.effect(payload["effect"])
      elif "state" in payload:
          if payload["state"] == light_info.payload_on:
              turn_on_my_light()
              my_light.on()
          else:
              turn_off_my_light()
              my_light.off()
      else:
          print("Unknown payload")


  user_data = "Some custom data"


  my_light = Light(settings, my_callback, user_data)


  my_light.off()

  ```



  The number entity is similar to the text entity, but for a numeric value instead of a string.
  It is possible to act upon receiving changes in HA by defining a `callback` function, as the following example shows:



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Number, NumberInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  number_info = NumberInfo(name="test", min=0, max=50, mode="slider", step=5)

  settings = Settings(mqtt=mqtt_settings, entity=number_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      number = int(message.payload.decode())
      logging.info(f"Received {number} from HA")
      do_some_custom_thing(number)
      
      my_number.set_value(number)


  user_data = "Some custom data"


  my_number = Number(settings, my_callback, user_data)


  my_number.set_value(42.0)

  ```





  The following example creates a sensor and sets its state:

  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Sensor, SensorInfo



  mqtt_settings = Settings.MQTT(host="localhost")


  sensor_info = SensorInfo(
      name="MyTemperatureSensor",
      device_class="temperature",
      unit_of_measurement="°C",
  )

  settings = Settings(mqtt=mqtt_settings, entity=sensor_info)


  mysensor = Sensor(settings)


  mysensor.set_state(20.5)
  ```



  The selection entity is a list of selectable options in homeassistant.
  It is possible to act upon reception of this 'command', by defining a `callback` function, as the following example shows:



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Select, SelectInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  select_info = SelectInfo(name="test", options=["option1", "option2", "option3"])

  settings = Settings(mqtt=mqtt_settings, entity=select_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      payload = message.payload.decode()
      do_something()


  user_data = "Some custom data"


  my_selection = Select(settings, my_callback, user_data)


  opt = ["option3", "option4", "option5"]
  my_selection.set_options()
  ```



  The switch is similar to a _binary sensor_, but in addition to publishing state changes toward HA it can also receive 'commands' from HA that request a state change.
  It is possible to act upon reception of this 'command', by defining a `callback` function, as the following example shows:



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Switch, SwitchInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  switch_info = SwitchInfo(name="test")

  settings = Settings(mqtt=mqtt_settings, entity=switch_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      payload = message.payload.decode()
      if payload == "ON":
          turn_my_custom_thing_on()
          
  	my_switch.on()
      elif payload == "OFF":
          turn_my_custom_thing_off()
          
  	my_switch.off()


  user_data = "Some custom data"


  my_switch = Switch(settings, my_callback, user_data)


  my_switch.off()

  ```



  The text is an `helper entity`, showing an input field in the HA UI that the user can interact with.
  It is possible to act upon reception of the inputted text by defining a `callback` function, as the following example shows:



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Text, TextInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  text_info = TextInfo(name="test")

  settings = Settings(mqtt=mqtt_settings, entity=text_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      text = message.payload.decode()
      logging.info(f"Received {text} from HA")
      do_some_custom_thing(text)
      
      my_text.set_text(text)


  user_data = "Some custom data"


  my_text = Text(settings, my_callback, user_data)


  my_text.set_text("Some awesome text")

  ```





  If you want to use an existing MQTT client for the connection, you can pass it to the `Settings` object:

  ```py
  from ha_mqtt_discoverable import Settings
  from paho.mqtt.client import Client


  client = Client()





  mqtt_settings = Settings.MQTT(client=client)


  ```



  Pydantic 2 has issues on 32 bit ARM. More details are on [ha-mqtt-discoverable/pull/191](https://github.com/unixorn/ha-mqtt-discoverable/pull/191). TL;DR: If you're on an ARM32 machine you're going to have to pin to the 0.13.1 version.



  Please run `black` on your code before submitting. There are `git` hooks already configured to run `black` and other checks before every commit, please run `pre-commit install` to enable them.



  If you use this module for your own project, please add a link here.

  - [ha-mqtt-discoverable-cli](https://github.com/unixorn/ha-mqtt-discoverable-cli) - Command line tools that allow using this module from shell scripts

  - [plejd-mqtt-ha](https://github.com/ha-enthus1ast/plejd-mqtt-ha) - A containerized Python application that bridges Plejd devices to Home Assistant

  - [homeassistant-zodiac-tri-expert](https://github.com/andreondra/homeassistant-zodiac-tri-expert) - A Zodiac Tri Expert salt water generator integration



  <a href="https://github.com/unixorn/ha-mqtt-discoverable/graphs/contributors">
    <img src="https://contributors-img.web.app/image?repo=unixorn/ha-mqtt-discoverable" />
  </a>

  Made with [contributors-img](https://contributors-img.web.app).


pkgId: cdc5f04e6655e39850ddc1ea6a3034e9b9918d51e075c6b40704cab46c39de72
name: python-ha-mqtt-discoverable-help
arch: noarch
version: 0.16.3
epoch: 0
release: 1
summary: Development documents and examples for ha-mqtt-discoverable
url: https://pypi.org/project/ha-mqtt-discoverable/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ha-mqtt-discoverable-0.16.3-1.src.rpm
location_href: Packages/python-ha-mqtt-discoverable-help-0.16.3-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/unixorn/ha-mqtt-discoverable.svg)](https://opensource.org/license/apache-2-0/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![GitHub last commit (branch)](https://img.shields.io/github/last-commit/unixorn/ha-mqtt-discoverable/main.svg)](https://github.com/unixorn/ha-mqtt-discoverable)
  [![Downloads](https://static.pepy.tech/badge/ha-mqtt-discoverable)](https://pepy.tech/project/ha-mqtt-discoverable)

  A Python 3 module that takes advantage of Home Assistant's [MQTT discovery protocol](https://www.home-assistant.io/integrations/mqtt/#mqtt-discovery) to create sensors without having to define anything on the HA side.

  Using MQTT discoverable devices lets us add new sensors and devices to HA without having to restart HA. The [ha-mqtt-discoverable-cli](https://github.com/unixorn/ha-mqtt-discoverable-cli/) module includes scripts to make it easy to create discoverable devices from the command line if you don't want to bother writing Python.

  <!-- START doctoc generated TOC please keep comment here to allow auto update -->
  <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->


  - [Installing](#installing)
    - [Python](#python)
  - [Supported entities](#supported-entities)
    - [Binary sensor](#binary-sensor)
      - [Usage](#usage)
    - [Button](#button)
    - [Camera](#camera)
      - [Usage](#usage-1)
    - [Covers](#covers)
      - [Usage](#usage-2)
    - [Device](#device)
      - [Usage](#usage-3)
    - [Device trigger](#device-trigger)
        - [Usage](#usage-4)
    - [Image](#image)
      - [Usage](#usage-5)
    - [Light](#light)
      - [Usage](#usage-6)
    - [Number](#number)
      - [Usage](#usage-7)
    - [Sensor](#sensor)
      - [Usage](#usage-8)
    - [Select](#select)
      - [Usage](#usage-9)
    - [Switch](#switch)
      - [Usage](#usage-10)
    - [Text](#text)
      - [Usage](#usage-11)
  - [FAQ](#faq)
    - [Using an existing MQTT client](#using-an-existing-mqtt-client)
    - [I'm having problems on 32 bit ARM](#im-having-problems-on-32-bit-arm)
  - [Contributing](#contributing)
  - [Users of ha-mqtt-discoverable](#users-of-ha-mqtt-discoverable)
  - [Contributors](#contributors)

  <!-- END doctoc generated TOC please keep comment here to allow auto update -->





  ha-mqtt-discoverable runs on Python 3.10 or later.

  `pip install ha-mqtt-discoverable` if you want to use it in your own python scripts. `pip install ha-mqtt-discoverable-cli` to install the `hmd` utility scripts.

  <!-- Please keep the entities in alphabetical order -->


  The following Home Assistant entities are currently implemented:

  - Binary sensor
  - Button
  - Camera
  - Cover
  - Device
  - Device trigger
  - Image
  - Light
  - Number
  - Sensor
  - Select
  - Switch
  - Text

  Each entity can associated to a device. See below for details.





  The following example creates a binary sensor and sets its state:

  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import BinarySensor, BinarySensorInfo



  mqtt_settings = Settings.MQTT(host="localhost")


  sensor_info = BinarySensorInfo(name="MySensor", device_class="motion")

  settings = Settings(mqtt=mqtt_settings, entity=sensor_info)


  mysensor = BinarySensor(settings)


  mysensor.on()
  mysensor.off()


  mysensor.update_state(True)
  mysensor.update_state(False)


  mysensor.set_attributes({"my attribute": "awesome"})

  ```



  The button publishes no state, it simply receives a command from HA.

  You must call `write_config` on a Button after creating it to make it discoverable.

  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Button, ButtonInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  button_info = ButtonInfo(name="test")

  settings = Settings(mqtt=mqtt_settings, entity=button_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      perform_my_custom_action()


  user_data = "Some custom data"


  my_button = Button(settings, my_callback, user_data)


  my_button.write_config()

  ```



  The following example creates an camera entity with a topic to an image.



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Camera, CameraInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  camera_info = CameraInfo(name="test", topic="zanzito/shared_locations/my-device")

  settings = Settings(mqtt=mqtt_settings, entity=camera_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      payload = message.payload.decode()
      perform_my_custom_action()


  user_data = "Some custom data"


  my_camera = Camera(settings, my_callback, user_data)


  my_camera.set_topic("zanzito/shared_locations/my-device")	# not needed if already defined
  ```



  A cover has five possible states `open`, `closed`, `opening`, `closing` and `stopped`. Most other entities use the states as command payload, but covers differentiate on this. The HA user can either open, close or stop it in the covers current position.

  Covers do not currently support tilt.

  A `callback` function is needed in order to parse the commands sent from HA, as the following
  example shows:



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Cover, CoverInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  cover_info = CoverInfo(name="test")

  settings = Settings(mqtt=mqtt_settings, entity=cover_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      payload = message.payload.decode()
      if payload == "OPEN":
      
      my_cover.opening()
      
          open_my_custom_cover()
          
      my_cover.open()
      if payload == "CLOSE":
      
      my_cover.closing()
      
          close_my_custom_cover()
          
      my_cover.closed()
      if payload == "STOP":
      
          stop_my_custom_cover()
          
      my_cover.stopped()


  user_data = "Some custom data"


  my_cover = Cover(settings, my_callback, user_data)


  my_cover.closed()
  ```


  From the [Home Assistant documentation](https://developers.home-assistant.io/docs/device_registry_index):
  > A device is a special entity in Home Assistant that is represented by one or more entities.
  A device is automatically created when an entity defines its `device` property.
  A device will be matched up with an existing device via supplied identifiers or connections, like serial numbers or MAC addresses.



  The following example create a device, by associating multiple sensors to the same `DeviceInfo` instance.

  ```py
  from ha_mqtt_discoverable import Settings, DeviceInfo
  from ha_mqtt_discoverable.sensors import BinarySensor, BinarySensorInfo


  mqtt_settings = Settings.MQTT(host="localhost")


  device_info = DeviceInfo(name="My device", identifiers="device_id")



  motion_sensor_info = BinarySensorInfo(name="My motion sensor", device_class="motion", unique_id="my_motion_sensor", device=device_info)

  motion_settings = Settings(mqtt=mqtt_settings, entity=motion_sensor_info)


  motion_sensor = BinarySensor(motion_settings)


  motion_sensor.on()


  door_sensor_info = BinarySensorInfo(name="My door sensor", device_class="door", unique_id="my_door_sensor", device=device_info)
  door_settings = Settings(mqtt=mqtt_settings, entity=door_sensor_info)


  door_sensor = BinarySensor(settings)


  door_sensor.on()


  ```



  The following example creates a device trigger and generates a trigger event:


  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import DeviceInfo, DeviceTriggerInfo, DeviceTrigger


  mqtt_settings = Settings.MQTT(host="localhost")


  device_info = DeviceInfo(name="My device", identifiers="device_id")


  trigger_info = DeviceTriggerInfo(name="MyTrigger", type="button_press", subtype="button_1", unique_id="my_device_trigger", device=device_info)

  settings = Settings(mqtt=mqtt_settings, entity=trigger_info)


  mytrigger = DeviceTrigger(settings)



  mytrigger.trigger("My custom payload")
  ```



  The following example creates an entity to an image url.



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Image, ImageInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  image_info = ImageInfo(name="test", url_topic ="http://camera.local/latest.jpg")

  settings = Settings(mqtt=mqtt_settings, entity=image_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      payload = message.payload.decode()
      perform_my_custom_action()


  user_data = "Some custom data"


  my_image = Image(settings, my_callback, user_data)


  my_image.set_url("http://camera.local/latest.jpg")	# not needed if already defined
  ```



  The light is different from other current sensor as it needs its payload encoded/decoded as json.
  It is possible to set brightness, effects and the color of the light. Similar to a _switch_ it can
  also receive 'commands' from HA that request a state change.
  It is possible to act upon reception of this 'command', by defining a `callback` function, as the following example shows:



  ```py
  import json
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Light, LightInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  light_info = LightInfo(
      name="test_light",
      brightness=True,
      color_mode=True,
      supported_color_modes=["rgb"],
      effect=True,
      effect_list=["blink", "my_cusom_effect"])

  settings = Settings(mqtt=mqtt_settings, entity=light_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):

      
      try:
          payload = json.loads(message.payload.decode())
      except ValueError as error:
          print("Ony JSON schema is supported for light entities!")
          return

      
      if "color" in payload:
          set_color_of_my_light()
          my_light.color("rgb", payload["color"])
      elif "brightness" in payload:
          set_brightness_of_my_light()
          my_light.brightness(payload["brightness"])
      elif "effect" in payload:
          set_effect_of_my_light()
          my_light.effect(payload["effect"])
      elif "state" in payload:
          if payload["state"] == light_info.payload_on:
              turn_on_my_light()
              my_light.on()
          else:
              turn_off_my_light()
              my_light.off()
      else:
          print("Unknown payload")


  user_data = "Some custom data"


  my_light = Light(settings, my_callback, user_data)


  my_light.off()

  ```



  The number entity is similar to the text entity, but for a numeric value instead of a string.
  It is possible to act upon receiving changes in HA by defining a `callback` function, as the following example shows:



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Number, NumberInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  number_info = NumberInfo(name="test", min=0, max=50, mode="slider", step=5)

  settings = Settings(mqtt=mqtt_settings, entity=number_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      number = int(message.payload.decode())
      logging.info(f"Received {number} from HA")
      do_some_custom_thing(number)
      
      my_number.set_value(number)


  user_data = "Some custom data"


  my_number = Number(settings, my_callback, user_data)


  my_number.set_value(42.0)

  ```





  The following example creates a sensor and sets its state:

  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Sensor, SensorInfo



  mqtt_settings = Settings.MQTT(host="localhost")


  sensor_info = SensorInfo(
      name="MyTemperatureSensor",
      device_class="temperature",
      unit_of_measurement="°C",
  )

  settings = Settings(mqtt=mqtt_settings, entity=sensor_info)


  mysensor = Sensor(settings)


  mysensor.set_state(20.5)
  ```



  The selection entity is a list of selectable options in homeassistant.
  It is possible to act upon reception of this 'command', by defining a `callback` function, as the following example shows:



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Select, SelectInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  select_info = SelectInfo(name="test", options=["option1", "option2", "option3"])

  settings = Settings(mqtt=mqtt_settings, entity=select_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      payload = message.payload.decode()
      do_something()


  user_data = "Some custom data"


  my_selection = Select(settings, my_callback, user_data)


  opt = ["option3", "option4", "option5"]
  my_selection.set_options()
  ```



  The switch is similar to a _binary sensor_, but in addition to publishing state changes toward HA it can also receive 'commands' from HA that request a state change.
  It is possible to act upon reception of this 'command', by defining a `callback` function, as the following example shows:



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Switch, SwitchInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  switch_info = SwitchInfo(name="test")

  settings = Settings(mqtt=mqtt_settings, entity=switch_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      payload = message.payload.decode()
      if payload == "ON":
          turn_my_custom_thing_on()
          
  	my_switch.on()
      elif payload == "OFF":
          turn_my_custom_thing_off()
          
  	my_switch.off()


  user_data = "Some custom data"


  my_switch = Switch(settings, my_callback, user_data)


  my_switch.off()

  ```



  The text is an `helper entity`, showing an input field in the HA UI that the user can interact with.
  It is possible to act upon reception of the inputted text by defining a `callback` function, as the following example shows:



  ```py
  from ha_mqtt_discoverable import Settings
  from ha_mqtt_discoverable.sensors import Text, TextInfo
  from paho.mqtt.client import Client, MQTTMessage


  mqtt_settings = Settings.MQTT(host="localhost")


  text_info = TextInfo(name="test")

  settings = Settings(mqtt=mqtt_settings, entity=text_info)


  def my_callback(client: Client, user_data, message: MQTTMessage):
      text = message.payload.decode()
      logging.info(f"Received {text} from HA")
      do_some_custom_thing(text)
      
      my_text.set_text(text)


  user_data = "Some custom data"


  my_text = Text(settings, my_callback, user_data)


  my_text.set_text("Some awesome text")

  ```





  If you want to use an existing MQTT client for the connection, you can pass it to the `Settings` object:

  ```py
  from ha_mqtt_discoverable import Settings
  from paho.mqtt.client import Client


  client = Client()





  mqtt_settings = Settings.MQTT(client=client)


  ```



  Pydantic 2 has issues on 32 bit ARM. More details are on [ha-mqtt-discoverable/pull/191](https://github.com/unixorn/ha-mqtt-discoverable/pull/191). TL;DR: If you're on an ARM32 machine you're going to have to pin to the 0.13.1 version.



  Please run `black` on your code before submitting. There are `git` hooks already configured to run `black` and other checks before every commit, please run `pre-commit install` to enable them.



  If you use this module for your own project, please add a link here.

  - [ha-mqtt-discoverable-cli](https://github.com/unixorn/ha-mqtt-discoverable-cli) - Command line tools that allow using this module from shell scripts

  - [plejd-mqtt-ha](https://github.com/ha-enthus1ast/plejd-mqtt-ha) - A containerized Python application that bridges Plejd devices to Home Assistant

  - [homeassistant-zodiac-tri-expert](https://github.com/andreondra/homeassistant-zodiac-tri-expert) - A Zodiac Tri Expert salt water generator integration

  - [homeassistant-addon-viessmann-gridbox](https://github.com/unl0ck/homeassistant-addon-viessmann-gridbox) - Get your Viessmann Gridbox Data Home Assistant integration



  <a href="https://github.com/unixorn/ha-mqtt-discoverable/graphs/contributors">
    <img src="https://contributors-img.web.app/image?repo=unixorn/ha-mqtt-discoverable" />
  </a>

  Made with [contributors-img](https://contributors-img.web.app).


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


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


pkgId: 01f30534723e103135c3d8fb4719dc581003f55847e72d463001c5abef3f2d74
name: python-habachen-help
arch: aarch64
version: 0.5.2
epoch: 0
release: 1
summary: Development documents and examples for habachen
url: https://github.com/Hizuru3/python-habachen
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-habachen-0.5.2-1.src.rpm
location_href: Packages/python-habachen-help-0.5.2-1.aarch64.rpm
checksum_type: sha256
description:
  Habachen provides a fast implementation of Japanese text converters
  that support half-width/full-width characters but also hiragana/katakana.


pkgId: 8183b962c48f4cc120e5b53b1132b29be1ce072007dc8acde6b594bdbdeea9ff
name: python-habana-pyhlml
arch: noarch
version: 1.19.0.561
epoch: 0
release: 1
summary: Python3 wrapper for the HLML library.
url: https://pypi.org/project/habana-pyhlml/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-habana-pyhlml-1.19.0.561-1.src.rpm
location_href: Packages/python-habana-pyhlml-1.19.0.561-1.noarch.rpm
checksum_type: sha256
description:
  This wrapper shadows the synapse release versions and uses the scheme
  $release-$build
  where release is the synapse release and build is the build of this repo ( 0 indexed ).


pkgId: 6a519fde34e6aa47a43a80e5dc5ae871b25da8e3c45d247744a9277960a13e7a
name: python-hack4uTestPG-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for hack4uTestPG
url: https://hack4u.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hack4uTestPG-0.1.0-1.src.rpm
location_href: Packages/python-hack4uTestPG-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - Introduccion a Linux[15 horas]
  - Personalizacion de Linux[3 horas]
  - Introduccion al hacking [53 horas]



  Instala el paquete usando `pip3`:

  ```python3
  pip3 install hack4u
  ```





  ```python
  from hack4u import list_courses

  for course in list_courses():
      print(course)
  ```




  ```python
  from hack4u import get_course_by_name

  course = get_course_by_name("Introduccion a LInux")
  print(course)
  ```



  ```python3
  from hack4u.utils import total_duration
  print(f"Duracion total: {total_duration()} horas")
  ```



  ```python
  from hack4u import get_course_by_name

  course = get_course_by_name("Introduccion a LInux")
  print(course)
  ```


  ```python3
  from hack4u.utils import total_duration
  print(f"Duracion total:{total_duration()} horas")
  ```


pkgId: 71612e8c815e688ac3f2a171761607081bc321a551955ae59c33630c1ed0f6cb
name: python-hairpred-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for hairpred
url: https://github.com/RuchirSahni/HAIRpr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hairpred-1.0.0-1.src.rpm
location_href: Packages/python-hairpred-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains the standalone Python script `HAIRpred.py`.



  This Github repository has files which need Git-LFS for installation. To install Git-LFS :

  ```bash
  sudo apt-get install git-lfs
  git lfs install
  ```

  Then, clone this github repository :

  ```bash
  git clone https://github.com/Ruchir3003/HAIRpr.git
  ```

  Next, we need to untar the tar.gz files :

  ```bash
  tar -xvJf models.tar.xz
  tar -xvfz pssm.tar.gz
  ```



  To install DSSP, run the following command:

  ```bash
  apt-get install dssp
  ```
  You can set up the environment using either `requirements.txt` (for pip users) or `environment.yml` (for Conda users).



  ```bash
  pip install -r requirements.txt
  ```


  ```bash
  conda env create -f env.yml
  ```



  You would need to install ncbi psi-blast files in the pssm and dssp for your system.



  You can install dssp by following https://github.com/cmbi/dssp



  You can install system-specific ncbi psi-blast files from https://ftp.ncbi.nlm.nih.gov/blast/executables/blast+/LATEST/


  ```
  usage: python3 HAIRpred.py [-h]
                         [-i INPUT
                         [-o OUTPUT]
                         [-j {1,2}]
                         [-m {1,2}] (Only for Predict Module)
                         [-t THRESHOLD]
  ```
  ```
  Please provide following arguments for successful run

  optional arguments:
    -h, --help            show this help message and exit
    -i INPUT, --input INPUT
                          Input: protein or peptide sequence(s) in FASTA format
                          or single sequence per line in single letter code
    -o OUTPUT, --output OUTPUT
                          Output: File for saving results by default outfile.csv
    -j {1,2}, --job {1,2}
                          Job Type: 1:Predict, 2: Design, by default 1
    -t THRESHOLD, --threshold THRESHOLD
                          Threshold: Value between 0 to 1 by default 0.5
    -m {1,2}, --model {1,2}
                          Model Type: (Only for Predict Module) Model Type: 1: RSA based RF, 2: RSA + PSSM ensemble model (Best Model). Default : 2


  **Input File:** It allow users to provide input in the FASTA format.

  **Output File:** Program will save the results in the CSV format, in case user do not provide output file name, it will be stored in "outfile.csv".

  **Threshold:** User should provide threshold between 0 and 1, by default its 0.5.

  **Job:** User is allowed to choose between two different modules, such as, 1 for prediction and 2 for Designing , by default its 1.

  **Model **: User is allowed to choose between two different models, such as, 1 for RSA based RF and 2 for RSA + PSSM ensemble RF, by default its 2.


pkgId: a799f59cb282579800988562b89749eb403ea6ca77045a43a11cea150e32ceef
name: python-haizelabs-api-help
arch: noarch
version: 0.1.0a14
epoch: 0
release: 1
summary: Development documents and examples for haizelabs-api
url: https://github.com/haizelabs/haizelabs-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-haizelabs-api-0.1.0a14-1.src.rpm
location_href: Packages/python-haizelabs-api-help-0.1.0a14-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/haizelabs_api.svg)](https://pypi.org/project/haizelabs_api/)

  The Haize Labs Python library provides convenient access to the Haize Labs REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [haizelabs.com](https://haizelabs.com). The full API of this library can be found in [api.md](https://github.com/haizelabs/haizelabs-python/tree/main/api.md).



  ```sh

  pip install --pre haizelabs_api
  ```



  The full API of this library can be found in [api.md](https://github.com/haizelabs/haizelabs-python/tree/main/api.md).

  ```python
  import os
  from haizelabs_api import HaizeLabs

  client = HaizeLabs(
      api_key=os.environ.get("HAIZE_LABS_API_KEY"),  # This is the default and can be omitted
  )

  response = client.judges.call(
      judge_ids=["string"],
  )
  print(response.content_id)
  client.detectors.call(
      request={
          "content": {"messages": [{"role": "user","name": "Hello, how are you"}]},
          "detector_ids": ["detector-id-1", "detector-id-2"],
      },
  )
  print(response)
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `HAIZE_LABS_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  Simply import `AsyncHaizeLabs` instead of `HaizeLabs` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from haizelabs_api import AsyncHaizeLabs

  client = AsyncHaizeLabs(
      api_key=os.environ.get("HAIZE_LABS_API_KEY"),  # This is the default and can be omitted
  )


  async def main() -> None:
      response = await client.judges.call(
          judge_ids=["string"],
      )
      print(response.content_id)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `haizelabs_api.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `haizelabs_api.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `haizelabs_api.APIError`.

  ```python
  import haizelabs_api
  from haizelabs_api import HaizeLabs

  client = HaizeLabs()

  try:
      client.judges.call(
          judge_ids=["string"],
      )
  except haizelabs_api.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except haizelabs_api.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except haizelabs_api.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from haizelabs_api import HaizeLabs


  client = HaizeLabs(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).judges.call(
      judge_ids=["string"],
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from haizelabs_api import HaizeLabs


  client = HaizeLabs(
      
      timeout=20.0,
  )


  client = HaizeLabs(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).judges.call(
      judge_ids=["string"],
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/haizelabs/haizelabs-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `HAIZE_LABS_LOG` to `info`.

  ```shell
  $ export HAIZE_LABS_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from haizelabs_api import HaizeLabs

  client = HaizeLabs()
  response = client.judges.with_raw_response.call(
      judge_ids=["string"],
  )
  print(response.headers.get('X-My-Header'))

  judge = response.parse()  # get the object that `judges.call()` would have returned
  print(judge.content_id)
  ```

  These methods return an [`APIResponse`](https://github.com/haizelabs/haizelabs-python/tree/main/src/haizelabs_api/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/haizelabs/haizelabs-python/tree/main/src/haizelabs_api/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.judges.with_streaming_response.call(
      judge_ids=["string"],
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from haizelabs_api import HaizeLabs, DefaultHttpxClient

  client = HaizeLabs(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/haizelabs/haizelabs-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import haizelabs_api
  print(haizelabs_api.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/haizelabs/haizelabs-python/tree/main/./CONTRIBUTING.md).


pkgId: 95f9d4ba3230c0b56755e2cd5c168acabe1918a9d92cbfc8b6b27aee3655cfbc
name: python-haliax-help
arch: noarch
version: 1.3
epoch: 0
release: 1
summary: Development documents and examples for haliax
url: https://github.com/stanford-crfm/haliax
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-haliax-1.3-1.src.rpm
location_href: Packages/python-haliax-help-1.3-1.noarch.rpm
checksum_type: sha256
description:
  <!--haliax-intro-start-->


  <a href="https://github.com/stanford-crfm/haliax/actions?query=branch%3Amain++">
      <img alt="Build Status" src="https://img.shields.io/github/actions/workflow/status/stanford-crfm/haliax/run_tests.yaml?branch=main">
  </a>
  <a href="https://haliax.readthedocs.io/en/latest/?badge=latest">
      <img alt="Documentation Status" src="https://readthedocs.org/projects/haliax/badge/?version=latest">
  </a>
  <a href="">
  <img alt="License" src="https://img.shields.io/github/license/stanford-crfm/haliax?color=blue" />
  </a>
  <a href="https://https://pypi.org/project/haliax/">
      <img alt="PyPI" src="https://img.shields.io/pypi/v/haliax?color=blue" />
  </a>

  > *Though you don’t seem to be much for listening, it’s best to be careful. If you managed to catch hold of even just a piece of my name, you’d have all manner of power over me.*<br/>
  > — Patrick Rothfuss, *The Name of the Wind*

  Haliax is a [JAX](https:://github.com/google/jax) library for building neural networks with named tensors, in the tradition of Alexander Rush's [Tensor Considered Harmful](https://nlp.seas.harvard.edu/NamedTensor).
  Named tensors improve the **legibility** and **compositionality** of tensor programs by using named axes instead of positional indices
  as typically used in NumPy, PyTorch, etc.

  Despite the focus on legibility, Haliax
  is also **fast**, typically about as fast as "pure" JAX code.
  Haliax is also built to be **scalable**: it
  can support [Fully-Sharded Data Parallelism (FSDP)](https://engineering.fb.com/2021/07/15/open-source/fsdp/) and Tensor Parallelism with [just a few lines of code](https://colab.research.google.com/drive/1QX4yH3zRFF3Xiibf1aahETcSQ5nbcUMz). Haliax powers [Levanter](https://github.com/stanford-crfm/levanter),
  our companion library for training large language models and other foundation models, with scale proven up to 20B parameters
  and up to a TPU v3-256 pod slice.



  Here's a minimal attention module implementation in Haliax. For a more detailed introduction,
  please see the [Haliax tutorial](https://colab.research.google.com/drive/1TiTcQQ4V5mopbgCu1SVl-oqJtXn7rFnC).
  (We use the excellent [Equinox](https://github.com/patrick-kidger/equinox) library for its module system and tree transformations.)

  ```python
  import haliax.nn.normalization
  import haliax.nn.activations
  import equinox as eqx
  import jax
  import jax.numpy as jnp
  import haliax as hax
  import haliax.nn as hnn

  Pos = hax.Axis("position", 1024)  # sequence length
  KPos = Pos.alias("key_position")
  Head = hax.Axis("head", 8)  # number of attention heads
  Key = hax.Axis("key", 64)  # key size
  Embed = hax.Axis("embed", 512)  # embedding size


  def attention_scores(Key, KPos, query, key, mask):
      
      scores = hax.dot(query, key, axis=Key) / jnp.sqrt(Key.size)

      if mask is not None:
          scores -= 1E9 * (1.0 - mask)

      
      scores = haliax.nn.normalization.softmax(scores, KPos)
      return scores


  def attention(Key, KPos, query, key, value, mask):
      scores = attention_scores(Key, KPos, query, key, mask)
      answers = hax.dot(scores, value, axis=KPos)

      return answers



  causal_mask = hax.arange(Pos).broadcast_axis(KPos) >= hax.arange(KPos)


  class Attention(eqx.Module):
      proj_q: hnn.Linear  # [Embed] -> [Head, Key]
      proj_k: hnn.Linear  # [Embed] -> [Head, Key]
      proj_v: hnn.Linear  # [Embed] -> [Head, Key]
      proj_answer: hnn.Linear  # output projection from [Head, Key] -> [Embed]

      @staticmethod
      def init(Embed, Head, Key, *, key):
          k_q, k_k, k_v, k_ans = jax.random.split(key, 4)
          proj_q = hnn.Linear.init(In=Embed, Out=(Head, Key), key=k_q)
          proj_k = hnn.Linear.init(In=Embed, Out=(Head, Key), key=k_k)
          proj_v = hnn.Linear.init(In=Embed, Out=(Head, Key), key=k_v)
          proj_answer = hnn.Linear.init(In=(Head, Key), Out=Embed, key=k_ans)
          return Attention(proj_q, proj_k, proj_v, proj_answer)

      def __call__(self, x, mask=None):
          q = self.proj_q(x)
          
          k = self.proj_k(x).rename({"position": "key_position"})
          v = self.proj_v(x).rename({"position": "key_position"})

          answers = attention(Key, KPos, q, k, v, causal_mask)

          x = self.proj_answer(answers)
          return x
  ```

  Haliax was created by [Stanford's Center for Research on Foundation Models (CRFM)](https://crfm.stanford.edu/)'s research engineering team.
  You can find us in the #levanter channel on the unofficial [Jax LLM Discord](https://discord.gg/FkRGNX3ND).

  <!--haliax-intro-end-->





  These are some tutorials to get you started with Haliax. They are available as Colab notebooks:

  <!--haliax-tutorials-start-->

  * [Introduction to Haliax with Transformers](https://colab.research.google.com/drive/1TiTcQQ4V5mopbgCu1SVl-oqJtXn7rFnC)
  * [Distributed Training in Haliax](https://colab.research.google.com/drive/1QX4yH3zRFF3Xiibf1aahETcSQ5nbcUMz) (including FSDP)
  * [Tensor Parallelism in Haliax](https://colab.research.google.com/drive/18_BrtDpe1lu89M4T6fKzda8DdSLtFJhi)
  * [Mixed Precision with `jmp`](https://colab.research.google.com/drive/1_4cikwt-UhSH7yRzNRK8ze9msM9r2mEl?usp=sharing) (This one is really a tutorial for [jmp](https://github.com/deepmind/jmp) but it's how to use it with Haliax...)

  <!--haliax-tutorials-end-->


  Haliax's API documentation is available at [haliax.readthedocs.io](https://haliax.readthedocs.io/en/latest/).



  We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for more information.
  We also have a list of [good first issues](https://github.com/stanford-crfm/haliax/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
  to help you get started. (If those don't appeal, don't hesitate to reach out to us on Discord!)



  Haliax is licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for the full license text.


pkgId: 9b54bd82de63302c4d51707b06ce05ec433d9d2ce9537bfd6e01dfa21ebaa6ac
name: python-halmos-help
arch: noarch
version: 0.2.3
epoch: 0
release: 1
summary: Development documents and examples for halmos
url: https://github.com/a16z/halmos
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-halmos-0.2.3-1.src.rpm
location_href: Packages/python-halmos-help-0.2.3-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/halmos)](https://pypi.org/project/halmos)
  [![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fa16z%2Fhalmos%2Frefs%2Fheads%2Fmain%2Fpyproject.toml)](https://github.com/a16z/halmos)
  [![License](https://img.shields.io/github/license/a16z/halmos)](https://github.com/a16z/halmos/blob/main/LICENSE)
  [![chat](https://img.shields.io/badge/chat-telegram-blue)](https://t.me/+4UhzHduai3MzZmUx)

  [**Install**](https://github.com/a16z/halmos?tab=readme-ov-file#installation)
  | [**Getting Started**](https://github.com/a16z/halmos/blob/main/docs/getting-started.md)
  | [**Examples**](https://github.com/a16z/halmos/blob/main/examples/README.md)
  | [**FAQ**](https://github.com/a16z/halmos/wiki/FAQ)
  | [**Chat**][chat]
  | [**awesome-halmos**](https://github.com/redtrama/awesome-halmos)

  Halmos is a _symbolic testing_ tool for EVM smart contracts. A Solidity/Foundry frontend is currently offered by default, with plans to provide support for other languages, such as Vyper and Huff, in the future.

  You can read more in our post: "_[Symbolic testing with Halmos: Leveraging existing tests for formal verification][post]_."

  Join the [Halmos Telegram Group][chat] for any inquiries or further discussions.

  [post]: <https://a16zcrypto.com/symbolic-testing-with-halmos-leveraging-existing-tests-for-formal-verification/>
  [chat]: <https://t.me/+4UhzHduai3MzZmUx>





  ```sh

  curl -LsSf https://astral.sh/uv/install.sh | sh


  uv tool install halmos





  uv tool upgrade halmos
  ```



  You can download a pre-built Docker image that contains python, halmos, its dependencies, foundry, solvers, etc.:

  ```sh
  docker pull ghcr.io/a16z/halmos:latest
  ```



  Note: this is not recommended because of the extra work required to manage the python version and the virtual environment. But if you know what you are doing, and need the extra control, you can do it like this:

  ```sh

  python3.12 --version


  python3.12 -m venv .venv && source .venv/bin/activate


  pip install halmos


  pip install git+https://github.com/a16z/halmos
  ```



  ```sh
  cd /path/to/src
  halmos
  ```

  For more details:

  ```sh
  halmos --help
  ```

  Alternatively, you can run the latest halmos Docker image available at [ghcr.io/a16z/halmos](ghcr.io/a16z/halmos):

  ```sh
  cd /path/to/src


  docker run -v .:/workspace ghcr.io/a16z/halmos:latest
  ```



  Refer to the [getting started guide](docs/getting-started.md) and the [examples](examples/README.md) directory.



  Refer to the [contributing guidelines](CONTRIBUTING.md), and explore the list of issues labeled ["good first issue" or "help wanted."][issues]

  [issues]: <https://github.com/a16z/halmos/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22%2C%22help+wanted%22>



  _These smart contracts and code are being provided as is. No guarantee, representation or warranty is being made, express or implied, as to the safety or correctness of the user interface or the smart contracts and code. They have not been audited and as such there can be no assurance they will work as intended, and users may experience delays, failures, errors, omissions or loss of transmitted information. THE SMART CONTRACTS AND CODE CONTAINED HEREIN ARE FURNISHED AS IS, WHERE IS, WITH ALL FAULTS AND WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING ANY WARRANTY OF MERCHANTABILITY, NON-INFRINGEMENT OR FITNESS FOR ANY PARTICULAR PURPOSE. Further, use of any of these smart contracts and code may be restricted or prohibited under applicable law, including securities laws, and it is therefore strongly advised for you to contact a reputable attorney in any jurisdiction where these smart contracts and code may be accessible for any questions or concerns with respect thereto. Further, no information provided in this repo should be construed as investment advice or legal advice for any particular facts or circumstances, and is not meant to replace competent counsel. a16z is not liable for any use of the foregoing, and users should proceed with caution and use at their own risk. See a16z.com/disclosures for more info._


pkgId: de19d0bb97492b5d8097b0585360146aaa8e9e445a8af1e0360f316e5eb76ec1
name: python-handshakes-help
arch: noarch
version: 0.7.9
epoch: 0
release: 1
summary: Development documents and examples for handshakes
url: https://pypi.org/project/handshakes/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-handshakes-0.7.9-1.src.rpm
location_href: Packages/python-handshakes-help-0.7.9-1.noarch.rpm
checksum_type: sha256
description:
  _A Modern Test Reporter_

  Processes the data collected from the test execution and then generates a modern Dashboard.





  [WebdriverIO](https://webdriver.io/) is a Next-gen browser and mobile automation test framework for Node.js

  1. Install Packages: `npm install wdio-handshake-reporter`
  2. Install Dashboard: `npm install handshake`
  3. Once done you can configure the reporter in your configuration.


  below are the things I would like to implement sooner or later.

  * [X] Add support for `webdriverio`
  * [ ] Add Reporter for `jest`
  * [ ] Work on documentation
  * [ ] Support for `mocha`
  * [ ] Listen to `cypress` results
  * [ ] Add Support for `playwright`


pkgId: af9b819745aec1dfeefdc113c9f708af3290d7eb87ef7a19dcc4a35707c77678
name: python-handshape-datasets-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for handshape-datasets
url: https://github.com/midusi/handshape_datasets
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-handshape-datasets-0.2.1-1.src.rpm
location_href: Packages/python-handshape-datasets-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  ![handshape](http://facundoq.github.io/datasets/lsa16/files/dataset/1_1_1.png "sample handshape")
  ![handshape](http://facundoq.github.io/datasets/lsa16/files/dataset/2_1_1.png "sample handshape")
  ![handshape](http://facundoq.github.io/datasets/lsa16/files/dataset/3_1_1.png "sample handshape")


  There are [various handshape datasets](http://facundoq.github.io/unlp/sign_language_datasets/) for Sign Language. However:
  * Each dataset has its own format and many are hard to find.
  * Each dataset has its own mapping of handshapes to classes. While signs depend on the specific Sign Language for a country/region, handshapes are universal. Hence, they could be shared between datasets/tasks.

  This library aims to provide two main features:
  * A simplified API to download and load handshape datasets
  * A mapping between datasets so that datasets can be merged for training/testing models.

  This library is a *work in progress*. Contributions are welcome. If you wish to add a dataset you can make a push request or open an issue.



  You can install `handshape_datasets` via pip with:

  `pip install handshape_datasets`



  Simply import the module and load a dataset. The following downloads, preprocesses and load to memory the [LSA16 dataset](http://facundoq.github.io/datasets/lsa16/):

      import handshape_datasets as hd
      images,metadata = hd.load("lsa16")
  Afterwards you can, for example, plot the first images of the dataset

      import matplotlib.pyplot as plt
      plt.imshow(images[0,:,:,:]) # show the first sample of the dataset


      import handshape_datasets as hd
      hd.list_datasets() # List available datasets
      hd.load("lsa16",version="color",delete=True) # use the color version, delete temporary files
      hd.delete_temporary_files("lsa16")# Delete temporary files  (if any)
      hd.clear("lsa16") # Delete all the local files for dataset LSA16
      hd.info("lsa16") # Shows detailed info of the dataset, including url, data format, fields, etc.





  |    Dataset id | Download size | Size on disk | Samples | Classes |
  |---------------|---------------|--------------|---------|---------|
  |     lsa16     |    640.6 Kb   |    1.2 Mb    |   800   |    16   |
  |      rwth     |    44.8 Mb    |   206.8 Mb   |   3359  |    45   |
  |     Irish     |    173.4 Mb   |   515.0 Mb   |  58114  |    26   |
  |     Ciarp     |    10.6 Mb    |   18.6 Mb    |   7127  |    10   |
  | PugeaultASL_A |     2.1 Gb    |    4.3 Gb    |  65774  |    24   |
  | PugeaultASL_B |    317.4 Mb   |   717.9 Mb   |  72676  |    26   |
  |    indianA    |     1.7 Gb    |    1.9 Gb    |   5040  |   140   |
  |    indianB    |    320.5 Mb   |    8.6 Gb    |   5000  |   140   |
  |      Nus1     |     2.8 Mb    |    3.6 Mb    |   479   |    10   |
  |      Nus2     |    73.7 Mb    |   106.1 Mb   |   2750  |    10   |
  |      jsl      |     4.5 Mb    |    7.9 Mb    |   8055  |    41   |
  |      psl      |    285.2 Mb   |    1.2 Gb    |   960   |    16   |


  You can find more information about the datasets in the following [sign language dataset survey](http://facundoq.github.io/unlp/sign_language_datasets/)



  Load the dataset:

      x,metadata = handshape_datasets.load("lsa16")
      y = metadata["y"]
  Get the input_shape and number of classes:

      input_shape = x[0].shape
      classes = y.max() + 1

  Define a model (using a pretrained MobileNet here):

      base_model = keras.applications.mobilenet.MobileNet(input_shape=(input_shape[0],input_shape[1],3),
                                                                  weights='imagenet', include_top=False)
      output = keras.layers.GlobalAveragePooling2D()(base_model.output)
      output = keras.layers.Dense(32, activation='relu')(output)
      output = keras.layers.Dense(classes, activation='softmax')(output)
      model = Model(inputs=base_model.input, outputs=output)
      model.compile(optimizer='Adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

  Split the dataset intro train/test sets:

      X_train, X_test, Y_train, Y_test = sklearn.model_selection.train_test_split(x,y,
                                                                                      test_size=0.9,
                                                                                      stratify=y)

  Fit the model

      history = model.fit(X_train, Y_train, batch_size=self.batch_size, epochs=self.epochs, validation_data=(X_test, Y_test))



  https://colab.research.google.com/drive/1kY-YrbegGFVT7NqVaeA4RjXYRVlZiISR?usp=sharing


pkgId: 782b3e57c7df50f49c2634f9dd3d359801dc8e6e5b9365bf347f5d9d9276d456
name: python-haptools-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for haptools
url: https://github.com/cast-genomics/haptools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-haptools-0.5.0-1.src.rpm
location_href: Packages/python-haptools-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi version](https://img.shields.io/pypi/v/haptools)](https://pypi.org/project/haptools)
  [![image](https://anaconda.org/bioconda/haptools/badges/version.svg)](https://anaconda.org/bioconda/haptools)
  [![license](https://img.shields.io/pypi/l/haptools)](LICENSE)
  ![status](https://github.com/CAST-genomics/haptools/workflows/Tests/badge.svg)
  [<img src=https://github.com/codespaces/badge.svg width=160>](https://codespaces.new/CAST-genomics/haptools)

  Haptools is a collection of tools for simulating and analyzing genotypes and phenotypes while taking into account haplotype information. Haptools supports fast simulation of admixed genomes (with `simgenotype`), visualization of admixture tracks (with `karyogram`), simulating haplotype- and local ancestry-specific phenotype effects (with `transform` and `simphenotype`), and computing a variety of common file operations and statistics in a haplotype-aware manner.

  Homepage: [https://haptools.readthedocs.io/](https://haptools.readthedocs.io/)

  Visit our homepage for installation and usage instructions.

  ![haptools commands](https://github.com/CAST-genomics/haptools/assets/23412689/7de95547-3138-45c6-99d8-46bca5716c26)


  There is an option to _"Cite this repository"_ on the right sidebar of [the repository homepage](https://github.com/CAST-genomics/haptools)

  > Arya R Massarat, Michael Lamkin, Ciara Reeve, Amy L Williams, Matteo D’Antonio, Melissa Gymrek, Haptools: a toolkit for admixture and haplotype analysis, Bioinformatics, 2023;, btad104, https://doi.org/10.1093/bioinformatics/btad104


pkgId: 3069d1fabd76f7b2a0f64874412aae3c5107fe11bbf57457108d1f5f610b8e5b
name: python-harmony-service-lib-help
arch: noarch
version: 2.4.0
epoch: 0
release: 1
summary: Development documents and examples for harmony-service-lib
url: https://github.com/nasa/harmony-service-lib-py
rpm_license: License :: OSI Approved :: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-harmony-service-lib-2.4.0-1.src.rpm
location_href: Packages/python-harmony-service-lib-help-2.4.0-1.noarch.rpm
checksum_type: sha256
description:
  A library for Python-based Harmony services to parse incoming messages, fetch data, stage data, and call back to Harmony





  Install the latest version of the package from PyPI using pip:

      $ pip install harmony-service-lib



  The package is installable from source via

      $ pip install git+https://github.com/harmony/harmony-service-lib-py.git#egg=harmony-service-lib

  If using a local source tree, run the following in the source root directory instead:

      $ pip install -e .



  Services that want to work with Harmony can make use of this library to ease
  interop and upgrades.  To work with Harmony, services must:

  1. Receive incoming messages from Harmony.  Currently the CLI is the only
  supported way to receive messages, though HTTP is likely to follow.  `harmony.cli`
  provides helpers for setting up CLI parsing while being unobtrusive to non-Harmony
  CLIs that may also need to exist.
  2. Extend `harmony.BaseHarmonyAdapter` and either override `#invoke` to process
  the message or override `#process_item` to process each individual STAC item
  provided in the input STAC catalog. The adapter class provides helper methods
  for retrieving data, staging results, and cleaning up temporary files, though
  these can be overridden or ignored if a service needs different behavior, e.g.
  if it operates on data in situ and does not want to download the remote file.

  A full example of these two requirements with use of helpers can be found in
  [example/example_service.py](example/example_service.py). Also see
  [adapting-new-services](https://github.com/nasa/harmony/blob/main/docs/guides/adapting-new-services.md) for in depth
  guidance on service development using this library, especially the
  [info on proper error handling](https://github.com/nasa/harmony/blob/main/docs/guides/adapting-new-services.md#5-error-handling).



  The following environment variables can be used to control the behavior of the
  library and allow easier testing:

  REQUIRED:

  * `STAGING_BUCKET`: When using helpers to stage service output and pre-sign URLs, this
         indicates the S3 bucket where data will be staged
  * `STAGING_PATH`: When using helpers to stage output, this indicates the path within
         `STAGING_BUCKET` under which data will be staged
  * `ENV`: The name of the environment.  If 'dev' or 'test', callbacks to Harmony are
         not made and data is not staged unless also using localstack
  * `SHARED_SECRET_KEY`: The 32-byte encryption key shared between Harmony and backend services.
         This is used to encrypt & decrypt the `accessToken` in the Harmony operation message.
         In a production environment, this should be injected into the container running the service
         Docker image. When running the service within Harmony, the Harmony infrastructure will
         ensure that this environment variable is set with the shared secret key, and the Harmony
         service library will read and use this key. Therefore, the service developer need not
         be aware of this variable or its value.

  OPTIONAL:

  * `APP_NAME`: Defaults to first argument on commandline. Appears in log records.
  * `AWS_DEFAULT_REGION`: (Default: `"us-west-2"`) The region in which S3 calls will be made
  * `USE_LOCALSTACK`: (Development) If 'true' will perform S3 calls against localstack rather
         than AWS
  * `LOCALSTACK_HOST`: (Development) If `USE_LOCALSTACK` `true` and this is set, will
         establish `boto` client connections for S3 operations using this hostname.
  * `TEXT_LOGGER`: (Default: True) Setting this to true will cause all
         log messages to use a text string format. By default log
         messages will be formatted as JSON.
  * `MAX_DOWNLOAD_RETRIES`: Number of times to retry HTTP download calls that fail due to transient errors.
  * `POST_URL_LENGTH`: Minimum url length that will be submitted via POST request.



  Prerequisites:
    - Python 3.9+, ideally installed via a virtual environment
    - A local copy of the code

  Install dependencies:

      $ make install

  Run linter against production code:

      $ make lint

  Run tests:

      $ make test

  Build & publish the package:

      $ make publish



  GitHub release notes will automatically be generated based on pull request subjects.
  Pull request subject lines should therefore concisely emphasize library
  user-facing behavior and updates they should appear in the changelog.  If more
  information is needed for release notes, note that in the PR content.


pkgId: 5fd28656dc9e3140bd6904768780ce14673b3b48baeca96be6e1312c06c038ca
name: python-harmonyhub-cli-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for harmonyhub-cli
url: https://github.com/rahgadda/HarmonyHub
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-harmonyhub-cli-0.0.3-1.src.rpm
location_href: Packages/python-harmonyhub-cli-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  - This is a Visual API Orchestrator POC created for Rest API Calls.
  - UI Generates YAML. Written in static HTML using WebComponents.
  - Python-based `CLI` is used to run YAML generated from UI. It can sequence and execute API Calls.


  - harmonyhub init
    - harmonyhub init --file workflow.yaml
  - harmonyhub run <<workflow.yaml>>
    - pyyaml2apiworkflow run <<workflow.yaml>> --debug
  - harmonyhub --help
  - harmonyhub --version


  - Simple comparisons (==, !=, >, <, >=, <=)
  - Logical operations (and, or, not)
  - Basic arithmetic operations (+, -, *, /, %)


  - [JQ](https://www.devtoolsdaily.com/jq_playground/)


  - $response
  - $request
  - $http_status


  - GraphQL
  - Grpc
  - Kafka


  - Demo created [here](https://app.beeceptor.com/console/automation-demo)


  - Below are projects used as inspiration
    - [Stepci](https://stepci.com/)
    - [Apache Karavan](https://github.com/apache/camel-karavan)


pkgId: a246e3ea3fcc2153d320d17e1316b55f97877a9371567b7bfbeee6bbeaa3d1f0
name: python-hashio-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for hashio
url: http://github.com/rsgalloway/hashio
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hashio-0.2.0-1.src.rpm
location_href: Packages/python-hashio-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Custom file and directory checksum tool.

  - multiple hash algos: c4, md5, sha256, sha512, xxh64
  - recursively runs checksums on files in directory trees
  - ignores predefined file name patterns
  - caches results for better performance

  The easiest way to install:
  ```bash
  $ pip install -U hashio
  ```

  Checksum one or more files or directories using one or more hash algorithms
  (default is xxh64):
  ```bash
  $ hashio <PATH> [--algo <ALGO>]
  ```
  Recursively checksum and gather metadata all the files in a dir tree, and output
  results to a JSON file:
  ```bash
  $ hashio <DIR>
  ```
  Note that files matching patterns defined in `config.IGNORABLE` will be skipped.
  Verify paths in previously generated JSON file by comparing stored mtimes (if
  available) or regenerated hash values if mtimes are missing or different:
  ```bash
  $ hashio --verify hash.json
  ```

  You modifiy settings in the environment stack file `hashio.env`, or create a new
  environment stack:
  ```bash
  $ cp hashio.env debug.env
  $ vi debug.env  # make edits
  $ ./debug.env -- hashio
  ```

  Generate a `hash.json` file for a given path (Default is the current working
  directory):
  ```python
  from hashio.worker import HashWorker
  worker = HashWorker(path)
  worker.run()
  ```
  Verify pre-generated checksums stored in a `hash.json` file:
  ```python
  from hashio.encoder import verify_checksums
  for algo, value, miss in verify_checksums("hash.json"):
      print("{0} {1}".format(algo, miss))
  ```


pkgId: bddae62204caff0e870b3d5325d8a9c54262aa8677d02bebe4d0c07e82c23b44
name: python-hata-help
arch: noarch
version: 1.3.71
epoch: 0
release: 1
summary: Development documents and examples for hata
url: https://github.com/HuyaneMatsu/hata
rpm_license: DBAD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hata-1.3.71-1.src.rpm
location_href: Packages/python-hata-help-1.3.71-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
      <b>
          <a href="https://github.com/HuyaneMatsu/hata">
              Hata
          </a>
      </b>
  </h1>

  <p align="center">
      <b>
          A blazing fast Discord API wrapper that you can't deny
      </b>
  </p>

  <p align="center">
      <a href="https://discord.gg/3cH2r5d">Support Guild</a> |
      <a href="https://github.com/HuyaneMatsu/hata/tree/master/docs/topics">Topical documentation</a> |
      <a href="https://github.com/HuyaneMatsu/hata/tree/master/docs/examples">Examples</a> |
      <a href="https://www.astil.dev/project/hata/docs/hata">Technical documentation</a> |
      <a href="https://github.com/HuyaneMatsu/hata">Source</a>
  </p>

  <h1></h1>
  <br>
  <p align="center">
      New hata versions use
      <a href="https://github.com/discord/discord-api-docs/discussions/4510">
          Discord API V10
      </a>
      .
  </p>

  <h1></h1>

  <h3 align="center">
      About
  </h3>



  Hata is an *asynchronous* [Discord API](https://discord.com/developers/docs/intro) wrapper built on top of scarletio.
  It is designed to be easy to use, with also providing rich API offering everything what an advanced developer might
  need.

  Named after [Hata no Kokoro](https://en.touhouwiki.net/wiki/Hata_no_Kokoro) from Touhou Project.

  <h1></h1>

  <h3 align="center">
      Why hata?
  </h3>

  - Multiple simultaneous clients

      Hata can run multiple clients from the same instance without sacrificing performance.

  - Performant

      Fast concurrent code based on async/await paradigm with cache control, PyPy support and much more!

  - Newest API features

      Whatever Discord decides to release/update/break Hata will support it natively in no time!

  - 100% Python

      Built in Python! Easy to code, easy to read, easy to maintain.

  <h1></h1>

  <h3 align="center">
      Usage
  </h3>

  Simple example implementing a `ping` command.

  ```py
  from hata import Client, Guild, wait_for_interruption

  GUILD = Guild.precreate(guild_id)

  Seija = Client('TOKEN', extensions = ['slash'])

  @Seija.events
  async def ready(client):
      print(f'{client:f} logged in.')

  @Seija.interactions(guild = GUILD)
  async def ping():
      """ping-pong"""
      return 'pong'

  Seija.start()

  wait_for_interruption()
  ```

  <h1></h1>

  *Hata leaves the main thread free, `client.start()` blocks it only till the client logs in (or fails it), although you
  can still use the `start_clients()` function, what as it says, starts up all the non-running clients parallelly.*

  *Sometimes leaving the main thread might cause problems when trying to shut down the bot(s). At this case, you might
  want to use `wait_for_interruption()`, which disconnects the clients gracefully and closes the event loop on keyboard
  interrupt.*

  <h1></h1>

  <h3 align="center">
      Installation
  </h3>

  To install Hata simply do

  ```shell

  $ python3 -m pip install hata


  $ python -m pip install hata


  $ python -m pip install hata[voice]
  ```
  And you are good to go! Hata has native pypy support as well if you need some more speed!

  <h1></h1>

  <h3 align="center">
      Dependencies
  </h3>



  - Python >= 3.6
  - [chardet](https://pypi.python.org/pypi/chardet) / [cchardet](https://pypi.org/project/cchardet/)



  - [dateutil](https://pypi.org/project/python-dateutil/)
  - [PyNaCl](https://pypi.org/project/PyNaCl/) (for voice support)

  <h1></h1>

  <h3 align="center">
      Get in touch
  </h3>

  If you have issues, suggestions, want to contribute, or just want to hang out, join our discord server.

  <p align="center">
      <a href="https://discord.gg/3cH2r5d">
          <img
              alt="Invite"
              src="https://discordapp.com/api/v9/guilds/388267636661682178/widget.png?style=banner1"
          />
      </a>
  </p>

  <h1></h1>

  <h3 align="center">
      Acknowledgements
  </h3>

  Shout-Out to our brave testers who are helping the most to improve Hata!

  - [`Koish`](https://github.com/UnconsciousPebble) \[Feature requests\]
  - [`BrainDead`](https://github.com/albertopoljak) \[Documentation improvements\]


pkgId: 8f6e5c6b7baca7ad83b4e148739c130cf0ac87f3bb28bfc9b606a1e382440ac9
name: python-hatch-buildext-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for hatch-buildext
url: https://pypi.org/project/hatch-buildext/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hatch-buildext-0.0.2-1.src.rpm
location_href: Packages/python-hatch-buildext-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install hatch-buildext
  ```

  `hatch-buildext` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.


pkgId: 9044798447578d7f32d7f9b48d211394adb344a85fb386d45795b2e623213310
name: python-hatch-help
arch: noarch
version: 1.14.0
epoch: 0
release: 1
summary: Development documents and examples for hatch
url: https://hatch.pypa.io/latest/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hatch-1.14.0-1.src.rpm
location_href: Packages/python-hatch-help-1.14.0-1.noarch.rpm
checksum_type: sha256
description:
  Hatch is a modern, extensible Python project manager.

  - Standardized [build system](https://hatch.pypa.io/latest/config/build/#build-system) with reproducible builds by default
  - Robust [environment management](https://hatch.pypa.io/latest/environment/) with support for custom scripts and UV
  - Configurable [Python distribution management](https://hatch.pypa.io/latest/tutorials/python/manage/)
  - [Test execution](https://hatch.pypa.io/latest/tutorials/testing/overview/) with known best practices
  - [Static analysis](https://hatch.pypa.io/latest/config/static-analysis/) with sane defaults
  - Built-in Python [script runner](https://hatch.pypa.io/latest/how-to/run/python-scripts/)
  - Easy [publishing](https://hatch.pypa.io/latest/publish/) to PyPI or other indices
  - [Version](https://hatch.pypa.io/latest/version/) management
  - Best practice [project generation](https://hatch.pypa.io/latest/config/project-templates/)
  - Responsive [CLI](https://hatch.pypa.io/latest/cli/about/), ~2-3x [faster](https://github.com/pypa/hatch/actions/workflows/cli.yml) than equivalent tools
  See the [Why Hatch?](https://hatch.pypa.io/latest/why/) page for more information.

  The [documentation](https://hatch.pypa.io/) is made with [Material for MkDocs](https://github.com/squidfunk/mkdocs-material) and is hosted by [GitHub Pages](https://docs.github.com/en/pages).

  Hatch is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: 469cf909d87944784664ad9b8fef740bd92d74edd829412b6d92d85b40042322
name: python-hatchet-sdk-help
arch: noarch
version: 0.42.2
epoch: 0
release: 1
summary: Development documents and examples for hatchet-sdk
url: https://pypi.org/project/hatchet-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hatchet-sdk-0.42.2-1.src.rpm
location_href: Packages/python-hatchet-sdk-help-0.42.2-1.noarch.rpm
checksum_type: sha256
description:
  This is the [Hatchet](https://hatchet.run) Python SDK. For usage, see the [docs](https://docs.hatchet.run).


pkgId: e959ac1dc7e624a64b28762988bb5aebad3eea9a66ef8f0ad0d2c37dd99e92f3
name: python-hattrick-libs-help
arch: noarch
version: 0.19.1
epoch: 0
release: 1
summary: Development documents and examples for hattrick-libs
url: https://pypi.org/project/hattrick-libs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hattrick-libs-0.19.1-1.src.rpm
location_href: Packages/python-hattrick-libs-help-0.19.1-1.noarch.rpm
checksum_type: sha256
description:
  This is a python3 client library for the API of the infamous online-strategy-game hattrick (https://www.hattrick.org).

  As this was just intended to be a learning-project and to be the ground-work for another hattrick-project of mine initially,
  https://hattrick-fun-with-flags.app, hattick_libs doesn't aim to be complete nor useful to any other purpose than it was originally built for.

  If you are looking for a complete python library for hattrick.org consider also pyCHPP by Pierre Gobin. His project was there before mine and
  looks quite sophisticated to me. It's implemented in an object-oriented style and thus well readable and clean. Compared to pyCHPP, hattrick_libs is a
  very basic implementation of the hattrick-API. But consider also this: If you are a learner like myself, hattrick_libs will be a perfect opportunity
  to get your hands dirty on some cool python stuff without having to learn oop first. Or you decide to implement your own flavor of a hattick library
  in python and let yourself inspire by both this projects. There is room for all of us. Whatever your decision is: make sure to connect. Refer to the
  "Contact" section of this document if you can help improve hattrick_libs, have suggestions, if you want to adopt it to your needs or if you just feel
  like having a chat with another nerdy hattrick manager.

  Have fun!:)


  For now the projects state is work in progress. It originally was just my 2023 christmas project after all!;) I'm actively maintaining it though.
  (information as of 2024-10-15)


  https://github.com/joschobart/hattrick_libs


  ```bash
  pip install hattrick-libs
  ```


  In your code directly reference the module you need:
  ```python
  from ht_libs import do_hattrick_request
  ```
  You find a sample-implementation of hattrick_libs in the [\_\_main\_\_.py](__main__.py) file.


  This package is licensed under the Apache License 2.0.


  joschobart on hattrick.org for a chat about bugs, hattrick, (monty) python or discworld.


pkgId: 888391017b6b2720bd3416174b585ed62593278fd01eaf88aba0e98951f711cd
name: python-havenlighting-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for havenlighting
url: https://pypi.org/project/havenlighting/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-havenlighting-0.1.0-1.src.rpm
location_href: Packages/python-havenlighting-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A Python client library for interacting with the Haven Lighting API.



  ```bash
  pip install havenlighting
  ```



  ```python
  from havenlighting import HavenClient


  client = HavenClient()


  authenticated = client.authenticate(
      email="your-email@example.com",
      password="your-password"
  )

  if authenticated:
      
      locations = client.discover_locations()

      
      for location_id, location in locations.items():
          print(f"Location: {location.name}")

          
          lights = location.get_lights()

          
          for light_id, light in lights.items():
              print(f"Light: {light.name}")
              light.turn_on()   # Turn light on
              light.turn_off()  # Turn light off

  ```



  1. Clone the repository
  2. Install development dependencies:
  ```bash
  pip install -e ".[dev]"
  ```

  3. Run tests:
  ```bash
  pytest
  ```



  MIT License - see LICENSE file for details.


pkgId: d1c47d7b7582a47f78cb42d4b2fc31ac60ad4d418ec34258ab623520613c69a2
name: python-hawk-scanner-help
arch: noarch
version: 0.3.23
epoch: 0
release: 1
summary: Development documents and examples for hawk-scanner
url: https://github.com/rohitcoder/hawk-eye
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hawk-scanner-0.3.23-1.src.rpm
location_href: Packages/python-hawk-scanner-help-0.3.23-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">🦅 Hawk-eye </h1>
  <p align="center"><b>Find PII & Secrets like never before across your entire infrastructure with same tool!</b></p>
  <p align="center">
  <a href="#description">Description</a> • <a href="#installation">Installation</a> • <a href="#features">Features</a> • <a href="#config">Configuration</a> • <a href="#acknowledgements">Acknowledgements</a><br><br>

  [![Publish to PyPI.org](https://github.com/rohitcoder/hawk-eye/actions/workflows/pypi.yml/badge.svg)](https://github.com/rohitcoder/hawk-eye/actions/workflows/pypi.yml)
  <img alt="Static Badge" src="https://img.shields.io/badge/Supports-S3-yellow?logo=amazons3">
  <img alt="Static Badge" src="https://img.shields.io/badge/Supports-GCP-red?logo=googlecloud">
  <img alt="Static Badge" src="https://img.shields.io/badge/Supports-MysQL-green?logo=mysql">
  <img alt="Static Badge" src="https://img.shields.io/badge/Supports-PostgreSQL-blue?logo=postgresql">
  <img alt="Static Badge" src="https://img.shields.io/badge/Supports-Redis-red?logo=redis">
  <img alt="Static Badge" src="https://img.shields.io/badge/Supports-On Prem-black?logo=amazonec2">
  </p>

  <div id="description">



  HAWK Eye is a robust, command-line tool built to safeguard against data breaches and cyber threats. Much like the sharp vision of a hawk, it quickly scans multiple data sources—S3, MySQL, PostgreSQL, MongoDB, CouchDB, Google Drive, Slack, Redis, Firebase, file systems, and Google Cloud buckets (GCS)—for Personally Identifiable Information (PII) and secrets. Using advanced text analysis and OCR techniques, HAWK Eye delves into various document formats like docx, xlsx, pptx, pdf, images (jpg, png, gif), compressed files (zip, tar, rar), and even video files to ensure comprehensive protection across platforms.



  Like the keen vision of a hawk, this tool enables you to monitor and safeguard your data with precision and accuracy, ensuring data privacy and security.
  </div>


  For commercial support and help with HAWK Eye, please contact us at [LinkedIn](https://linkedin.com/in/rohitcoder) or [Twitter](https://twitter.com/rohitcoder).



  See how this works on Youtube - https://youtu.be/LuPXE7UJKOY

  ![HAWK Eye Demo](assets/preview.png)
  ![HAWK Eye Demo](assets/preview2.png)


  <div id="installation">


     ```bash
        pip3 install hawk-scanner
     ```



  1. Example working command (Use all/fs/s3/gcs etc...)
     ```bash
        hawk_scanner all --connection connection.yml --fingerprint fingerprint.yml --json output.json --debug
     ```
  2. Pass connection data as CLI input in --connection-json flag, and output in json data (Helpful for CI/CD pipeline or automation)
     ```bash
       hawk_scanner fs --connection-json '{"sources": {"fs": {"fs1": {"quick_scan": true, "path": "/Users/rohitcoder/Downloads/data/KYC_PDF.pdf"}}}}' --stdout --quiet --fingerprint fingerprint.yml
     ```

  3. You can also import Hawk-eye in your own python scripts and workflows, for better flexibility
     ```python
        from hawk_scanner.internals import system
        pii = system.scan_file("/Users/kumarohit/Downloads/Resume.pdf")
        print(pii)
     ```

  4. You can also import Hawk-eye with custom fingerprints in your own python scripts like this
  ```python
     from hawk_scanner.internals import system
     pii = system.scan_file("/Users/kumarohit/Downloads/Resume.pdf", {
         "fingerprint": {
           "Email": '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}',
        }
     )
     print(pii)
     ```




  You have to install some extra dependencies.
  For scanning postgresql source, this tool requires ``psycopg2-binary`` dependency, we can't ship this dependency with main package because psycopg2-binary not works with most of the systems espically with Windows, so you have to install it manually.

     ```bash
        pip3 install psycopg2-binary
     ```


  You may get error after running ``hawk-scanner`` command on redhat from ``cv2`` dependency . You need to install some extra dependencies
  ```
  yum install mesa-libGL
  ```



  HAWK Eye is a Python-based CLI tool that can be installed using the following steps:

  1. Clone the HAWK Eye repository to your local machine.
     ```bash
        git clone https://github.com/rohitcoder/hawk-eye.git
     ```
  2. Navigate to the HAWK Eye directory.
  3. Run the following command to install the required dependencies:
     ```bash
        pip3 install -r requirements.txt
     ```
  4. Create a connection.yml file in the root directory and add your connection profiles (see the "How to Configure HAWK Eye Connections" section for details).
  5. Run the following command to install HAWK Eye:
     ```bash
        python3 hawk_scanner/main.py
     ```
  </div>

  <div id="features">


  - Swiftly scans multiple data sources (S3, MySQL, PostgreSQL, Redis, Firebase, filesystem, and GCS) for PII data and malware exposure.
  - Advanced algorithms and deep scanning capabilities provide thorough security auditing.
  - Real-time alerts and notifications keep you informed of potential data vulnerabilities using Slack and other integrations, with more coming soon.
  - New command support for S3, MySQL, PostgreSQL, Redis, Firebase, filesystem, and GCS expands the tool's capabilities.
  - ``--debug`` flag enables printing of all debugging output for comprehensive troubleshooting.
  - Save output in JSON format using the --json flag and specify a file name like --json output.json.
  - Proudly crafted with love and a sense of humor to make your security journey enjoyable and stress-free.



  To unleash the power of HAWK Eye, simply follow the steps mentioned in the "Usage" section of the "README.md" file.


  Note: If you don't provide any command, it will run all commands (firebase, fs, gcs, mysql, text, couchdb, gdrive, gdrive workspace, slack, postgresql, redis, s3) by default.
  <table>
     <thead>
        <tr>
           <th>Option</th>
           <th>Description</th>
        </tr>
     </thead>
     <tbody>
        <tr>
           <td>
             firebase
           </td>
           <td>Scan Firebase profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              fs
              <commit_id>
           </td>
           <td>Scan filesystem profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              gcs
           </td>
           <td>Scan GCS (Google Cloud Storage) profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              text
           </td>
           <td>Scan text or string for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              mysql
           <td>Scan MySQL profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              mongodb
           <td>Scan MongoDB profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              couchdb
           <td>Scan CouchDB profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              slack
           <td>Scan slack profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              postgresql
           <td>Scan postgreSQL profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              redis
           </td>
           <td>Scan Redis profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              s3
            </td>
           <td>Scan S3 profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              gdrive
            </td>
           <td>Scan Google drive profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>
              gdrive_workspace
            </td>
           <td>Scan Google drive Workspace profiles for PII and secrets data.</td>
        </tr>
        <tr>
           <td>--connection</td>
           <td>Provide a connection YAML local file path like --connection connection.yml, this file will contain all creds and configs for different sources and other configurations.</td>
        </tr>
        <tr>
           <td>--connection-json</td>
           <td>Provide a connection json as CLI Input, helpful when you want to run this tool in CI/CD pipeline or automation.</td>
        </tr>
        <tr>
           <td>--fingerprint</td>
           <td>Provide a fingerprint file path like --fingerprint fingerprint.yml, this file will override default fingerprints.</td>
        </tr>
        <tr>
           <td>--debug</td>
           <td>Enable Debug mode.</td>
        </tr>
        <tr>
           <td>--stdout</td>
           <td>Print output on stdout or terminal.</td>
        </tr>
        <tr>
           <td>--quiet</td>
           <td>Use --quiet flag if you want to hide all logs from your terminal.</td>
        </tr>
        <tr>
           <td>--json</td>
           <td>Provide --json file name to save output in json file like --json output.json</td>
        </tr>
        <tr>
           <td>--shutup</td>
           <td>Use --shutup flag if you want to hide Hawk ASCII art from your terminal 😁</td>
        </tr>
     </tbody>
  </table>
  </div>

  <div id="config">



  HAWK Eye uses a YAML file to store connection profiles for various data sources. The connection.yml file is located in the config directory. You can add new profiles to this file to enable HAWK Eye to scan additional data sources. The following sections describe the process for adding new profiles to the connection.yml file.




  ```yaml
  notify:
    redacted: True
    suppress_duplicates: True
    slack:
      webhook_url: https://hooks.slack.com/services/T0XXXXXXXXXXX/BXXXXXXXX/1CIyXXXXXXXXXXXXXXX

  sources:
    redis:
      redis_example:
        host: YOUR_REDIS_HOST
        password: YOUR_REDIS_PASSWORD
    s3:
      s3_example:
        access_key: YOUR_S3_ACCESS_KEY
        secret_key: YOUR_S3_SECRET_KEY
        bucket_name: YOUR_S3_BUCKET_NAME
        cache: true
    gcs:
      gcs_example:
        credentials_file: /path/to/your/credential_file.json
        bucket_name: YOUR_GCS_BUCKET_NAME
        cache: true
        exclude_patterns:
          - .pdf
          - .docx
    firebase:
      firebase_example:
        credentials_file: /path/to/your/credential_file.json
        bucket_name: YOUR_FIREBASE_BUCKET_NAME
        cache: true
        exclude_patterns:
          - .pdf
          - .docx
    mysql:
      mysql_example:
        host: YOUR_MYSQL_HOST
        port: YOUR_MYSQL_PORT
        user: YOUR_MYSQL_USERNAME
        password: YOUR_MYSQL_PASSWORD
        database: YOUR_MYSQL_DATABASE_NAME
        limit_start: 0   # Specify the starting limit for the range
        limit_end: 500   # Specify the ending limit for the range
        tables:
          - table1
          - table2
        exclude_columns:
           - column1
           - column2
    postgresql:
      postgresql_example:
        host: YOUR_POSTGRESQL_HOST
        port: YOUR_POSTGRESQL_PORT
        user: YOUR_POSTGRESQL_USERNAME
        password: YOUR_POSTGRESQL_PASSWORD
        database: YOUR_POSTGRESQL_DATABASE_NAME
        limit_start: 0   # Specify the starting limit for the range
        limit_end: 500   # Specify the ending limit for the range
        tables:
          - table1
          - table2
    mongodb:
      mongodb_example:
        uri: YOUR_MONGODB_URI
        host: YOUR_MONGODB_HOST
        port: YOUR_MONGODB_PORT
        username: YOUR_MONGODB_USERNAME
        password: YOUR_MONGODB_PASSWORD
        database: YOUR_MONGODB_DATABASE_NAME
        uri: YOUR_MONGODB_URI  # Use either URI or individual connection parameters
        limit_start: 0   # Specify the starting limit for the range
        limit_end: 500   # Specify the ending limit for the range
        collections:
          - collection1
          - collection2
    fs:
      fs_example:
        path: /path/to/your/filesystem/directory
        exclude_patterns:
          - .pdf
          - .docx
          - private
          - venv
          - node_modules

   gdrive:
      drive_example:
        folder_name:
        credentials_file: /Users/kumarohit/Downloads/client_secret.json ## this will be oauth app json file
        cache: true
        exclude_patterns:
          - .pdf
          - .docx

    gdrive_workspace:
      drive_example:
        folder_name:
        credentials_file: /Users/kumarohit/Downloads/client_secret.json ## this will be service account json file
        impersonate_users:
          - usera@amce.org
          - userb@amce.org
        cache: true
        exclude_patterns:
          - .pdf
          - .docx
    text:
      profile1:
        text: "Hello World HHWPK6943Q"
    slack:
      slack_example:
        token: xoxp-XXXXXXXXXXXXXXXXXXXXXXXXX # get your slack app these permissiosn https://api.slack.com/methods/team.info and https://api.slack.com/methods/conversations.list
        channel_types: "public_channel,private_channel"
        
        
        
        
  ```

  You can add or remove profiles from the connection.yml file as needed. You can also configure only one or two data sources if you don't need to scan all of them.
  </div>


  HAWK Eye's extensibility empowers developers to contribute new security commands. Here's how:

  1. Fork the HAWK Eye repository to your GitHub account.
  2. Create a new Python file for your security command inside the commands directory, with a descriptive name.
  3. Define a function execute(args) within the new Python file, containing the logic for your command.
  4. Provide clear documentation and comments explaining the purpose and usage of the new command.
  5. Thoroughly test your command to ensure it works seamlessly and aligns with the existing features.
  6. Submit a pull request from your branch to the main HAWK Eye repository.
  7. The maintainers will review your contribution, provide feedback if needed, and merge your changes.


  We welcome contributions from the open-source community to enhance HAWK Eye's capabilities in securing data sources. To contribute:

  1. Fork the HAWK Eye repository to your GitHub account.
  2. Create a new branch from the main branch for your changes.
  3. Adhere to the project's coding standards and style guidelines.
  4. Write clear and concise commit messages for your changes.
  5. Include appropriate test cases for new features or modifications.
  6. Update the "README.md" file to reflect any changes or new features.
  7. Submit a pull request from your branch to the main branch of the HAWK Eye repository.
  8. The maintainers will review your pull request and work with you to address any concerns.
  9. After approval, your contributions will be merged into the main codebase.

  Join the HAWK Eye community and contribute to data source security worldwide. For any questions or assistance, feel free to open an issue on the repository.

  If you find HAWK Eye useful and would like to support the project, please consider making a donation. All 100% of the donations will be distributed to charities focused on education welfare and animal help.

  <div id="acknowledgements">


  <ul type="disc">
  <li><a href="https://www.blackhat.com/sector/2023/arsenal/schedule/index.html#hawk-eye---pii--secret-detection-tool-for-your-servers-database-filesystems-cloud-storage-services-35716" target="_blank">
  Black Hat SecTor 2023 [Arsenal]</a></li>
  <li><a href="https://blackhatmea.com/session/hawk-eye-pii-secret-detection-tool-your-servers-database-filesystems-cloud-storage-0" target="_blank">
  Black Hat Middle East and Africa 2023 [Arsenal]</a></li>
  <li><a href="https://www.blackhat.com/eu-23/arsenal/schedule/index.html#hawk-eye---pii--secret-detection-tool-for-your-servers-database-filesystems-cloud-storage-services-35711" target="_blank">
  Black Hat Europe 2023 [Arsenal]</a></li>
  </ul>


  We extend our heartfelt appreciation to all contributors who continuously improve this tool! Your efforts are essential in strengthening the security landscape. 🙏

  <a href="https://github.com/rohitcoder/hawk-eye/graphs/contributors">
    <img src="https://contrib.rocks/image?abc=1&repo=rohitcoder/hawk-eye" />
  </a>
  </div>



  Feel free to make a donation directly to the charities of your choice or send it to us, and we'll ensure it reaches the deserving causes. Just reach out to us on [LinkedIn](https://linkedin.com/in/rohitcoder) or [Twitter](https://twitter.com/rohitcoder) to let us know about your contribution. Your generosity and support mean the world to us, and we can't wait to express our heartfelt gratitude.

  Your donations will play a significant role in making a positive impact in the lives of those in need. Thank you for considering supporting our cause!


pkgId: ad0bc88af946867d832875bd0e7e37c8c9a7a25d0e8080cef8616f34c72891c7
name: python-hayhooks-help
arch: noarch
version: 0.0.19
epoch: 0
release: 1
summary: Development documents and examples for hayhooks
url: https://pypi.org/project/hayhooks/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hayhooks-0.0.19-1.src.rpm
location_href: Packages/python-hayhooks-help-0.0.19-1.noarch.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Hayhooks](#hayhooks)
    - [Quick start](#quick-start)
      - [Install the package](#install-the-package)
      - [Check Hayhooks status](#check-hayhooks-status)
      - [Deploy a Haystack pipeline](#deploy-a-haystack-pipeline)
      - [Have a look at the API schema](#have-a-look-at-the-api-schema)
      - [Run the pipeline](#run-the-pipeline)
      - [Undeploy the pipeline](#undeploy-the-pipeline)
    - [Docker setup](#docker-setup)
    - [Next steps](#next-steps)
    - [License](#license)


  Start by installing the package:
  ```console
  pip install hayhooks
  ```
  The `hayhooks` package ships both the server and the client component, and the client is capable of starting the
  server. From a shell, start the server with:
  ```console
  $ hayhooks run
  INFO:     Started server process [44782]
  INFO:     Waiting for application startup.
  INFO:     Application startup complete.
  INFO:     Uvicorn running on http://localhost:1416 (Press CTRL+C to quit)
  ```

  From a different shell, you can query the status of the server with:
  ```console
  $ hayhooks status
  Hayhooks server is up and running.
  ```

  Time to deploy a Haystack pipeline. The pipeline must be in Yaml format (the output of [`pipeline.dump()`](https://docs.haystack.deepset.ai/v2.0/docs/serialization#converting-a-pipeline-to-yaml)), if you don't have one at hand, you can use
  one from this repository. From the root of the repo:
  ```console
  $ hayhooks deploy tests/test_files/test_pipeline_01.yml
  Pipeline successfully deployed with name: test_pipeline_01
  ```
  Another call to `status` should confirm your pipeline is ready to serve requests:
  ```console
  $ hayhooks status
  Hayhooks server is up and running.
  Pipelines deployed:
  - test_pipeline_01
  ```

  Hayhooks will use introspection to set up the OpenAPI schema accordingly to the inputs and outputs of your pipeline,
  and to see how this works let's get the pipeline diagram with:
  ```console
  $ curl http://localhost:1416/draw/test_pipeline_01 --output test_pipeline_01.png
  ```
  The downloaded image should look like this:
  ![test pipeline](img/test_pipeline_01.png)
  As you can see, the pipeline in order to start requires an input of type `int` named `value`, and optionally we can
  pass another input of type `int` named `add`. At the end of the run, the pipeline will return an output of type `int`
  named `result`.
  If you open a browser at [http://localhost:1416/docs#/](http://localhost:1416/docs#/) you should see two schemas, one
  for the Request, where we'll pass the pipeline inputs (note how `add` is optional):
  ```
  Test_pipeline_01RunRequest
      first_addition
          value* integer
          add (integer | null)
  ```
  And another one for the Response, where we'll receive the pipeline results:
  ```
  Test_pipeline_01RunResponse
      double
          value* integer
  ```

  At this point, knowing the schema we can run our pipeline with an HTTP client:
  ```console
  $ curl -X 'POST' \
    'http://localhost:1416/test_pipeline_01' \
    -H 'accept: application/json' \
    -H 'Content-Type: application/json' \
    -d '{
    "first_addition": {
      "value": 19
    }
  }'
  {"double":{"value":42}}%
  ```

  Hayhooks tries to do as much bookkeeping as possible without restarting the server. For example, to free up
  resources you can undeploy the pipeline directly from the client:
  ```console
  $ hayhooks undeploy test_pipeline_01
  Pipeline successfully undeployed
  ```

  To connect to a specific server you can pass a `--server` argument to the client:
  ```bash
  $ hayhooks --server http://myserver:1416 status
  ```

  For development purposes, you can disable SSL verification with the `--disable-ssl` flag:
  ```bash
  $ hayhooks --disable-ssl status
  ```

  > [!TIP]
  > If you have docker-compose installed and you want to quickly get up and running, just do `docker-compose up -d`
  Instead of launching the server in a separate shell like we did in the Quick Start, you can run it in a Docker
  container :
  ```console
  $ docker run --rm -p 1416:1416 deepset/hayhooks:main
  ```
  If you want to build the container yourself:
  ```console
  $ cd docker
  $ docker buildx bake
  ```
  There are 2 special folders in the container you can override using a `mount`:
  1. A folder `/opt/pipelines` containing pipeline definitions that will be automatically deployed when the container starts
  2. A folder `/opt/custom_components` containing custom components that Haystack will be able to import if part of a pipeline
  For example, you can mount a local `./pipelines` folder containing pipelines you want to run at start-up like this:
  ```console
  $ docker run --rm -p 1416:1416 -v $PWD/pipelines:/opt/pipelines "deepset/hayhooks:main"
  ```

  `hayhooks` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.


pkgId: b8e86f67460c5ef3d0adc68c9b72e7aaed93d87b1d8fe3ac7144c2356ad424e0
name: python-haystack-ai-help
arch: noarch
version: 2.8.0
epoch: 0
release: 1
summary: Development documents and examples for haystack-ai
url: https://github.com/deepset-ai/haystack
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-haystack-ai-2.8.0-1.src.rpm
location_href: Packages/python-haystack-ai-help-2.8.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <a href="https://haystack.deepset.ai/"><img src="https://raw.githubusercontent.com/deepset-ai/haystack/main/docs/img/banner_20.png" alt="Green logo of a stylized white 'H' with the text 'Haystack, by deepset. Haystack 2.0 is live 🎉' Abstract green and yellow diagrams in the background."></a>

  |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
  | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
  | CI/CD   | [![Tests](https://github.com/deepset-ai/haystack/actions/workflows/tests.yml/badge.svg)](https://github.com/deepset-ai/haystack/actions/workflows/tests.yml) [![types - Mypy](https://img.shields.io/badge/types-Mypy-blue.svg)](https://github.com/python/mypy) [![Coverage Status](https://coveralls.io/repos/github/deepset-ai/haystack/badge.svg?branch=main)](https://coveralls.io/github/deepset-ai/haystack?branch=main) [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) |
  | Docs    | [![Website](https://img.shields.io/website?label=documentation&up_message=online&url=https%3A%2F%2Fdocs.haystack.deepset.ai)](https://docs.haystack.deepset.ai)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
  | Package | [![PyPI](https://img.shields.io/pypi/v/haystack-ai)](https://pypi.org/project/haystack-ai/) ![PyPI - Downloads](https://img.shields.io/pypi/dm/haystack-ai?color=blue&logo=pypi&logoColor=gold) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/haystack-ai?logo=python&logoColor=gold) [![Conda Version](https://img.shields.io/conda/vn/conda-forge/haystack-ai.svg)](https://anaconda.org/conda-forge/haystack-ai) [![GitHub](https://img.shields.io/github/license/deepset-ai/haystack?color=blue)](LICENSE) [![License Compliance](https://github.com/deepset-ai/haystack/actions/workflows/license_compliance.yml/badge.svg)](https://github.com/deepset-ai/haystack/actions/workflows/license_compliance.yml) |
  | Meta    | [![Discord](https://img.shields.io/discord/993534733298450452?logo=discord)](https://discord.com/invite/xYvH6drSmA) [![Twitter Follow](https://img.shields.io/twitter/follow/haystack_ai)](https://twitter.com/haystack_ai)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
  </div>

  [Haystack](https://haystack.deepset.ai/) is an end-to-end LLM framework that allows you to build applications powered by
  LLMs, Transformer models, vector search and more. Whether you want to perform retrieval-augmented generation (RAG),
  document search, question answering or answer generation, Haystack can orchestrate state-of-the-art embedding models
  and LLMs into pipelines to build end-to-end NLP applications and solve your use case.



  The simplest way to get Haystack is via pip:

  ```sh
  pip install haystack-ai
  ```

  Install from the `main` branch to try the newest features:
  ```sh
  pip install git+https://github.com/deepset-ai/haystack.git@main
  ```

  Haystack supports multiple installation methods including Docker images. For a comprehensive guide please refer
  to the [documentation](https://docs.haystack.deepset.ai/docs/installation).



  If you're new to the project, check out ["What is Haystack?"](https://haystack.deepset.ai/overview/intro) then go
  through the ["Get Started Guide"](https://haystack.deepset.ai/overview/quick-start) and build your first LLM application
  in a matter of minutes. Keep learning with the [tutorials](https://haystack.deepset.ai/tutorials). For more advanced
  use cases, or just to get some inspiration, you can browse our Haystack recipes in the
  [Cookbook](https://haystack.deepset.ai/cookbook).

  At any given point, hit the [documentation](https://docs.haystack.deepset.ai/docs/intro) to learn more about Haystack, what can it do for you and the technology behind.



  > [!IMPORTANT]
  > **You are currently looking at the readme of Haystack 2.0**. We are still maintaining Haystack 1.x to give everyone
  > enough time to migrate to 2.0. [Switch to Haystack 1.x here](https://github.com/deepset-ai/haystack/tree/v1.x).

  - **Technology agnostic:** Allow users the flexibility to decide what vendor or technology they want and make it easy to switch out any component for another. Haystack allows you to use and compare models available from OpenAI, Cohere and Hugging Face, as well as your own local models or models hosted on Azure, Bedrock and SageMaker.
  - **Explicit:** Make it transparent how different moving parts can “talk” to each other so it's easier to fit your tech stack and use case.
  - **Flexible:** Haystack provides all tooling in one place: database access, file conversion, cleaning, splitting, training, eval, inference, and more. And whenever custom behavior is desirable, it's easy to create custom components.
  - **Extensible:** Provide a uniform and easy way for the community and third parties to build their own components and foster an open ecosystem around Haystack.

  Some examples of what you can do with Haystack:

  -   Build **retrieval augmented generation (RAG)** by making use of one of the available vector databases and customizing your LLM interaction, the sky is the limit 🚀
  -   Perform Question Answering **in natural language** to find granular answers in your documents.
  -   Perform **semantic search** and retrieve documents according to meaning.
  -   Build applications that can make complex decisions making to answer complex queries: such as systems that can resolve complex customer queries, do knowledge search on many disconnected resources and so on.
  -   Scale to millions of docs using retrievers and production-scale components.
  -   Use **off-the-shelf models** or **fine-tune** them to your data.
  -   Use **user feedback** to evaluate, benchmark, and continuously improve your models.

  > [!TIP]
  ><img src="https://github.com/deepset-ai/haystack/raw/main/docs/img/deepset-cloud-logo-lightblue.png"  width=30% height=30%>
  >
  > Are you looking for a managed solution that benefits from Haystack? [deepset Cloud](https://www.deepset.ai/deepset-cloud?utm_campaign=developer-relations&utm_source=haystack&utm_medium=readme) is our fully managed, end-to-end platform to integrate LLMs with your data, which uses Haystack for the LLM pipelines architecture.



  Use **deepset Studio** to visually create, deploy, and test your Haystack pipelines. Learn more about it in [our announcement post](https://haystack.deepset.ai/blog/announcing-studio).

  ![studio](https://github.com/user-attachments/assets/e4f09746-20b5-433e-8261-eca224ac23b3)


  👉 [Sign up](https://landing.deepset.ai/deepset-studio-signup)!



  Haystack collects **anonymous** usage statistics of pipeline components. We receive an event every time these components are initialized. This way, we know which components are most relevant to our community.

  Read more about telemetry in Haystack or how you can opt out in [Haystack docs](https://docs.haystack.deepset.ai/docs/telemetry).



  If you have a feature request or a bug report, feel free to open an [issue in Github](https://github.com/deepset-ai/haystack/issues). We regularly check these and you can expect a quick response. If you'd like to discuss a topic, or get more general advice on how to make Haystack work for your project, you can start a thread in [Github Discussions](https://github.com/deepset-ai/haystack/discussions) or our [Discord channel](https://discord.com/invite/VBpFzsgRVF). We also check [𝕏 (Twitter)](https://twitter.com/haystack_ai) and [Stack Overflow](https://stackoverflow.com/questions/tagged/haystack).



  We are very open to the community's contributions - be it a quick fix of a typo, or a completely new feature! You don't need to be a Haystack expert to provide meaningful improvements. To learn how to get started, check out our [Contributor Guidelines](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md) first.

  There are several ways you can contribute to Haystack:
  - Contribute to the main Haystack project
  - Contribute an integration on [haystack-core-integrations](https://github.com/deepset-ai/haystack-core-integrations)

  > [!TIP]
  >👉 **[Check out the full list of issues that are open to contributions](https://github.com/orgs/deepset-ai/projects/14)**



  Here's a list of projects and companies using Haystack. Want to add yours? Open a PR, add it to the list and let the
  world know that you use Haystack!

  -   [Airbus](https://www.airbus.com/en)
  -   [Alcatel-Lucent](https://www.al-enterprise.com/)
  -   [Apple](https://www.apple.com/)
  -   [BetterUp](https://www.betterup.com/)
  -   [Databricks](https://www.databricks.com/)
  -   [Deepset](https://deepset.ai/)
  -   [Etalab](https://www.deepset.ai/blog/improving-on-site-search-for-government-agencies-etalab)
  -   [Infineon](https://www.infineon.com/)
  -   [Intel](https://github.com/intel/open-domain-question-and-answer#readme)
  -   [Intelijus](https://www.intelijus.ai/)
  -   [Intel Labs](https://github.com/IntelLabs/fastRAG#readme)
  -   [LEGO](https://github.com/larsbaunwall/bricky#readme)
  -   [Netflix](https://netflix.com)
  -   [NOS Portugal](https://www.nos.pt/en/welcome)
  -   [Nvidia](https://developer.nvidia.com/blog/reducing-development-time-for-intelligent-virtual-assistants-in-contact-centers/)
  -   [PostHog](https://github.com/PostHog/max-ai#readme)
  -   [Rakuten](https://www.rakuten.com/)
  -   [Sooth.ai](https://www.deepset.ai/blog/advanced-neural-search-with-sooth-ai)


