semvec/pypi-packages huggingface dataset:
paracrine 0.2.1
A system deployment tool
Requires Python: >=3.9

Paracrine
=========
[![PyPI version](https://badge.fury.io/py/paracrine.svg)](https://badge.fury.io/py/paracrine)

Paracrine is a system deployment tool. It's based around [Mitogen](https://mitogen.networkgenomics.com/) and standard Python packages for
features (although, currently there's only the one core package). Current status is essentially,
"works for me, probably won't eat your computer", but thoughts and patches are welcomed.

It's designed towards rapid idempotent deploys i.e. a zero-changes deploy should take in the order of a small number of seconds ideally, and so can be used as your application deployment option as well as for system changes, which has the design benefit of you could use it for GitOps-style deploys. Obviously, if you do more changes, it'll take longer, but that's generally less of an issue, but it should still be faster than most other tooling options. It assumes it's got a host system to run from, which _probably_ can be anything that runs Python, but the testing for that so far has been on a Debian laptop.

It's named after [Paracrine signaling](https://en.wikipedia.org/wiki/Paracrine_signaling) "a type of cellular communication in which a cell produces a signal to induce changes in nearby cells" which feels pretty accurate for a deployment tool.

Main documentation is at https://palfrey.github.io/paracrine/

Usage
-----

1. Setup Python. Tested against 3.9+
2. `pip install paracrine`
3. Write a main file describing what you want to setup. [integration_test/main.py](https://github.com/palfrey/paracrine/blob/main/integration_test/main.py) is a reasonable example. It must call the `run` function, which takes general arguments, and list of modules to run.
4. Write an inventory file for the machines this is managing. Current setup assumes they're all the same. [integration_test/docker/inventory.yaml](https://github.com/palfrey/paracrine/blob/main/integration_test/docker/inventory.yaml) is a reasonable example file, but I suggest generating it from whatever you're using to create the servers (e.g. Terraform).
5. Write a `config.yaml`. This has a main top-level key of `environments` with keys below that for each inventory file you've got ([integration_test/config.yaml](https://github.com/palfrey/paracrine/blob/main/integration_test/config.yaml) just has one, but in most scenarios you'll have at least a dev and prod setup). What you do below that is up to you, but typically it'll be environment variables and secrets to feed into the main file.
6. Run `python -m paracrine.commands.setup <inventory file>` - this will install the minimum python bits so that everything else works.
7. Dry-run the main file (e.g. `python main.py -i ./docker/inventory.yaml`), and then add `--apply` once you're happy with the run.

Limitations
-----------
* All the servers are assumed to be Debian Linux boxes (although Debian-derivatives like Ubuntu _should_ work)
* Direct SSH access is assumed possible (Mitogen supports jump boxes, but there's no setup for that yet here) with keys, not passwords
old-doc 0.0.3
Easily create synthetic data for HTR and OCR
Requires Python: >=3.8

# old-doc

Easily create synthetic data for HTR (Handwritten Text Recognition) and OCR (Optical Character Recognition).

## Description

old-doc is a Python package designed to generate synthetic data for training and testing HTR and OCR models. This tool streamlines the process of creating diverse datasets for improving text recognition systems, allowing users to generate custom manuscript-like pages with various text styles, layouts, and effects.

## Installation

You can install old-doc using pip:

```bash
pip install old-doc
```

Note: old-doc requires Python 3.8 or later.

## Features

- Generate synthetic handwritten text images
- Create synthetic printed document images
- Customize text content, fonts, layouts, and degradation effects
- Support for curved text, drop caps, and marginalia
- Export data in image format and ALTO XML for HTR and OCR tasks

## Usage

Here's an example of how to use old-doc to create a sample manuscript page:

```python
from old_doc import TextBlock, Column, Row, Page

title = TextBlock("Simple Document", block_type="heading", font_size=40, font_color=(100, 0, 0))
content = TextBlock("This is a sample text for our document. " * 5, 
                    font_size=16, font_color=(0, 0, 0), 
                    curve_amount=0.1,  # Slight curve to the text
                    word_spacing=10
                    )

# Create layout
header_row = Row([Column([title], width=800)], height=60)
content_row = Row([Column([content], width=800)], height=400)

# Create page
page = Page([header_row, content_row], 
            cell_padding=20, 
            background_color=(250, 240, 230))  # Light parchment color

# Generate the page
image, alto = page.generate()

# Save the results
image.save("example.png")
page.save_alto_xml("example.alto.xml")

# Display the image (optional, requires matplotlib)
page.visualize_results()
```

This example creates a manuscript page with a header, date, main content with curved text and potential drop caps, and marginalia. It then generates the page, visualizes it, and saves both the image and ALTO XML output.
crack-pdf 0.1.1
A tool to crack password-protected PDFs
Requires Python: >=3.6

# crack-pdf

crack-pdf is a command-line tool for attempting to decrypt password-protected PDF files using a brute-force approach.

## Features

- Attempts to crack PDF passwords using digit combinations
- Configurable password length
- Command-line interface for easy use

## Installation

To install crack-pdf, follow these steps:

1. Clone the repository:

```sh
git clone <https://github.com/szpatrichard/crack-pdf.git>
cd crack-pdf
```

2. Install the package:

```sh
pip install -e .
```

## Usage

After installation, you can use the `crack-pdf` command from anywhere in your terminal:

```sh
crack-pdf /path/to/your/pdf -l <password_length>
```

Where:

- `/path/to/your/pdf` is the path to the PDF file you want to decrypt
- `<password_length>` is the length of the password to try (e.g., 4 for a 4-digit password)

Example:

```sh
crack-pdf ~/user/documents/locked.pdf -l 4
```

This command will attempt to crack a PDF password using all 4-digit combinations.

## Limitations

- This tool only attempts numeric passwords.
- It uses a brute-force approach, which can be time-consuming for longer passwords.
- It's intended for educational purposes and should not be used for illegal activities.

## Contributing

Contributions to crack-pdf are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the [LICENCE](LICENCE) file for details.

## Disclaimer

This tool is for educational purposes only. Only use it on PDF files that you own or have explicit permission to access. The authors are not responsible for any misuse or damage caused by this program.