alomancy 0.1.0.post0__tar.gz

alomancy-0.1.0.post0/.github/workflows/ci.yml

@@ -0,0 +1,214 @@
+name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [ main, master, develop ]
+  pull_request:
+    branches: [ main, master, develop ]
+  release:
+    types: [published]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+
+      - name: Cache pip packages
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-lint-${{ hashFiles('**/pyproject.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-pip-lint-
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install ruff mypy
+          pip install -e ".[dev]"
+
+      - name: Lint with ruff
+        run: ruff check src tests
+
+      - name: Check formatting with ruff
+        run: ruff format --check src tests
+
+      - name: Type check with mypy
+        run: mypy src/alomancy
+        continue-on-error: true  # Allow to continue if mypy fails
+
+  test:
+    runs-on: ${{ matrix.os }}
+    needs: lint  # Run tests after linting passes
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+        exclude:
+          # Exclude some combinations to reduce CI time
+          - os: macos-latest
+            python-version: "3.9"
+          - os: macos-latest
+            python-version: "3.11"
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Cache pip packages
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-py${{ matrix.python-version }}-pip-${{ hashFiles('**/pyproject.toml') }}
+        restore-keys: |
+          ${{ runner.os }}-py${{ matrix.python-version }}-pip-
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e ".[dev]"
+
+    - name: Test with pytest
+      run: |
+        pytest --cov=alomancy --cov-report=xml --cov-fail-under=70 -v tests/
+      env:
+        ALOMANCY_TEST_MODE: "1"
+        ALOMANCY_MOCK_EXTERNAL: "1"
+
+    - name: Upload coverage to Codecov
+      if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.10'
+      uses: codecov/codecov-action@v3
+      with:
+        file: ./coverage.xml
+        flags: unittests
+        name: codecov-umbrella
+        fail_ci_if_error: false
+
+  integration-test:
+    runs-on: ubuntu-latest
+    needs: test
+    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master')
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+
+    - name: Cache pip packages
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-integration-pip-${{ hashFiles('**/pyproject.toml') }}
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e ".[dev]"
+
+    - name: Run integration tests
+      run: |
+        pytest -m integration tests/ -v
+      env:
+        ALOMANCY_TEST_MODE: "1"
+        ALOMANCY_MOCK_EXTERNAL: "1"
+
+  build:
+    runs-on: ubuntu-latest
+    needs: [test, lint]
+    if: github.event_name == 'release' || github.event_name == 'push'
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Needed for setuptools_scm
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build twine
+
+    - name: Build package
+      run: python -m build
+
+    - name: Check package
+      run: twine check dist/*
+
+    - name: Upload build artifacts
+      uses: actions/upload-artifact@v3
+      with:
+        name: dist
+        path: dist/
+
+  publish:
+    runs-on: ubuntu-latest
+    needs: build
+    if: github.event_name == 'release'
+    environment: release  # Use environment protection
+
+    steps:
+    - name: Download build artifacts
+      uses: actions/download-artifact@v3
+      with:
+        name: dist
+        path: dist/
+
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}
+
+  documentation:
+    runs-on: ubuntu-latest
+    needs: test
+    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master')
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+
+    - name: Cache pip packages
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-docs-pip-${{ hashFiles('**/pyproject.toml') }}
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e ".[docs]"
+
+    - name: Build documentation
+      run: |
+        cd docs
+        make html
+      continue-on-error: true
+
+    - name: Deploy to GitHub Pages
+      if: success()
+      uses: peaceiris/actions-gh-pages@v3
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        publish_dir: ./docs/_build/html

alomancy-0.1.0.post0/.gitignore

@@ -0,0 +1,11 @@
+*traj
+*xyz
+*log
+
+mace_general
+results
+working_demo
+MACE_model
+archive
+
+__pycache__

alomancy-0.1.0.post0/.pre-commit-config.yaml

@@ -0,0 +1,42 @@
+# Minimal pre-commit configuration
+repos:
+  # General code quality
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-merge-conflict
+      - id: check-yaml
+      - id: check-toml
+      - id: debug-statements
+
+  # Python formatting and linting
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.1.15
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+
+  # Fast unit tests only
+  - repo: local
+    hooks:
+      - id: pytest-unit
+        name: Unit tests
+        entry: pytest
+        language: system
+        pass_filenames: false
+        always_run: true
+        args: [-m, "not integration and not slow", --tb=line, -q, tests/]
+        stages: [pre-commit]
+
+exclude: |
+  (?x)^(
+      \.git/|
+      __pycache__/|
+      build/|
+      dist/|
+      \.venv/|
+      src/alomancy/_?version\.py
+  )

alomancy-0.1.0.post0/PKG-INFO

@@ -0,0 +1,346 @@
+Metadata-Version: 2.4
+Name: alomancy
+Version: 0.1.0.post0
+Summary: Active Learning framework for atomistic simulations with flexible workflows and HPC submission.
+Author-email: Julian Holland <holland@fhi.mpg.de>
+License: MIT
+Project-URL: Homepage, https://github.com/julianholland/ALomancy
+Project-URL: Repository, https://github.com/julianholland/ALomancy
+Project-URL: Documentation, https://alomancy.readthedocs.io
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: ase>=3.22.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tqdm>=4.60.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: wfl==0.3.3
+Requires-Dist: expyre-wfl==0.1.6
+Requires-Dist: seaborn>=0.11.0
+Requires-Dist: mace-torch>=0.3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.10; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=6.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.2; extra == "docs"
+Requires-Dist: sphinxcontrib-napoleon>=0.7; extra == "docs"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0; extra == "test"
+Requires-Dist: pytest-mock>=3.10; extra == "test"
+Requires-Dist: pytest-xdist>=3.0; extra == "test"
+
+<div align="center">
+
+</div>
+<div align="center">
+
+# `ALomancy` 🔮
+
+**Modular Active Learning Workflows for Modern Computational Chemistry**
+
+
+[![PyPI version](https://badge.fury.io/py/alomancy.svg)](https://badge.fury.io/py/alomancy)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Tests](https://github.com/yourusername/ALomnacy/workflows/CI/badge.svg)](https://github.com/yourusername/ALomnacy/actions)
+[![Code style: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+
+[Installation](#installation) • [Quick Start](#quick-start) • [Documentation](#documentation) • [Examples](#examples) • [Contributing](#contributing)
+
+</div>
+
+---
+
+## 🎯 Overview
+
+ALomnacy is a Python framework for running active learning (AL) workflows for training machine-learned inter-atomic potentials (MLIPs). This package focusses on customization and reproducibility to build robust training datasets and train MLIPs.
+
+### Key Features
+
+- 🚀 **Automated AL Workflows**: End-to-end active learning with minimal manual intervention
+- 🔧 **HPC Integration**: Built-in support for remote job submission on HPC clusters
+- **Parallelization**: Ensures that jobs run concurrently where possible
+- 🔄 **Extensible Design**: Abstract base classes for easy customization and extension
+- 📊 **Analysis Tools**: Built-in utilities for monitoring and analyzing AL progress
+
+### Workflow Overview
+
+```mermaid
+graph LR
+    A[Initial Dataset] --> B[Train MLIP Committee]
+    B --> C[Generate Structures]
+    C --> D[Uncertainty Quantification]
+    D --> E[High-Accuracy Evaluation]
+    E --> F[Update Dataset]
+    F --> B
+
+    style A fill:#e1f5fe
+    style B fill:#f3e5f5
+    style C fill:#e8f5e8
+    style D fill:#fff3e0
+    style E fill:#fce4ec
+    style F fill:#f1f8e9
+```
+
+## 🚀 Installation
+
+### From PyPI (Recommended)
+
+```bash
+pip install alomancy
+```
+
+### From Source
+
+```bash
+git clone https://github.com/yourusername/ALomnacy.git
+cd ALomnacy
+pip install -e ".[dev]"
+```
+
+### Dependencies
+
+- Python 3.9+
+- [ASE](https://wiki.fysik.dtu.dk/ase/) - Atomic Simulation Environment
+- [WFL](https://github.com/libAtoms/workflow) - Workflow for atomistic simulations
+- [Expyre](https://github.com/libAtoms/ExPyRe) - Remote job execution
+
+## ⚡ Quick Start
+
+### 1. Basic Active Learning Workflow
+
+```python
+from alomancy.core import StandardActiveLearningWorkflow
+from pathlib import Path
+
+# Initialize workflow
+workflow = StandardActiveLearningWorkflow(
+    initial_train_file_path="train_set.xyz",
+    initial_test_file_path="test_set.xyz",
+    config_file_path="config.yaml",
+    number_of_al_loops=5,
+    verbose=1
+)
+
+# Run the active learning workflow
+workflow.run()
+```
+
+### 2. Configuration File
+
+Create a `config.yaml` file to specify your computational setup:
+
+```yaml
+mlip_committee:
+  name: "mace_training"
+  size_of_committee: 4
+  epochs: 1000
+  max_time: "24:00:00"
+  hpc:
+    hpc_name: "gpu_cluster"
+    partitions: ["gpu"]
+    pre_cmds: ["module load cuda", "source activate mace"]
+
+structure_generation:
+  name: "md_generation"
+  number_of_concurrent_jobs: 8
+  desired_number_of_structures: 100
+  max_time: "12:00:00"
+  hpc:
+    hpc_name: "gpu_cluster"
+    partitions: ["gpu"]
+    pre_cmds: ["module load cuda", "source activate mace"]
+
+high_accuracy_evaluation:
+  name: "dft_evaluation"
+  max_time: "48:00:00"
+  hpc:
+    hpc_name: "cpu_cluster"
+    partitions: ["cpu"]
+    pre_cmds: ["module load quantum-espresso"]
+    node_info:
+      ranks_per_system: 32
+      ranks_per_node: 32
+      threads_per_rank: 1
+      max_mem_per_node: "128GB"
+    pwx_path: "/path/to/pw.x"
+    pp_path: "/path/to/pseudopotentials"
+    pseudo_dict:
+      H: "H.pbe-rrkjus_psl.1.0.0.UPF"
+      O: "O.pbe-n-kjpaw_psl.1.0.0.UPF"
+```
+
+### 3. Custom Workflow Implementation
+
+Extend the base class for specialized workflows:
+
+```python
+from alomancy.core import BaseActiveLearningWorkflow
+from ase import Atoms
+import pandas as pd
+
+class CustomActiveLearningWorkflow(BaseActiveLearningWorkflow):
+
+    def train_mlip(self, base_name: str, mlip_committee_job_dict: dict, **kwargs):
+        """Custom MLIP training implementation"""
+        # Your custom training logic here
+        return "path/to/trained/model.pt"
+
+    def evaluate_mlip(self, mlip_committee_job_dict: dict, **kwargs) -> pd.DataFrame:
+        """Custom model evaluation"""
+        # Your evaluation logic here
+        return pd.DataFrame({"rmse": [0.1], "mae": [0.05]})
+
+    def generate_structures(self, base_name: str, job_dict: dict,
+                          train_data: list[Atoms], **kwargs) -> list[Atoms]:
+        """Custom structure generation"""
+        # Your structure generation logic here
+        return generated_structures
+
+    def high_accuracy_evaluation(self, base_name: str,
+                               high_accuracy_eval_job_dict: dict,
+                               structures: list[Atoms], **kwargs) -> list[Atoms]:
+        """Custom high-accuracy evaluation"""
+        # Your DFT calculation logic here
+        return evaluated_structures
+```
+
+## 📚 Examples
+
+Check out the `examples/` directory for complete workflow examples:
+
+- **Basic Usage**: Simple active learning workflow setup
+- **Custom HPC Configuration**: Advanced cluster configuration
+- **Analysis Scripts**: Post-processing and visualization tools
+
+## 🏗️ Project Structure
+
+```
+alomancy/
+├── analysis/           # Analysis and visualization tools
+├── configs/           # Configuration management
+├── core/              # Core active learning framework
+├── high_accuracy_evaluation/  # DFT calculation modules
+├── mlip/              # Machine learning potential training
+├── structure_generation/      # MD and structure generation
+└── utils/             # Utility functions and helpers
+```
+
+## 🔧 Key Components
+
+### Core Framework
+- **BaseActiveLearningWorkflow**: Abstract base class for AL workflows
+- **StandardActiveLearningWorkflow**: Ready-to-use implementation
+
+### MLIP Training
+- **MACE Integration**: Committee training with uncertainty quantification
+- **Remote Submission**: HPC job management for GPU-accelerated training
+
+### Structure Generation
+- **Molecular Dynamics**: ASE-based MD simulations with MACE potentials
+- **Uncertainty Sampling**: Intelligent structure selection based on model disagreement
+
+### High-Accuracy Evaluation
+- **Quantum Espresso**: Automated DFT calculations for reference data
+- **Job Management**: Parallel submission and monitoring of DFT jobs
+
+## 📊 Monitoring and Analysis
+
+Monitor your AL progress with built-in analysis tools:
+
+```python
+from alomancy.analysis import MACEAnalysis
+
+# Analyze model performance
+analyzer = MACEAnalysis("results/")
+analyzer.plot_learning_curves()
+analyzer.analyze_uncertainty_evolution()
+analyzer.generate_report()
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+### Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/ALomnacy.git
+cd ALomnacy
+
+# Install in development mode
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run linting
+ruff check .
+ruff format .
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+pytest
+
+# Run specific test categories
+pytest tests/core_tests/
+pytest tests/mlip_train_tests/
+pytest tests/high_acc_tests/
+
+# Run with coverage
+pytest --cov=alomancy
+```
+
+## 📝 Citation
+
+If you use ALomnacy in your research, please cite:
+
+```bibtex
+@software{alomancy2025,
+  title={ALomnacy: Modular Active Learning Workflows for Modern Computational Chemistry},
+  author={Julian Holland},
+  year={2025},
+  url={https://github.com/yourusername/ALomnacy},
+  version={0.1.0}
+}
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- The Fritz Haber Institute
+
+## 📞 Support
+
+- 📖 **Documentation**: [Link to docs]
+- 🐛 **Bug Reports**: [GitHub Issues](https://github.com/yourusername/ALomnacy/issues)
+- 💬 **Discussions**: [GitHub Discussions](https://github.com/yourusername/ALomnacy/discussions)
+- 📧 **Email**: holland@fhi.mpg.de
+
+---