semvec/pypi-packages huggingface dataset:
subprocessed 0.0
Execute a function in a Python subprocess instead of using the Python main process.
Requires Python: >=3.7

# subprocessed

Execute a function in a subprocess instead of using the main process.

It allows you to protect your main process from ugly things done in the
functionalities you are using:
- Global variables definition.
- `sys.path` modification.
- Segmentation fault and other wild crashes.
- Static C/C++ variables.
- Fortran 77 `COMMON`.
- Etc.

## Install

Install `subprocessed` from `pip`:
```sh
pip install subprocessed
```

## Usage

### Decorate your function with `subprocessed`

After installation, you can use the `subprocessed` decorator as follow:
```python
from subprocessed import subprocessed

@subprocessed
def do_ugly_things(a: int, b: str, c: float):
    """Function hiding ugly thing done by the ``ugly`` module."""
    import ugly # Hide also your imports!
    return ugly.do_horrible_things(parameters)

# Call serenely your module
result1, output1 = do_ugly_things(1, "dummy", c=3.7)
result2, output2 = do_ugly_things(2, "meh", c=100.5)
```

#### Get what's happening in the decorated function seamlessly

Everything happening in the subprocessed function is transmitted to the main
process:
- Returned values.
- Raised Exceptions.
- Send warnings.
- Proper exit with zero exit code.

#### Check if the subprocess is alive... or not

By default, the subprocess status is automatically checked every second.
You can control that with the `check_delay` parameter when decorating your
function.

```python
from subprocessed import subprocessed
@subprocessed(check_delay=0.1)  # Check the subprocess every 100 ms
def do_ugly_things():
    pass
```

If the subprocess has died, a `multiprocessing.ProcessError` is raised.

#### Deactivate the subprocess checking

You can also completely deactivate the verification with `None`:

```python
from subprocessed import subprocessed
@subprocessed(check_delay=None)  # No checking
def do_ugly_things():
    pass
```

> Remember when doing that: if the subprocess crashes, the execution of the main
> process will be blocked.

## Known limitations

### Serializable inputs and outputs

Transmitting objects between processes is possible only if they are serializable.

### Daemon child processes cannot create children processes

An exception will be raised if you try to execute a subprocessed function in a
daemon child process.

### Only compatible with POSIX systems

This forks Python process so it is not possible to use it on Windows and MacOS.
doc-insights 0.1.1
A tool for validating documentation and related resources
Requires Python: >=3.6

## Documentation Validation

### Overview

This Jupyter Notebook is designed to automate the validation process for documentation and Type files within one or more projects. It performs a series of checks across specified cloned repositories, ensuring that all documentation links, Type references, and image paths are correctly fformatted and that the necessary files are present.

### Key Functions

- **File Scanning and Counting:** The Notebook scans specified local directories, counting files with particular extensions (e.g., `.c3doc.md`, `.c3typ`) and aggregating metadata.

- **Link Extraction and Validation:** It extracts links from documentation files, including references to other documents, Types, and images. These links are then validated to ensure they point to existing, correctly named files.

- **Error Reporting:** Any broken links, missing files, or other issues identified during the validation process are logged and can be outputted to the console and/or saved to a CSV file for further review.

### Configuration

The Notebook is highly configurable, allowing users to:

- Specify directories containing application files and dependencies.
- Define which file extensions should be included in the validation process.
- Set custom regex patterns for extracting links.
- Exclude specific Types from validation.
- Choose whether to print results to the console and/or save them to a file.
- Ignore certain subdirectories that do not need to be scanned.
- Control logging behavior and output locations.

### Execution

After configuring the Notebook with the desired settings, the run_validation function is executed. This function orchestrates the entire validation process, ensuring that all documentation and Type files are correctly linked and that the project is free of broken references.

## Installation

To install the project, you can use `pip`:

```bash
pip install doc-insights
```

## Example notobook

```py
from doc_insights.main import run_validation

# Call a function from your package to verify it works
run_validation(
    dependency_dirs=['/Users/chrismahlke/Documents/c3server-feature-devx-studio-doc-8.4'],
    app_dirs=['/Users/chrismahlke/Documents/c3server-feature-devx-studio-doc-8.4'],
    file_exts_to_include=['.c3doc.md', '.c3typ'],
    exclude_types=["Jsn", "Bin", "Str"],
    subdirs_to_ignore=[".git"],
    should_print_counts=True,
    should_print_broken_links=True,
    should_print_documents=False,
    should_save_to_csv=False,
    csv_file_path='output.csv',
    doc_file_ext='.c3doc.md',
    type_file_ext='.c3typ',
    log_file_path='log.txt'
)
```
tpl-parser 1.0.1
A Python package to parse Photoshop TPL files and extract data into JSON format.
Requires Python: >=3.6

# TPLParserPy

<p align="center">
  <img src="https://raw.githubusercontent.com/DavyJonesCodes/TPLParserPy/ff1be2e10922593ffe2949b8927ff6696000ecde/assets/logo.png" alt="Logo" height="128px">
</p>

<p align="center">
  <img src="https://img.shields.io/badge/python-3670A0?style=for-the-badge&logo=python&logoColor=ffdd54" />
  <img src="https://img.shields.io/badge/adobe%20photoshop-%2331A8FF.svg?style=for-the-badge&logo=adobe%20photoshop&logoColor=white"/>
</p>

# 🎨 TPLParserPy

Welcome to **TPLParserPy**! 🛠️ This Python package is designed to help you parse Photoshop TPL (Tool Preset) files and extract the data into a friendly JSON format. Perfect for anyone who wants to dive deep into TPL files and understand their inner workings! 💡

## ✨ Features

- 🔍 **Parse Photoshop TPL files** with ease.
- 🗂️ **Extract tool names, types, and properties** into JSON format.
- 💾 **Save the extracted data** for further use or analysis.

## 🚀 Installation

You can easily install TPLParserPy via pip from [PyPI](https://pypi.org/project/tpl-parser/):

```bash
pip install tpl-parser
```

## 🛠️ Usage

### Importing and Using the Library

Here's a quick example of how to use TPLParserPy in your Python project:

```python
from TPLParser import TPLReader

file_path = "path/to/yourfile.tpl"
reader = TPLReader(file_path)
tpl_data = reader.read_tpl()
reader.save_to_json("output.json")
```

### Command-Line Interface

TPLParserPy also includes a handy command-line interface for quick parsing:

```bash
tpl-parser path/to/yourfile.tpl -o output.json
```

## 🤝 Contributions

Contributions are welcome! 🎉 If you'd like to contribute to TPLParserPy, feel free to fork the repository and submit a pull request. If you have any questions or need guidance, don't hesitate to contact me at [devjonescodes@gmail.com](mailto:devjonescodes@gmail.com).

## 📄 License

This project is licensed under the Creative Commons Attribution-NonCommercial 4.0 International License. For more details, see the [LICENSE](./LICENSE) file. For commercial use, please contact [Dev Jones](mailto:devjonescodes@gmail.com).

## 📬 Contact

If you have any questions, suggestions, or just want to say hi, feel free to reach out via email: [devjonescodes@gmail.com](mailto:devjonescodes@gmail.com). We'd love to hear from you! 😊
genetic-algorithms-personal 0.2.0
A custom genetic algorithm package with Pygame visualization.
Requires Python: >=3.6

# Genetic Algorithms

A custom Python package implementing a Genetic Algorithm (GA) with support for Pygame visualization. This package allows you to run genetic algorithms for optimization problems and visualize the evolution of the population over generations.

## Features

- **Genetic Algorithm Implementation**: Easily customizable with different mutation rates, crossover rates, and fitness functions.
- **Pygame Visualization**: Visualize the evolution of the population over time using a graphical interface.
- **Elitism**: Support for elitism to carry the best individuals to the next generation.
- **Early Stopping**: Stop the algorithm early if the population's fitness stagnates for a certain number of generations.

## Installation

### Option 1: Install Locally

You can install the package locally by cloning the repository and running:

```bash
pip install .
```
gustavo-image-processor 0.0.2
Image Processing Package using skimage
Requires Python: >=3.8

# package_name

Description. 
The package gustavo-image-processor is used to:
	Processing:
		- Histogram matching 
		- Structural similarity
		- Resize image
	Utils:
		- Read image
		- Save image
		- Plot image
		- Plot result
		- Plot histogram

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install image_processing
```

## Author
Gustavo

## License
[MIT](https://choosealicense.com/licenses/mit/)