semvec/pypi-packages huggingface dataset:
google_takeout_email 0.0.5
Contains a reader for mailbox files, MailboxReader, and utility functions for parsing email addresses.

# Google Takeout Email

Contains a reader for mailbox files, MailboxReader, and utility functions for parsing
email addresses. Read from the mailbox.

The MailboxReader class functions as a context manager that opens a mailbox file. The
messages property returns an iterator of email.message objects.

The strip_address function returns the first actual email address contained in a string
and the parse_address_list returns a list of addresses in a comma separated list.
reeco 0.0.2.post1707846505
Python library with utility functions for the REECO Framework.

---
component-id: reeco-python-library
name: "REECO Python Library"
description: "The Python library of the REECO framework."
project: reeco-framework
type: SoftwareLibrary
credits:
- Enrico Daga <http://github.com/enridaga>
resource: https://pypi.org/project/reeco/

---
# REECO Python Library

Python library for the REECO framework.


## Schema

TBD

### Developers
Editing happens in this [Spreadsheet](https://docs.google.com/spreadsheets/d/1PZ11esT6COK7Y0mMZEHifY9hQeREbNSlRbC6dkYtjNg/edit?usp=sharing).

The reference documentation is in folder `schema/`.

To regenerate the `yaml` files in the schema directory:
```bash
python3 generate-schema.py && git add schema/ && git commit -m "Update" && git push
```

## Validator

TBD
booyah 0.1.2
A joyful python web framework
Requires Python: >=3.6

![alt TestRunner](https://github.com/marceloribeiro/booyah/actions/workflows/tests_runner.yml/badge.svg)

## Booyah Framework

Booyah is a MVC web framework written in Python that aims to be easy to use while setting up projects quickly. It follows the convention over configuration paradigm introduced by Ruby on Rails.

### Documentation

The following links detail the process of installing and setting up your first project.

[1. Installation](https://github.com/marceloribeiro/booyah/blob/main/docs/install.md)

[2. Getting Started](https://github.com/marceloribeiro/booyah/blob/main/docs/getting-started.md)

[3. The Booyah Console](https://github.com/marceloribeiro/booyah/blob/main/docs/console.md)

[4. The Booyah ORM](https://github.com/marceloribeiro/booyah/blob/main/docs/booyah-orm.md)

[5. The MVC architecture](https://github.com/marceloribeiro/booyah/blob/main/docs/booyah-mvc.md)

[6. Database Operations](https://github.com/marceloribeiro/booyah/blob/main/docs/database-operations.md)

[7. Generators](https://github.com/marceloribeiro/booyah/blob/main/docs/generators.md)

[8. Jobs](https://github.com/marceloribeiro/booyah/blob/main/docs/jobs.md)

### Collaborating

You can collaborate with Booyah by forking the repo and submitting a pull request. We are very early stage so any help is welcome. We do try to follow the Rails way in Python though, so please keep that in mind.

You can visit the issues tab in github for some ideas.
pydiffchecker 0.1.5
Wrappers for git diff
Requires Python: >=3.8

# PyDiffChecker

**Wrappers for git diff**

## LineShiftChecker

This tool provides an API for checking shifted but not modified lines in changed files of a Git diff. The tool will collect the lines where the content did not change into dict-like objects with source->destination line number mapping per changed file. File renames are detected as well.

The behavior is very similar to unified diff on Github or output of [git-diffn](https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles/blob/master/useful_scripts/git-diffn.sh). There are green (added), red (remove) and white (unmodified) lines. The return value of the API will contain these "white" lines with the source/destination line number for the whole file.

### Example

Let's assume this is the output of git-diffn:
```diff
diff --git a/pydiffchecker/helper.py b/pydiffchecker/helper.py
index f9d4e08..6a6c214 100644
--- a/pydiffchecker/helper.py
+++ b/pydiffchecker/helper.py
@@ -3,14 +3,13 @@ from typing import Iterator
    3,   3:
    4,   4:
    5,   5: def subprocess_readlines(cmd, cwd=None) -> Iterator[str]:
-   6     :-    process = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE)
+        6:+    process = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE, text=True)
    7,   7:
    8,   8:     for line in process.stdout:
-   9     :-        line = line.decode().rstrip(r'\n')
-  10     :-
+        9:+        line = line.rstrip('\n')
   11,  10:         yield line
   12,  11:
-  13     :-    process.wait()
+       12:+    process.communicate()
   14,  13:
   15,  14:     if process.returncode != 0:
   16,  15:         raise subprocess.CalledProcessError(process.returncode, cmd)
```

Here the lines 3-5, 7-8, 11-12 and 14-16 are unmodified, but some of them are shifted. Of course, "white" lines that are not shown above are also unmodified. The API fill return the following data (visualized for simplicity, see Usage how to access the data programatically):
```
* pydiffchecker/helper.py->pydiffchecker/helper.py:
    1->1
    2->2
    3->3
    4->4
    5->5
    6->None
    7->7
    8->8
    9->None
    10->None
    11->10
    12->11
    13->None
    14->13
    15->14
    16->15
```

### Usage
```python
from pydiffchecker.line_shift_checker import LineShiftChecker

line_shift_checker = LineShiftChecker('HEAD~', 'HEAD')
all_shifted_lines = line_shift_checker.get_all_shifted_lines()

# Iterate through shifted lines
for src_path, shifted_lines in all_shifted_lines.items():
    renamed_to = shifted_lines.dst_path
    for src_line_index, dst_line_index in shifted_lines:
        print(f'{src_line_index}->{dst_line_index}')

# Find if lines are shifted (and to where) in a file
if 'your/file.cpp' in all_shifted_lines:
    shifted_lines = all_shifted_lines['your/file.cpp']
    renamed_to = shifted_lines.dst_path
    if 12 in shifted_lines:
        # line 12 was shifted, to where?
        shifted_to = shifted_lines[12]
```
SimorghOCR 0.1.0
A simple OCR application using CustomTkinter, Tesseract, and EasyOCR.
Requires Python: >=3.8

# SimorghOCR

SimorghOCR is an optical character recognition (OCR) application specialized in Persian language.<br>

SimorghOCRは、ペルシア語に特化した光学文字認識（OCR）アプリケーションです。

## Features
- Tesseract OCR and EasyOCR<br>
- Capable of processing both image files (JPEG, PNG, BMP, TIFF, etc.) and PDF documents<br>
- User-friendly GUI built with CustomTkinter<br>
- Language support focused on Persian (Farsi)<br>
- Direct conversion of extracted text to Microsoft Word (DOCX) format for easy editing and formatting<br>
<br>
- Tesseract OCRおよびEasyOCR<br>
- 画像ファイル（JPEG、PNG、BMP、TIFFなど）とPDFドキュメントの両方を処理可能<br>
- CustomTkinterで構築されたユーザーフレンドリーなGUI<br>
- ペルシア語（ファルシ）に焦点を当てた言語サポート<br>
- 抽出されたテキストを簡単な編集とフォーマットのためにMicrosoft Word（DOCX）形式に直接変換<br>

## Inastall
Before installing SimorghOCR, it is necessary to have Tesseract OCR pre-installed, which is one of the main OCR engines used in the application. Please download and install Tesseract OCR from [here](https://github.com/tesseract-ocr/tesseract).<br>
<br>
Once Tesseract OCR is installed, follow these steps to install SimorghOCR:<br>
<br>
SimorghOCRをインストールする前に、アプリケーションで使用される主要なOCRエンジンの1つであるTesseract OCRの事前インストールされているが必要です。[こちら](https://github.com/tesseract-ocr/tesseract)からTesseract OCRをダウンロードしてインストールしてください。<br>
<br>
Tesseract OCRがインストールされたら、以下の手順でSimorghOCRをインストールしてください：


```bash
# Clone the repository
# リポジトリをクローン
git clone https://github.com/KidoIshi/SimorghOCR.git

# Go to clone directory
# クローンしたディレクトリに移動
cd SimorghOCR

# Install necessary Python packages
# 必要なPythonパッケージをインストール
pip install -r requirements.txt
# SimorghOCR
```
Select the OCR engine<br>
Upload an image or PDF file<br>
Upon completion of OCR processing, the extracted text will be displayed in the application window and can be downloaded as a Word document<br>
<br>
OCRエンジンを選びます<br>
画像またはPDFファイルをアップロードします<br>
OCR処理が完了すると、抽出されたテキストがアプリケーションウィンドウに表示され、Wordドキュメントとしてダウンロードできます
## Licence
GNU GPL version 3
ai-powered-spark-tune-agent 0.1.0
N/A

# AI-Powered Spark Tune Agent
- [AI-Powered Spark Tune Agent](#ai-powered-spark-tune-agent)
  - [Overview](#overview)
  - [Architecture](#architecture)
  - [Requirements](#requirements)
  - [Configuration](#configuration)
    - [Setting up the environment](#setting-up-the-environment)
      - [AWS S3 Bucket](#aws-s3-bucket)
      - [Azure Blob Storage](#azure-blob-storage)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Logging](#logging)
  - [Process Audit](#process-audit)
  - [License](#license)

## Overview
AI-Powered Spark Tune Agent aims to extract metrics from Spark processes using the SparkUI API. The agent allows you to upload information to an AWS S3 bucket or Azure Blob Storage container for later analysis. Allows you to obtain metrics from Cloudera, Databricks, EMR, etc. through History Server.

## Architecture
![architecture](./docs/images/architecture.png)

## Requirements
- **Python version**: 3.9.x
- **Spark version**: 2.4.x to 3.5.x
- **Operating system**: Linux, MacOS, Windows

## Configuration

### Setting up the environment

#### AWS S3 Bucket


#### Azure Blob Storage

## Installation
```bash
git clone git@github.com:angelmaroco/ai-powered-spark-tune-agent.git

cd ai-powered-spark-tune-agent

make environment

make install
```


## Usage
```bash
ai_powered_spark_tune_agent
```

## Logging

## Process Audit

## License
View [license](./LICENSE)
objectlist 1.0.2
Use methods and method chaining on lists of objects.
Requires Python: >=3.9
Keywords: object,list,method,chaining

# ObjectList

Use methods and method chaining on lists of objects.
Also allowing clean syntax for parallel processing.


## Examples

As an example we define an ObjectList of Path objects.

```python
from objectlist import ObjectList

from pathlib import Path
path_list = [Path('foo/a'), Path('foo/bar/b'), Path('foo/bar/c')]
path_objectlist = ObjectList(path_list)
```

### Getting object attributes and properties
If we would like to get the parents of all paths 

```plaintext
[WindowsPath('foo'), WindowsPath('foo/bar'), WindowsPath('foo/bar')]
```
then using a normal list it is necessary to use a loop:

```python
[p.parent for p in path_list]
```

but using an ObjectList this can be done by
```python
path_objectlist.parent
```

ObjectLists can be easily converted to strings:
```python
path_objectlist.parent.str
```

```plaintext
['foo', 'foo\\bar', 'foo\\bar']
```

### Using object methods and passing arguments
Object methods can also be used

```python
path_objectlist.with_suffix('.txt')
```
```plaintext
[WindowsPath('foo/a.txt'), WindowsPath('foo/bar/b.txt'), WindowsPath('foo/bar/c.txt')]
```

### Using parallel processing

Parallel processing can be activated on existing ObjectLists by using .parallel 

```python
path_objectlist.parallel.with_suffix('.txt')
```

Alternatively parallel processing can be activated when the ObjectList is defined: 

```python
path_objectlist = ObjectList(path_list, 
                             use_parallel_processing=True, 
                             number_of_cores=None,
                             parallel_processing_kwargs=dict(verbose=0), 
                             return_none_if_all_none=True)
```
lammpstools 0.0.20
package to analyse LAMMPS data
Requires Python: >=3.3

# lammpstools

`lammpstools` is a small python package which can be used to analyse LAMMPS data.

For documentation on the functions it contains, install the package:

`pip install lammpstools`

open a python interpretter (by typing `python` in your shell)

and then in the python interpreter write

`import lammpstools`
`print(lammpstools.__doc__)`


which will give a list of all functions. To access documentation of a specific function,
follow a similar route. E.g. for the `DumpLoader` class write

`print(lammpstools.DumpLoader.__doc__)`

which will tell you (probably) all you need to know.