semvec/pypi-packages huggingface dataset:
pymodd 1.1.0
create and edit modd.io games in python
License: MIT
Requires Python: >=3.8

======
pymodd
======

|Build| |Version| |License|

pymodd is a python package for creating and editing modd.io games in python

.. |Build| image:: https://img.shields.io/github/actions/workflow/status/jeff5343/pymodd/test.yml?label=CI&logo=github&style=plastic
   :alt: GitHub Workflow Status
.. |Version| image:: https://img.shields.io/pypi/v/pymodd?style=plastic
   :alt: PyPI
.. |License| image:: https://img.shields.io/pypi/l/pymodd?style=plastic
   :alt: PyPI - License

Features
--------

- edit global and entity scripts
- organize folders and scripts with a mapping file
- edit environment variables
- a command to generate and compile a pymodd project

Documentation
-------------

The pymodd wiki is located at `github.com/jeff5343/pymodd/wiki <https://github.com/jeff5343/pymodd/wiki>`_

A brief outline:

- `Introduction <https://github.com/jeff5343/pymodd/wiki>`_
- `Install Guide <https://github.com/jeff5343/pymodd/wiki/Install-Guide>`_
- `Generating and Compiling a Pymodd Project <https://github.com/jeff5343/pymodd/wiki/Generating-and-Compiling-a-Pymodd-Project>`_
- `Pymodd Project Structure <https://github.com/jeff5343/pymodd/wiki/Pymodd-Project-Structure>`_


Quick Script Example
--------------------

view the ``examples/froge`` directory in the `github repository <https://github.com/jeff5343/pymodd>`_ to view the entire pymodd project

.. code:: py

    @script(triggers=[Trigger.EVERY_SECOND])
    def every_second():
        if NumberOfUnitsOfUnitType(UnitType.FROG) < 5:
            create_unit_for_player_at_position_with_rotation(UnitType.FROG, Variable.AI, RandomPositionInRegion(EntireMapRegion()), 0)
        else:
            if NumberOfUnitsOfUnitType(UnitType.FROG_BOSS) == 0:
                if Variable.BOSS_TIMER <= 0:
                    create_unit_for_player_at_position_with_rotation(UnitType.FROG_BOSS, Variable.AI, RandomPositionInRegion(EntireMapRegion()), 0)
                    update_ui_target_for_player_for_miliseconds(UiTarget.CENTER, 'BOSS SPAWNED', Undefined(), 5000)
                decrease_variable_by_number(Variable.BOSS_TIMER, 1)
mil-kit 0.4.5
A toolkit for processing the ASM's Mammal Image Library (MIL).
License: MIT
Requires Python: >=3.10
Keywords: automation, batch-processing, image-processing, photoshop, psd

# mil-kit

![Tests](https://github.com/hhandika/mil-kit/actions/workflows/test.yml/badge.svg)
![GitHub Tag](https://img.shields.io/github/v/tag/hhandika/mil-kit?label=GitHub)
![PyPI - Version](https://img.shields.io/pypi/v/mil-kit?color=blue)

A Python toolkit for batch processing the Mammal Image Library (MIL) images. Reshape, convert, and optimize images for the mammal diversity database and other applications.

## Features

- 🚀 Batch process multiple PSD files in a directory
- ⚡ Parallel processing for faster execution
- 📊 Progress bar with detailed status
- 📝 Automatically hide all text layers
- 🖼️ Export processed files as PNG (default) or other formats
- 📁 Support for recursive directory processing
- ⚡ Preserve folder structure in output

## Installation

Install using pip:

```bash
pip install mil-kit
```

Or using uv:

```bash
uv add mil-kit
```

## Usage

### Command Line

Process PSD files in a directory:

```bash
mil-kit -d /path/to/psd/files
```

Process recursively, specify output directory, and use JPEG format:

```bash
mil-kit -d /path/to/psd/files -o /path/to/output -r -f jpeg --max-resolution 500
```

### Options

- `-d, --dir`: Input directory containing PSD files (required)
- `-o, --output`: Output directory for processed files (default: input directory)
- `-f, --output-format`: Output image format (default: png)
- `-r, --recursive`: Process subdirectories recursively
- `--max-resolution`: Set maximum resolution for output images (if needed)

### Python API

You can also use mil-kit as a Python library:

```python
from mil_kit.psd.processor import PSDProcessor
from mil_kit.job import BatchJob

# Process a single file
processor = PSDProcessor("image.psd")
processor.load()
processor.hide_non_image_layers()
processor.export("output.jpg", format="jpeg")

# If you want to export with max resolution
processor.export("output_resized.jpg", format="jpeg", max_resolution=500)

# Batch process
job = BatchJob(
    input_dir="./psd_files",
    output_dir="./output",
    recursive=True,
    output_format="png",
    max_workers=4
)
job.run()
```

## Requirements

- Python >= 3.10
- psd-tools >= 1.12.0
- pillow >= 12.0.0
- tqdm >= 4.67.1

## License

MIT License - see [LICENSE](LICENSE) file for details.

## Contributing

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

## Issues

Report bugs and request features on [GitHub Issues](https://github.com/hhandika/psd-toolkit/issues).
dask-utils 0.1.0
daks lib utilities
License: MIT
Requires Python: >=3.10
Keywords: dask, python

# DASK utility library

[![main](https://github.com/mhferjani/dask-utils/actions/workflows/ci.yml/badge.svg)](https://github.com/mhferjani/dask-utils/actions/workflows/ci.yml)
[![PyPI version](https://img.shields.io/pypi/v/dask-utils.svg)](https://pypi.org/project/dask-utils/)
[![Python](https://img.shields.io/pypi/pyversions/dask-utils.svg)](https://pypi.org/project/dask-utils/)
[![Downloads](https://img.shields.io/pypi/dm/dask-utils)](https://pypi.org/project/dask-utils/)This library provides custom Dask classes for connect and execute computation on DASK cluster.

* Scan and parse Dask config file (cfg parser)
* Extension of the default Dask Client
* Custom functions to retrieve information from Dask cluster
* Test utilities: generate local cluster and initialize client
* Decorators: Singleton decorator
* Packaging utility to create a zip dask tasks dependencies
* Queue utility to deal with futures (Future) for different Dask clients

## Requirements

* Python >= 3.10 (not yet tested with Python =2.7 and =3.4)

## Installation

To install this library:

```bash
poetry add dask-utils
```

or 

```bash
uv add dask-utils
```

or directly with pip


## Dependencies
* dask[distribute]


## Configuration

### Default config file [useful for development purposes]

By default, `dask-utils` come with a build-in config file named ``client.cfg``.
``client.cfg`` contains a minimum of config options which client used to perform connection to Dask scheduler 
and submitting computation on cluster.

```
[client]
host = localhost
port = 8786
timeout=10
name=client_name

[worker]
memory=1e5
cpu=2
process=1
```

**Example**:

```python
from  dask_utils import Client
#Init client and connect to localhost scheduler on 8786 port
c= Client()
#sublit compuation on localhost dask
c.submit(f,*args)
```
**Note** : field names in worker section can be changed if `--resources "XX=YY"` params used when launched worker respect the same convention name

### Custom config file [**Recommended for production usage**]

You can overwrite the default config file ``client.cfg`` by creating your custom file config into your project.
In this case, you should define `DASK_UTILS_ROOT_CONFIG` variable env for the runtime.

**Examples**:

```bash
export DASK_UTILS_ROOT_CONFIG=/etc/mlbox/client.cfg
```
```python
from  dask_utils import Client
#Init client and connect to scheduler defined into DASK_UTILS_ROOT_CONFIG 
c= Client()
c.submit(f,*args)
```

**Note** : In development time, you can overwrite options defined in config file (defined in `DASK_UTILS_ROOT_CONFIG`) by passing options 
directly as parameters to `Client` class.

```python
from  dask_utils import Client
#overwrite config
my_custom_address='192.168.2.2:52879'
c= Client(address=my_custom_address)
c.submit(f,*args)
```

or 

```python
my_custom_resources:{'cpu':1,'memory':'2G'}
c.submit(f,*args,resources=my_custom_resources)
```
prism-engines 0.1.0
Geometric analysis engines for time series data
License: MIT
Requires Python: >=3.9
Keywords: time-series, analysis, pca, correlation, geometry

# PRISM Engines

Geometric analysis engines for time series data.

## Installation

```bash
pip install prism-engines
```

For plotting support:
```bash
pip install prism-engines[plot]
```

## Quick Start

```python
import prism_engines as prism

# Load CSV and run all engines
results = prism.run("your_data.csv")

# Print analysis report
results.print_report()

# Generate visualization
results.plot()

# Save results
results.save("output/", name="my_analysis")
```

## What It Does

PRISM Engines analyzes multi-variate time series to reveal geometric structure:

| Engine | What It Measures |
|--------|-----------------|
| **Correlation** | Pairwise relationships between series |
| **PCA** | Dimensionality and dominant modes |
| **Hurst** | Memory/persistence in each series |

## Example Output

```
============================================================
PRISM ENGINES ANALYSIS REPORT
============================================================

Data: (100, 5) (5 series)
Range: 2024-01-01 to 2024-04-10

--- CORRELATION ---
  mean_abs_correlation: 0.4523
  max_correlation: {'pair': ('AAPL', 'MSFT'), 'value': 0.892}

--- PCA ---
  explained_variance_ratio: [0.523, 0.218, 0.142, 0.089, 0.028]
  effective_dimension: 3
  global_forcing_metric: 0.523

--- HURST ---
  mean_hurst: 0.612
  persistence_classification: {'AAPL': 'persistent', ...}
============================================================
```

## Detailed Usage

### Loading Data

```python
from prism_engines import load_csv

# Load and validate CSV
df = load_csv("data.csv")
```

Your CSV should have:
- First column: dates (will become index)
- Remaining columns: numeric time series

### Running Specific Engines

```python
from prism_engines import run_engines

# Run only PCA and correlation
results = run_engines(df, engines=["pca", "correlation"])
```

### Accessing Results

```python
# Get specific engine result
pca = results["pca"]

# Access metrics
print(pca.metrics["global_forcing_metric"])
print(pca.metrics["effective_dimension"])

# Check all available metrics
print(pca.metrics.keys())
```

### Available Engines

```python
from prism_engines import list_engines

print(list_engines())
# ['correlation', 'pca', 'hurst']
```

## Metrics Reference

### Correlation Engine
- `correlation_matrix`: NxN correlation matrix
- `mean_abs_correlation`: Average |correlation|
- `max_correlation`: Strongest correlated pair
- `min_correlation`: Weakest correlated pair

### PCA Engine
- `explained_variance_ratio`: Variance per component
- `effective_dimension`: Components for 90% variance
- `global_forcing_metric`: PC1 dominance (higher = more shared movement)
- `pc1_loadings`: How each series loads on PC1

### Hurst Engine
- `hurst_exponents`: H value per series
- `mean_hurst`: Average H
- `persistence_classification`: Category per series
  - `H < 0.4`: anti-persistent (mean-reverting)
  - `0.4 ≤ H ≤ 0.6`: random walk
  - `H > 0.6`: persistent (trending)

## License

MIT