semvec/pypi-packages huggingface dataset:
devrouw 0.1.1
A Python library for data analysis and visualization
Requires Python: >=3.6

<h1 align=center>DeVrouw <img src="https://github.com/AitSad/Static/blob/main/DeVrouw/woman%20waving.gif" height=35></h1>

DeVrouw is a dutch word reffering to "woman", not after the woman meme but to celeberate upcoming birthdate of mathematician Sophe Germain.  The library is useful for visualization and data analysis for beginners without using MatPlotlib and pandas together to write hectic scripts. Did you know? DeVrouw was entirely created by an AI system, and not even a single line, including this was written independently and copied from source! 

### Usage

```python
import devrouw.visualization as viz
import devrouw.analysis as ana

# Load data
data = ana.load_data('data.csv')

# Analyze data
mean = ana.calculate_mean(data)
median = ana.calculate_median(data)
mode = ana.calculate_mode(data)

# Visualize data
viz.plot_histogram(data)
viz.plot_boxplot(data)

# Print analysis results
print(f"Mean: {mean}")
print(f"Median: {median}")
print(f"Mode: {mode}")
```
screenrun 0.1.2
Simple process management. Keep a process running in a screen session forever.

# ScreenRun

ScreenRun is a simple process management tool that allows you to keep a process running forever just by adding a single cron job. It utilizes Screen sessions to manage and monitor your processes, making it easy to start, stop, and restart them.

# Installation

To install ScreenRun, run the following command:

```bash
pip install screenrun

```

# Usage

You can use ScreenRun via the command line or in Python scripts.

## Command Line

```bash
# Start a new Screen session with the given name and command
> screenrun execute --name nap sleep 60

# List all running Screen sessions
> screenrun list
nap

# Kill a running Screen session by its name
> screenrun kill --name nap

# Keep a command running indefinitely using the persist option
> screenrun persist --name nap sleep 60

# Start a command in a Screen session if it's not already running
> screenrun persist --name nap sleep 60

```

## Add to cron

To ensure your command keeps running, add the following line to your cron configuration:

```bash
* * * * * screenrun cron sleep 60

```

## Python

You can also use ScreenRun in your Python scripts:

```python
from screenrun import ScreenRun

screenrun = ScreenRun()

screenrun.execute('sleep 60')

```

# Warning for macOS Users

On macOS, the default version of "Screen" is outdated. For ScreenRun to work properly, you need to install the latest GNU version of Screen. You can do this using Homebrew:

```bash
brew install screen

```

Please note that this requires [Homebrew](https://brew.sh/) to be installed on your system. If you don't have Homebrew installed, follow the [installation instructions](https://brew.sh/) before running the above command.


# License

Creative Commons Zero v1.0 Universal
dataframe-quickview 0.1.1
A simple package to extend pandas DataFrame functionality for web-based visualization
Requires Python: >=3.6

# DataFrame QuickView

**DataFrame QuickView** is a Python package that extends pandas DataFrame functionality to easily display and visualize DataFrames in a web-based environment. This package is an experiment in paired programming with GPT-4. It is built using Flask and allows users to view paginated DataFrames and interactively generate histograms based on the selected columns.

## Features

### Phase 1

- Extend pandas DataFrame with `quickview()` method
- Display paginated DataFrame in a web browser
- Create an interactive dropdown and button combination populated with DataFrame columns
- Generate histograms based on the selected column when the button is pressed

### Phase 1 Technical Overview

- Flask server: Represents the backend server running the Flask application, which serves the paginated DataFrame and processes the histogram data.
- DataFrame display: The component in the web browser that shows the paginated DataFrame.
- Column selection: The dropdown and button combination that allows users to select a column for generating the histogram.
- Histogram generation: The component responsible for creating a histogram based on the selected column.

Interactions:

- Flask server sends the paginated DataFrame to the DataFrame display.
- User selects a column in the Column selection component.
- User clicks the button in the Column selection component.
- Flask server receives the selected column and processes the histogram data.
- Histogram generation component receives the data and displays the histogram.

## Usage

1. Install the package using pip:

```
pip install dataframe-quickview
```


2. Import the package and use the `quickview()` method on a pandas DataFrame object:

```python
import pandas as pd
from dataframe_quickview import quickview

data = {'A': [1, 2, 3, 4, 5], 'B': [2, 4, 6, 8, 10], 'C': [3, 6, 9, 12, 15]}
df = pd.DataFrame(data)

df.quickview()
```

This will start the Flask server and open the browser to view the paginated DataFrame and interactive histogram.

## Contributing

We welcome contributions to this project. However, please note that all code added to the project should be written primarily by Language Models (LLMs) to maintain the experimental nature of this project.

## License

This project is licensed under the MIT License.
anfema-django-utils 1.5.0
Collection of various django related utilities
Requires Python: >=3.7
Keywords: django,utils

# anfema-django-utils

Collection of various django related utilities, helpers & small apps.

https://anfema.github.io/anfema-django-utils/

## Documentation

To build the documentation from the local sources run: 
```bash
$ pip install tox && tox -e docs
```

## Tests

To run the unittests from the local sources run: 
```bash
$ pip install tox && tox
```

## Release process

Steps required to create a new release and publish the package on PyPI: 

1. Bump `__version__` in `anfema_django_utils/__ini__.py`
2. Create a new release on GitHub with the tag `v<version>`
bricks-helper 1.2.5
A Python package for helping with databricks related work
Requires Python: >=3.8

# Introduction

A python package for enhancing the experience of interacting with databricks

## Build process

```
py -m build
```

```
py -m twine upload --repository pypi dist/* --verbose
```

### To set your API token for PyPI, you can create a $HOME/.pypirc similar to:

```
[pypi]
username = __token__
password = <PyPI token>`
```
irrp 1.0.1
irrp.py as a python module

# irrp

Basically [irrp.py](https://abyz.me.uk/rpi/pigpio/code/irrp_py.zip) but
as a python module so you can integrate it easily with your Python
program.

## Examples

### To record:
```py
import pigpio
pi = pigpio.pi()
gpio_pin = 18

# Record the IR data
import irrp
rr = irrp.RecordReplayer(pi)
print(rr.record(gpio_pin))

# optionally, save to a file:
import json
json.dump(open("data.json", "wb"))
```

### To replay:
```py
import pigpio
pi = pigpio.pi()
gpio_pin = 18

# load the recorded data
import json
data = json(load(open("data.json")))

# replay the data
import irrp
rr = irrp.RecordReplayer(pi)
rr.replay(gpio_pin, data)
```

### To record and compare data:
```py
import pigpio
pi = pigpio.pi()
gpio_pin = 18

# record data
import irrp
rr = irrp.RecordReplayer(pi)
rec = rr.record(gpio_pin)

import json
data = json(load(open("data.json")))
irrp.compare(data, rec)
```