semvec/pypi-packages huggingface dataset:
paeio 0.1
Utilities library for read/write operations and general data cleaning routines
Requires Python: >=3.7.1

# Utilities library for read/write operations and general data cleaning routines

## Intro

This is a versatile Python library aimed at facilitating read/write operations and providing general data cleaning routines. It consists of two main topics:

- IN/OUT operations (io)
- Data cleaning & preprocessing

## Project Structure

```plaintext
paeio
├── README.md
├── docs            -> Folder containing files for building the library.
├── paeio              -> Folder containing the library's code
│   ├── data_cleaning         -> Module for data cleaning.
│   └── io                    -> Module for I/O operations.
├── dist             -> Folder containing files for package distribution
│   ├── __init__.py
│   └── paeio-0.X-py3-none-any.whl               -> Installation with pip will be done from here.
├── tests            -> Folder containing test files for validating the package's implementations.
├── requirements.txt          -> Required packages to run the project
└── pyproject.toml                  -> Setup file for generating the package installer.
```

## Daily Use

### Library Installation

For development, it's highly recommended to create a separate environment. To do this, run:

```bash
$ conda create -n paeio python==3.X #(X >= 7.1)
```

For installation via pip, run the following command:

```bash
$ pip3 install paeio
```

### IO Usage

For development, you only need to run the following command:

```bash
$ az login
```

Follow the command's suggested steps, and once you complete login, you are free to go.

### Credential Connections

- **.env**: Having a .env file on the project root containing your credentials.
- **az login**: Login with your user.
- **Production**: Using service principal credentials, very similar to .env connection. You'll need the following variables defined:

```plaintext
$ AZURE_CLIENT_ID
$ AZURE_CLIENT_SECRET
$ AZURE_TENANT_ID
```

## Contributing to the Project

### Git Clone

```bash
$ git clone https://github.com/jotap123/paeio.git
```

### Branch Creation

- **Name**: module_affected / fewwordsummaryofthechanges
  - Example: io/new_file_reader

### Merge Request Creation

- **Title**: Summarize in English
- **Commit Messages**: In English
pkg-packages 0.269.0
🤖 This is a official repository for DocuPy, a Python package that allows you to create beautiful documentation for your Python projects.
Requires Python: >=3.6

# 🤖 Beep boop
This is a package automaticly maintenaned by the [Github Actions](https://github.com/actions) that runs on every push to the [main branch](https://doc.github.com/en/actions/reference/workflow-syntax-for-github-actions#main).
# 👁️ Automatically moderated:
- [x] The Github Actions will automatically moderate all PRs that are opened or merged.
statementskeleton 1.3
A package for formatting financial statements in the console. Designed for PyActy.
Requires Python: >3.11

# StatementSkeleton
StatementSkeleton is a package for formatting your output to appear as a financial statement. This package was designed
to be used with PyActy, but it can be used by itself.

## Classes

### Skeleton
This is the main class and all other elements are nested inside of it. You can create a Skeleton like so:
```py
from statementskeleton import Skeleton

skel: Skeleton = Skeleton()
```
The class takes five arguments:
1. The financial statement you wish to print.
2. The name of the company the financial statement belongs to.
3. The name of the financial statement.
4. The date of the financial statement (MM/DD/YYYY format).
5. If the numbers show decimals or not.

The financial statement must be specifically formatted for this to work. An example is as follows:
```py
financial_statement: dict[str:dict[str:dict[str:str | float]]] = {
    "Assets": {
        "Cash": {
            "d/c": "debit",
            "bal": 400.0,
            "term": "current"
        },

        "Accounts Receivable": {
            "d/c": "debit",
            "bal": 1_000.0,
            "term": "current"
        }
    },

    "Liabilities": {
        "Accounts Payable": {
            "d/c": "credit",
            "bal": 200.0,
            "term": "current"
        }
    },

    "Stockholders' Equity": {
        "Common Stock": {
            "d/c": "credit",
            "bal": 200
        },

        "Retained Earnings": {
            "d/c": "credit",
            "bal": 1_000
        }
    }
}
```
If it isn't formatted like this, it won't work.

Using all the information above, we can complete the creation of our Skeleton object:
```py
from statementskeleton import Skeleton

skel: Skeleton = Skeleton(financial_statement, "Company Name", "Financial Statement", "12/31/2024", decimals=False)

# This is the method to actually print the financial statement.
skel.print_output()
```

### Account
This class adds an account to the `Skeleton` that contains a name and a balance. You can add it to the `Skeleton` like so:
```py
from statementskeleton import Skeleton, Account

skel: Skeleton = Skeleton(financial_statement, "Company Name", "Financial Statement", "12/31/2024", decimals=False)

skel.implement(Account(skel, "Cash", 400), "cash_account")
```
The `implement()` method has two arguments. The first is the actual element you're implementing, and the second is a 
unique ID for that element so that it can be modified later if needed.

When implementing an element, the first argument of the object must be the `Skeleton` object you are implementing the
element to. This applies to EVERY element.

It's recommended to make a new class that inherits `Skeleton` and override the `define_header()` and `define_body()` 
methods, but this will be covered in a later section.

### Divider

### Element

### Header

### Spacer

### Subtotal

### Title

### Total