semvec/pypi-packages huggingface dataset:
milanesas 0.1.33
A group of tools to do exploratory analysis.
Requires Python: >=3.9,<4.0
Keywords: packaging,data_science,pandas

![Milas](https://raw.githubusercontent.com/TorrezMN/EDA_Helper/main/docs/img/mila.png)
<a href="https://www.freepik.es/foto-gratis/filete-frito-papas-fritas-ensalada-generado-ia_41280531.htm#query=milanesa&position=7&from_view=search&track=sph&uuid=3ea07f79-5848-48b5-b78f-9f0c1f572f52">Imagen de vecstock</a> en Freepik

# Milanesas / EDA helper 
---

Tired of wrangling data wrangling during EDA?  Unleash the Python data analysis beast within with milanesas, your new secret weapon for effortless Exploratory Data Analysis!

Say goodbye to repetitive coding and hello to intuitive automation: visualize distributions, uncover missing values, identify relationships, and generate comprehensive reports – all with a few lines of code.

Stop drowning in data, start diving for insights with milanesas!

P.S. It's so user-friendly, even pandas ninjas will be impressed.


## Features

- Functions to draw simple graphs.
- Functions for drawing orizontal and vertical comparative graphs.
- Functions for transforming percentage values.
- Functions for counting unique values.



## Installation

Install my-project with pipy.

```bash
pip install milanesas
```
    
## Usage/Examples

```python
import pandas as pd

import milanesas.eda_helper as eh #Importing the library.


# Create a test dataframe.
df = pd.DataFrame({'Category': ['A', 'B', 'F', 'C'], 'count': [4, 2, 3, 1]})


# Make a horizontal barchart.
eh.make_custom_horizontal_bar(
    df, 
    "col", 
    "Custom horizontal bar chart.", 
    "Count", 
    "Category", 
    False)
```

This simple code will show the following chart.

![Barchart demo.](https://raw.githubusercontent.com/TorrezMN/EDA_Helper/main/docs/img/output_2_1.png)


## License

[MIT](https://github.com/TorrezMN/EDA_Helper/blob/main/docs/img/output_2_1.png)
poetry-experiment 0.1.1
Testing poetry, Correct Python Packaging, installing and running as cli
Requires Python: >=3,<4

### This repo is just an experiment to test out poetry

Key things:
easyily turn program.py to `poetryexp` runnable program that can be installed with `pip install poetry-experiment`
or other available pypi package name

In a new project folder (package-root):
1. run `git init` or `git clone` beforehand
2. create README.md if missing
3. propper py package
    - put program.py in package folder poetry-experiment/
    - create __init__.py (import program) inside, in poetry-experiment/
4. poetry init
5. add script to toml
6. poetry build
7. poetry config pypi-token.pypi your-api-token
8. poetry publish


```
package-root/
	README.md
	poetry.toml (fix name)
	poetry-experiment/
		__init__.py #import program inside
		program.py 
	.git/
```


To accomplish this, you can follow these steps:

1. **Create a `pyproject.toml` file**: Make sure you have a `pyproject.toml` file in your project directory. Poetry uses this file to manage project dependencies and settings.

2. **Add metadata to `pyproject.toml`**: You'll need to define metadata such as the project name, version, and description in the `pyproject.toml` file.

3. **Define entry points**: In your `pyproject.toml`, you can define entry points for your command-line interface (CLI) using the `[tool.poetry.scripts]` section. This will allow users to run your program using a specified name.

4. **Write your `program.py`**: Write the Python script that you want to publish.

5. **Build your package**: Use Poetry to build your package. This will generate a distributable package that can be uploaded to PyPI.

6. **Publish to PyPI**: Once your package is built, you can publish it to PyPI using Poetry's `publish` command.

Here's a step-by-step guide:

1. Create a `pyproject.toml` file if you don't already have one. It should look something like this:

```toml
[tool.poetry]
name = "poetry_experiment"
version = "1.0.0"
description = "A description of your program"
authors = ["Your Name <your.email@example.com>"]

[tool.poetry.dependencies]
python = "^3.8"

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"

[tool.poetry.scripts]
poetryexp = "program:main"
```

2. Write your `program.py`. Make sure it has a function named `main`, which will be called when users run your program.

```python
def main():
    print("Hello, world!")
```

3. Once you've written your script and configured your `pyproject.toml`, you can use Poetry to build your package:

```bash
poetry build
```

4. After the build is successful, you can publish your package to PyPI:

```bash
poetry publish --build
```

5. After publishing, users can install your package using pip:

```bash
pip install poetry_experiment
```

6. Once installed, users can run your program using the specified entry point:

```bash
poetryexp
```

This will execute the `main()` function defined in your `program.py`.
yaqd-rpi-gpio 2024.2.0
yaq daemons for control of Rasperry Pi GPIO
Requires Python: >=3.7

# yaqd-rpi-gpio

[![PyPI](https://img.shields.io/pypi/v/yaqd-rpi-gpio)](https://pypi.org/project/yaqd-rpi-gpio)
[![yaq](https://img.shields.io/badge/framework-yaq-orange)](https://yaq.fyi/)
[![black](https://img.shields.io/badge/code--style-black-black)](https://black.readthedocs.io/)
[![ver](https://img.shields.io/badge/calver-YYYY.0M.MICRO-blue)](https://calver.org/)
[![log](https://img.shields.io/badge/change-log-informational)](https://gitlab.com/yaq/yaqd-rpi-gpio/-/blob/main/CHANGELOG.md)

yaq interface to Raspberry Pi GPIO pins

This package contains the following daemon(s):

- [gpio-digital-output](https://yaq.fyi/daemons/gpio-digital-output)
- [gpio-digital-sensor](https://yaq.fyi/daemons/gpio-digital-sensor)