semvec/pypi-packages huggingface dataset:
trailwatch-python-sdk 0.0.1
Python SDK for Trailwatch by Kicksaw
License: MIT
Requires Python: >=3.9,<4.0

- [Installation](#installation)
- [Getting Started](#getting-started)
- [Partial Success](#partial-success)

# Installation

```shell
pip install trailwatch
```

# Getting Started

```python
from trailwatch import configure, watch

configure(
  project="my-project",
  trailwatch_url="https://<random>.execute-api.us-west-2.amazonaws.com",
)

@watch()
def handler(event, context):
  # Do your thing
  return
```

# Partial Success

Raise a `PartialSuccess` exception to indicate that the execution was partially
successful. This exception is handled by Trailwatch to set execution status to `partial`
and will not be propagated to the caller.

```python
from trailwatch import configure, watch
from trailwatch.exceptions import PartialSuccessError

configure(
  project="my-project",
  trailwatch_url="https://<random>.execute-api.us-west-2.amazonaws.com",
)

@watch()
def handler(event, context):
  # Do your thing
  # You find out that only a subset of the work was successful
  # Log information about the failure normally using the logger
  raise PartialSuccessError
```
aigremlins 1.3
Using GPT 3 to backstop buggy code
License: MIT
Requires Python: >=3.9.10,<4.0.0

# AIGremlins

AI Gremlin - Automatic Error Correction with OpenAI
AI Gremlin is a Python module that leverages OpenAI's GPT-3 to automatically fix errors in your Python code. The module contains two main classes, GremlinTest and AIgremlin, which work together to handle exceptions and get suggestions for fixes from OpenAI's API.

Note:
Using this code in real applications is a terrible idea for many reasons, including:
- Creating the machine revolution by given an AI direct possibility to execute functions without anyone chekcing.
- There's no garantuee that the AI generated function won't break anything else or delete something import.
- Many other reasons.

Don't even think about using this in production.

## Installation
```
pip install aigremlins
```

## Example usage
```
from aigremlins import AIGremlin

# Initialize AI Gremlin instance with your OpenAI API key
gremlin = AIgrAIGremlinemlin(api_key="your_openai_api_key", verbose=True)

# Define the function with an error
@gremlin.ai_backstop
def buggy_function(a, b):
    """ This function should always return a value"""
    return a / b

# Call the function with parameters that cause an exception
result = buggy_function(4, 0)
```


### Features
Automatically detects and corrects errors in your Python functions using OpenAI's GPT-3.
Tries to stay as close as possible to the intent of the original function.
Dynamically adds and executes the new fixed function in the original namespace.
Customizable parameters to control the number of iterations, token limit, temperature settings, and verbosity of the output.
Ability to add custom instructions for OpenAI's API.

### How It Works
The AIgremlin class wraps your target function with a decorator called ai_backstop.
When the target function encounters an exception, the ai_backstop decorator captures the error, function code, and parameters.
The ai_backstop decorator formats a prompt for OpenAI's API to get a suggestion for fixing the function.
The suggestion is received from OpenAI's API, and a new fixed function is generated.
The fixed function is added to the original namespace and executed.
The process continues until the fixed function executes without errors or the maximum number of iterations is reached.

### Usage
1. Import the AIgremlin class from the module.
2. Instantiate an AIgremlin object with your OpenAI API key and other optional parameters (e.g., max_iterations, max_tokens, temperature, temperature_escalation, verbose, and instructions).
3. Define your function and apply the ai_backstop decorator to it.

Call the decorated function as you normally would. If an exception is encountered, the AI Gremlin will automatically attempt to fix it using OpenAI's API.


### Options
1. temperature -> default temperature of the model used.
2. temperature escalation -> the model can become increasingly creative. Should be somewhere between the range of 0.1-0.4 as the max temperature is 1.
3. instructions -> you can give additional instructions to the AI to take into consideration.
jow-api 0.1.4
Simple Python API for Jow.fr
License: MIT

# Jow API

This is a Python package that allows you to search for recipes on [Jow.fr](https://Jow.fr). The package provides an easy-to-use interface to search for recipes and fetch information about them.

## Installation

You can install the package using [pip](https://pip.pypa.io/en/stable/) : 

```bash
pip install jow-api
```

## Usage
The package provides convenient functions for searching and obtaining recipe information. Here's an example:

```python
from jow_api import Jow

# Perform a search for recipes containing the word "poulet"
recipes = Jow.search("poulet", limit=5)

# Loop through each recipe in the results and print its attributes
for recipe in recipes:
    print(f"ID: {recipe.id}")
    print(f"Name: {recipe.name}")
    print(f"URL: {recipe.url}")
    print(f"Description: {recipe.description}")
    print(f"Preparation time: {recipe.preparationTime}")
    print(f"Cooking time: {recipe.cookingTime}")
    print(f"Preparation extra time per cover: {recipe.preparationExtraTimePerCover}")
    print(f"Covers count: {recipe.coversCount}")
    print("Ingredients:")
    for ingredient in recipe.ingredients:
        print(f"\t{ingredient.name}: {ingredient.quantity} {ingredient.unit}")
        if ingredient.isOptional:
            print("\t(optional)")
    print()

```
The Jow.search() function takes a search query as input, with an optional limit parameter, and returns a list of JowResult objects. Each JowResult object contains information about a single recipe, including its ID, name, URL on Jow.fr, and a list of ingredients.

Each JowResult object contains the following attributes:

- `id` : The ID of the recipe.
- `name` : The name of the recipe.
- `url` : The URL of the recipe on Jow.fr.
- `ingredients` : A list of Ingredient objects, each of which represents an ingredient used in the recipe.
- `imageUrl` : The URL of the recipe image on Jow.fr.
- `videoUrl` : The URL of the recipe video on Jow.fr.
- `description` : A short description of the recipe.
- `preparationTime` : The time required to prepare the recipe (in minutes).
- `preparationExtraTimePerCover` : The extra time required to prepare the recipe for each additional serving.
- `cookingTime` : The time required to cook the recipe (in minutes).

Each Ingredient object contains the following attributes:

- `name` : The name of the ingredient.
- `quantity` : The quantity of the ingredient needed for the recipe.
- `unit` : The unit of measurement for the quantity of the ingredient.
- `isOptional` : A boolean value indicating whether the ingredient is optional or not.

## License

This package is licensed under the [MIT License](https://choosealicense.com/licenses/mit/).


## Disclaimer
This package is not affiliated with Jow.fr in any way. The data is retrieved using publicly available APIs, and the package does not guarantee the accuracy of the information provided. Please use this package at your own risk.
lively-tk 1.1.0
A highly configurable toolkit for commanding robots in mixed modalities with liveliness.
License: MIT
Requires Python: >=3.7

<h1 align="center">
  <a href="https://wisc-hci.github.io/lively/"><img src="https://user-images.githubusercontent.com/5341396/218564862-aeac4437-873f-48cb-b503-15375250f75b.png" alt="Lively"></a>
</h1>

<p align="center">
   <a href="https://badge.fury.io/py/lively_tk"><img src="https://badge.fury.io/py/lively_tk.svg" alt="PyPI version" height="18"></a>
   <a href="https://badge.fury.io/js/@people_and_robots%2Flively"><img src="https://badge.fury.io/js/@people_and_robots%2Flively.svg" alt="npm version" height="18"></a>
    <br>
    <a href= "https://wisc-hci.github.io/lively/"><img alt="docs: ready" src="https://img.shields.io/badge/docs-ready-success.svg?logoHeight=10"></a>
</p>

# Lively v1.1.0

You can find the documentation for lively [here](https://wisc-hci.github.io/lively/)

# LivelyStudio

For an interface to configure Lively, see [LivelyStudio](https://github.com/Wisc-HCI/LivelyStudio).

## About

Lively Package

The Lively framework provides a highly configurable toolkit for commanding robots in mixed modalities while incorporating liveliness motions. It is adapted from [RelaxedIK](https://github.com/uwgraphics/relaxed_ik_core) framework, and compatible with Python and Javascript/Node.

To configure a robot, the easiest method is to use the LivelyStudio interface in the [LivelyStudio](https://github.com/Wisc-HCI/LivelyStudio) repository, which is a system for configuring and programming the robot visually.

## Documentation

Documentation is provided on our [github pages site](https://wisc-hci.github.io/lively/). It provides an API overview and online tutorials.

## Getting Help

Please feel free to post in our [Github Discussions](https://github.com/Wisc-HCI/lively/discussions), or if you found an issue, report it [here](https://github.com/Wisc-HCI/lively/issues). 


## Contributing


**Python Instructions**

To build, download and `cd` to this directory. Then run:

```bash

# Install Maturin
pip3 install maturin

# If you just want to install locally or develop:
maturin develop
```

## Deploy to GitHub Page

To deploy, run `yarn deploy` from the `main` branch in the `docs` directory. We will need to redeploy every time we make new changes to the documentataion.

**Javascript Instructions**

To build, download and `cd` to this directory. Then run:

```bash
# Build the javascript bundle
wasm-pack build --scope people_and_robots --target bundler -- --features jsbindings

# Pack
wasm-pack pack

# Publish
wasm-pack publish --access=public
```


## References
[^1]:Rakita, Daniel, Bilge Mutlu, and Michael Gleicher. "PROXIMA: An Approach for Time or Accuracy Budgeted Collision Proximity Queries." Proceedings of Robotics: Science and Systems (RSS). 2022. http://www.roboticsproceedings.org/rss18/p043.pdf
auto-sktime 0.1.0
Automatic creation of time series forecasts, regression and classification
License: MIT
Requires Python: >=3.8

# auto-sktime

Automatic creation of time series forecasts, regression and classification.

## Installation

For trouble shooting and detailed installation instructions, see the documentation.

```
Operating system: Linux
Python version: Python 3.8, 3.9, and 3.10 (only 64 bit)
Package managers: pip
```

### pip

auto-sktime is available in pip. You can see all available wheels [here](https://test.pypi.org/project/auto-sktime).

```bash
pip install auto-sktime
```

or, with maximum dependencies,

```bash
pip install auto-sktime[all_extras]
```

## Remaining Useful Life Predictions (AutoRUL)

This section describes how to reproduce the results in the _AutoRUL_ paper. First, checkout the exact code that was used
to create the results. Therefore, you can use the tag [v0.1.0](https://github.com/Ennosigaeon/auto-sktime/tree/v0.1.0)

```bash
git checkout tags/v0.1.0 -b autorul
```

Next, switch to the `scripts` directory and use

```bash
python remaining_useful_lifetime.py <BENCHMARK>
```

to run a single benchmark data set. To view the available benchmarks and all configuration parameters run

```bash
python remaining_useful_lifetime.py --help
```

### Reproducing results

You can use the following commands to recreate the reported baseline results in the experiments of the paper.

```bash
python remaining_useful_lifetime.py <BENCHMARK> --runcount_limit 1 --timeout 3600 --multi_fidelity False --include baseline_lstm
python remaining_useful_lifetime.py <BENCHMARK> --runcount_limit 1 --timeout 3600 --multi_fidelity False --include baseline_cnn
python remaining_useful_lifetime.py <BENCHMARK> --runcount_limit 1 --timeout 3600 --multi_fidelity False --include baseline_transformer
python remaining_useful_lifetime.py <BENCHMARK> --runcount_limit 1 --timeout 7200 --multi_fidelity False --include baseline_rf
python remaining_useful_lifetime.py <BENCHMARK> --runcount_limit 200 --timeout 7200 --multi_fidelity False --ensemble_size 1 --include baseline_svm
```

with `<BENCHMARK>` being one of `{cmapss,cmapss_1,cmapss_2,cmapss_3,cmapss_4,femto_bearing,filtration,phm08,phme20}`.
For the _AutoRUL_ evaluation only the benchmark is provided and all remaining default configurations are used.

```bash
python remaining_useful_lifetime.py <BENCHMARK>
```

To reproduce the results from AutoCoevoRUL, checkout the [repository](https://github.com/Ennosigaeon/AutoCoevoRUL) from
Github and use the [autocoevorul.py](scripts/autocoevorul.py) file to either export the data sets or import the results.

## Note

This project has been set up using PyScaffold 4.2.1. For details and usage
information on PyScaffold see https://pyscaffold.org/.

## Building

To create a new release of `auto-sktime` you will have to install `build` and `twine`

```bash
pip install build twine
python -m build

```
panorama-sidekick 0.1.3
A CLI application to get helpful information from a Palo Alto Panorama device. 
License: MIT
Requires Python: >=3.8,<4.0

<h2 align="center">A Palo Alto Panorama Sidekick</h2>

[![CI](https://github.com/johnjtorres/panorama-sidekick/actions/workflows/main.yml/badge.svg)](https://github.com/johnjtorres/panorama-sidekick/actions/workflows/main.yml)

## Features

- Print a list of managed device groups.

## TODO

- Print a list of managed firewalls.
- Print helpful information about firewalls (version, vsys, IP, uptime, etc.).
- Find security rules based on certain criteria and print in JSON.
- Run an operational command on Panorama or a firewall.