semvec/pypi-packages huggingface dataset:
GifPlotter 0.1.2
A library to create and arrange plots and generate GIFs.
Requires Python: >=3.0


[![Downloads](https://static.pepy.tech/badge/GifPlotter)](https://pepy.tech/project/GifPlotter)
# FlexiPlotter

`FlexiPlotter` is a flexible data visualization library that allows you to create various types of plots (line, scatter, bar) from a pandas DataFrame based on a structured payload. It can handle multiple subplots arranged in a custom layout and can even generate animated GIFs from the plot data over time.

## Features

- Create flexible layouts of subplots for visualizing different types of charts.
- Supports line, scatter, and bar plots.
- Automatically configures axis labels, titles, and colors from payload data.
- Generate animated GIFs showing data evolution over time.
- Save the resulting figure or GIF to disk.

## Installation

### Prerequisites

Make sure you have the following installed:

- Python 3.x
- Pandas (`pip install pandas`)
- NumPy (`pip install numpy`)
- Matplotlib (`pip install matplotlib`)
- ImageIO (`pip install imageio`)

### Clone the repository

```bash
git clone https://github.com/yourusername/flexi-plotter.git
cd flexi-plotter
culebratester-client 2.0.73
CulebraTester
Keywords: Swagger, CulebraTester

    ## Snaky Android Test --- If you want to be able to try out the API using the **Execute** or **TRY** button from this page - an android device should be connected using &#x60;adb&#x60; - the server should have been started using &#x60;./culebratester2 start-server&#x60;  then you will be able to invoke the API and see the responses.   # noqa: E501
primordial-wrapper 1.2.0
Wrapper for Primordial API
Requires Python: >=3.6

# 🌌 Primordial API Wrapper

Primordial API Wrapper is a Python package that provides a sleek and powerful interface to interact with the Primordial API. This wrapper makes API calls a breeze and handles responses like a pro! 🚀

## 🛠️ Installation

Get the Primordial API Wrapper up and running with a simple pip command:

```bash
pip install primordial-wrapper
```

## 🚀 Usage

To harness the power of the Primordial API Wrapper, import the `PrimordialAPI` class and initialize it with your API key:

```python
from primordial_wrapper import PrimordialAPI

api = PrimordialAPI(api_key="your_api_key")
```

### 🧰 Available Methods

The wrapper comes packed with these awesome methods:

1. 🤖 `generate_ai_response(prompt: str)`: Get an AI-generated response
2. 🎨 `generate_ai_image(prompt: str)`: Create an AI-generated image
3. 📥 `download_media(url: str)`: Download media from a URL
4. 📋 `create_pastebin(content: str)`: Create a new pastebin entry
5. 🔍 `get_pastebin(pastebin_id: str)`: Fetch a pastebin entry
6. ☀️ `get_weather(city: str)`: Get weather info for a city
7. 🗣️ `text_to_speech(text: str, lang: str = 'en')`: Convert text to speech
8. 📱 `generate_qr(url: str)`: Generate a QR code
9. 🔗 `shorten_url(url: str)`: Shorten a URL
10. 🚧 `bypass_link(url: str)`: Bypass shortened links
11. 📊 `get_bf_stock()`: Get Blox Fruits stock info
12. 🕷️ `scrape_web(url: str)`: Scrape a website
13. 📤 `upload_image(image_path: str)`: Upload an image
14. 🖼️ `get_image(image_id: str)`: Retrieve an image

### 💡 Example

Here's a quick example to get you started:

```python
from primordial_wrapper import PrimordialAPI
api = PrimordialAPI(api_key="your_api_key_here")
response = api.generate_ai_response("Tell me a joke about programming")
print(response)
```

## 👨‍💻 Development

Set up your dev environment in a flash:

1. Clone the repo:
   ```bash
   git clone https://github.com/KirbyHacks/primordial-wrapper.git
   cd primordial-wrapper
   ```

2. Install in editable mode with dev dependencies:
   ```bash
   pip install -e .[dev]
   ```

3. Run those tests:
   ```bash
   pytest
   ```

## 🤝 Contributing

We love contributions! Here's how you can help:

1. 🍴 Fork the repository
2. 🌿 Create a new branch for your feature or bug fix
3. 🛠️ Make your changes and write tests if applicable
4. ✅ Run the tests to ensure everything's working
5. 📤 Submit a pull request with a clear description of your changes

## 📜 License

This project is licensed under the MIT License. Check out the [LICENSE](LICENSE) file for all the legal stuff.

## 📬 Contact

Got questions? We've got answers!

- 📧 Email: rlow@kys.gay
- 💬 Discord: rlow._
- 🌐 Join our Discord server: [discord.gg/primordial-api](https://discord.gg/primordial-api)

For any other issues, feel free to open an issue on the [GitHub repository](https://github.com/KirbyHacks/primordial-wrapper).

Happy coding! 🎉
downtime-csv 1.0.5
A tool that measures the downtime from the user's perspective when restarting a web server and outputs it to a CSV file.
Requires Python: <4.0,>=3.12

# downtime-csv

This tool is used to measure how long a website is down from the user's perspective, such as when it is restarted. It continues to send HTTP requests for 5 minutes every 200ms, and outputs the start time, response time, and status of each request to standard output as CSV.

## Requirements

Python >= 3.7 

## Install

You can download and install this tool from pypi with the command below.

```shell
pip install downtime-csv
```

## Usage

You can collect data for that URL with the command below. The data is printed to standard output.

```
downtime-csv URL
```

## Example

Using the command below, you can obtain the results of accessing google.com every 200ms for 5 minutes as test.csv. Load this into Excel and analyze it.

```shell
downtime-csv google.com > test.csv
```

The first column is the start time, but it has millisecond precision, so please set it to display milliseconds in Excel as well.
Note that the output is in the order the requests finished. If you want to order by request start, sort the entire range by the value of the first column.

## Add custom header

The downtim-csv command allows you to add headers to HTTP requests using the -H option, similar to curl.

```shell
downtime-csv https://example.com -H "Authorization: Bearer token" -H "Custom-Header: Value"
```

The headers given by default are as follows:

```
User-Agent: aiohttp/<version> python/<version>
Accept-Encoding: gzip, deflate
Accept: */*
```

These headers are what aiohttp adds to requests by default. If you add a custom header, it will not override these default headers, but if you specify a header with the same name, the custom header will take precedence.
omegaup 2.0.18
Utilities for interacting with omegaUp
Requires Python: >=3.6

# omegaUp

Library for interacting with omegaUp.

## `omegaup.validator.validatortest`

Allows an input validator to be modeled as a standard unit test.

To use, write your validator as if it were a normal
[unittest.TestCase](https://docs.python.org/3/library/unittest.html#unittest.TestCase):

```python
import logging
import unittest
import sys

from omegaup.validator import validatortest


class MyTest(unittest.TestCase):
  def test_foo(self):
    contestant_output = sys.stdin
    case_name = sys.argv[1]
    with open('data.in', 'r') as original_input, \
         open('data.out', 'r') as original_output:
        logging.info('This will be printed to stderr')

        self.assertAlmostEqual(
            float(contestant_output.readline().strip()),
            float(original_output.readline().strip()))


if __name__ == '__main__':
    validatortest.main()
```
quickprofile 0.2.0
A simple profiling library for measuring execution time.
Requires Python: >=3.6

# QuickProfile

A simple profiling library to measure execution time for functions, code blocks, and specific lines of code.

## Features

- **Function Profiling**: Decorate functions to log their execution time.
- **Block Profiling**: Use a context manager to profile a block of code.
- **Line Profiling**: Measure the execution time of specific lines of code.

## Installation

You can install QuickProfile directly from the source code or via PyPI:

### From PyPI

To install the latest version from PyPI, use:

```bash
pip install quickprofile

```

## Usage
**Profiling a Function:**
Use the `@profile_time` decorator to measure the execution time of a function:

```bash
from quickprofile import profile_time
import time

@profile_time
def my_function():
    # Simulate a time-consuming task
    time.sleep(1)

my_function()  # Logs the execution time

```

**Profiling a Code Block:**
Use the `profile_block` context manager to measure the execution time of a block of code:
```bash
from quickprofile import profile_block
import time

with profile_block():
    # Simulate a time-consuming task
    time.sleep(2)  # This will be logged

```

**Profiling Specific Lines:**
Use the `profile_line` context manager to measure the execution time of specific lines:
```bash
from quickprofile import profile_line

with profile_line():
    total = sum(i for i in range(1000000))  # This line's execution time will be logged


```