semvec/pypi-packages huggingface dataset:
dirac-solver 0.1.0
Librería diseñada para la solución numérica de la ecuación de Dirac.
License: MIT
Requires Python: >=3.8

# Dirac-Solver: Solucionador numérico de la Ecuación de Dirac

Este proyecto implementa un solucionador numérico para la ecuación de Dirac en 1D, 2D y 3D. El núcleo computacional está escrito en C++ y expuesto a Python mediante `pybind11`, permitiendo simulaciones eficientes junto con una interfaz simple y flexible.

La ecuación resuelta es:


\\[  (i\gamma^\mu \partial_\mu - m)\psi = 0 \\]


en unidades naturales, donde el bispinor \\(\psi \in \mathbb{C}^4\\) es un vector columna complejo. El proyecto implementa métodos explícitos tipo FDTD (Leapfrog), potenciales personalizables, condiciones de frontera modulares y manejo de datos en HDF5.

---

## Características principales

- Implementación explícita del esquema **Leapfrog (FDTD)**.
- Mallas 1D/2D/3D mediante la clase `Grid`.
- Interfaz C++ ↔ Python mediante **pybind11**.
- Potenciales configurables: Coulomb, pozo, Yukawa, y potenciales definidos por el usuario.
- Condiciones de frontera intercambiables.
- Módulo Python para estados iniciales, observables, geometría y almacenamiento.
- Ejemplos en Jupyter listos para ejecutar.
- Documentación generada con **Doxygen**.

---

## Estructura del proyecto


dirac_solver/
├── cpp_src/              # Código fuente C++ (núcleo numérico)
├── dirac_solver/         # API Python
├── examples/             # Notebooks de ejemplos
├── docs/                 # Documentación Doxygen (HTML y LaTeX)
├── tests/                # Pruebas unitarias
├── save_data/            # Resultados de simulaciones (HDF5)
├── planning/             # Diseño, requisitos, notas técnicas
└── pyproject.toml        # Configuración del paquete Python


---

## Instalación

### Instalación local editable

```bash
pip install -e .
````

### Compilación del núcleo C++

```bash
mkdir -p cpp_build
cd cpp_build
cmake ../cpp_src
make -j
```

---

## Uso básico

Ejemplo mínimo en Python:

```python
from dirac_solver import core, potentials, initial_state, observables

grid = core.Grid(shape=(200,), spacing=0.05)

V = potentials.Coulomb(Z=1)

psi0 = initial_state.gaussian(grid)

solver = core.TimeIntegrator(grid, V)
psi_t = solver.evolve(psi0, dt=0.001, steps=1000)

obs = observables.Observables(psi_t)
density = obs.probability_density()
```

---

## Documentación

Para compilar la documentación, en el directorio principal ejecutar:

```bash
doxygen
```

La salida se genera en:

```
docs/html/index.html
docs/latex/
```

---

## Ejemplos

En el directorio `examples/` encontrarás notebooks que cubren:

* Partícula libre
* Pozo cuadrado
* Potencial Coulomb
* Potencial Yukawa
* Ondas gaussianas

---

## Contribuir

Las contribuciones son bienvenidas.

* Revisar `CONTRIBUTING.md`
* Mantener consistencia en el estilo del código
* Agregar pruebas unitarias si se añaden características nuevas
* Actualizar la documentación cuando corresponda

---

## Licencia

Este proyecto se distribuye bajo la licencia **MIT**. Ver `LICENSE` para más detalles.
psd-toolkit 0.2.0
A toolkit for batch processing PSD files - hide text layers and export to PNG
License: MIT
Requires Python: >=3.10
Keywords: automation, batch-processing, image-processing, photoshop, psd

# psd-toolkit

A Python toolkit for batch processing Adobe Photoshop PSD files. Automatically hide text layers and export to PNG format.

## 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 psd-toolkit
```

Or using uv:

```bash
uv add psd-toolkit
```

## Usage

### Command Line

Process PSD files in a directory:

```bash
psd-toolkit -d /path/to/psd/files
```

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

```bash
psd-toolkit -d /path/to/psd/files -o /path/to/output -r -f jpeg
```

### 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

### Python API

You can also use psd-toolkit as a Python library:

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

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

# 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).