scipathgen 0.1.0__tar.gz

scipathgen-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+.venv
+.DS_Store
+*/*/__pycache__
+others_projects/sciforge
+scistack-gui/extension/node_modules/
+scistack-gui/frontend/node_modules/__pycache__/ 
+*.pyc 
+__pycache__/ 
+*.pyc 
+*.pyo 

scipathgen-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: scipathgen
+Version: 0.1.0
+Summary: Template-based path generation for data pipelines
+Project-URL: Repository, https://github.com/example/scipathgen
+Project-URL: Issues, https://github.com/example/scipathgen/issues
+Author: SciStack Contributors
+License-Expression: MIT
+Keywords: batch-processing,data-pipeline,file-discovery,metadata,path,template
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# SciPathGen
+
+Template-based path generation for data pipelines.
+
+Generates file paths with associated metadata from a template and metadata value combinations.
+
+## Usage
+
+```python
+from scipathgen import PathGenerator
+
+paths = PathGenerator(
+    "{subject}/trial_{trial}.mat",
+    root_folder="/data/experiment",
+    subject=range(3),
+    trial=range(5),
+)
+
+for path, meta in paths:
+    print(path, meta)
+# /data/experiment/0/trial_0.mat {'subject': 0, 'trial': 0}
+# /data/experiment/0/trial_1.mat {'subject': 0, 'trial': 1}
+# ...
+
+# Supports indexing and length
+print(len(paths))  # 15
+path, meta = paths[0]
+```
+
+If `root_folder` is omitted, paths are resolved relative to the current working directory via `Path.resolve()`.

scipathgen-0.1.0/README.md

@@ -0,0 +1,30 @@
+# SciPathGen
+
+Template-based path generation for data pipelines.
+
+Generates file paths with associated metadata from a template and metadata value combinations.
+
+## Usage
+
+```python
+from scipathgen import PathGenerator
+
+paths = PathGenerator(
+    "{subject}/trial_{trial}.mat",
+    root_folder="/data/experiment",
+    subject=range(3),
+    trial=range(5),
+)
+
+for path, meta in paths:
+    print(path, meta)
+# /data/experiment/0/trial_0.mat {'subject': 0, 'trial': 0}
+# /data/experiment/0/trial_1.mat {'subject': 0, 'trial': 1}
+# ...
+
+# Supports indexing and length
+print(len(paths))  # 15
+path, meta = paths[0]
+```
+
+If `root_folder` is omitted, paths are resolved relative to the current working directory via `Path.resolve()`.

scipathgen-0.1.0/pyproject.toml

@@ -0,0 +1,88 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "scipathgen"
+version = "0.1.0"
+description = "Template-based path generation for data pipelines"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    { name = "SciStack Contributors" }
+]
+keywords = [
+    "path",
+    "template",
+    "file-discovery",
+    "metadata",
+    "data-pipeline",
+    "batch-processing",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "mypy>=1.0",
+    "ruff>=0.1.0",
+]
+
+[project.urls]
+Repository = "https://github.com/example/scipathgen"
+Issues = "https://github.com/example/scipathgen/issues"
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/scipathgen"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "F",   # Pyflakes
+    "I",   # isort
+    "B",   # flake8-bugbear
+    "C4",  # flake8-comprehensions
+    "UP",  # pyupgrade
+]
+ignore = [
+    "E501",  # line too long (handled by formatter)
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["scipathgen"]

scipathgen-0.1.0/src/scipathgen/__init__.py

@@ -0,0 +1,10 @@
+"""Path generation utilities for data pipelines.
+
+This package provides template-based path generation for creating file paths
+organized by metadata combinations (subject, trial, session, etc.).
+"""
+
+from scipathgen.generator import PathGenerator
+
+__all__ = ["PathGenerator"]
+__version__ = "0.1.0"

scipathgen-0.1.0/src/scipathgen/generator.py

@@ -0,0 +1,89 @@
+"""Path generation from templates and metadata combinations."""
+
+from itertools import product
+from pathlib import Path
+from typing import Any, Iterator
+
+
+class PathGenerator:
+    """
+    Generate file paths with associated metadata from a template and metadata values.
+
+    This class helps separate path resolution from data loading by generating
+    all combinations of metadata values along with their fully resolved paths.
+
+    Args:
+        path_template: A format string with placeholders for metadata fields.
+                      Uses Python's str.format() syntax, e.g., "{subject}/trial_{trial}.mat"
+        root_folder: Optional root folder path. If provided, paths are resolved
+                    relative to this folder. If None, paths are resolved
+                    relative to the current working directory (via Path.resolve()).
+        **metadata: Keyword arguments where each key is a metadata field name and
+                   each value is an iterable of values for that field.
+
+    Example:
+        >>> paths = PathGenerator(
+        ...     "{subject}/trial_{trial}.mat",
+        ...     root_folder="/data/experiment",
+        ...     subject=range(3),
+        ...     trial=range(5)
+        ... )
+
+        >>> for path, meta in paths:
+        ...     print(path, meta)
+        # /data/experiment/0/trial_0.mat {'subject': 0, 'trial': 0}
+        # /data/experiment/0/trial_1.mat {'subject': 0, 'trial': 1}
+        # ...
+
+        >>> # Can also access by index or get length
+        >>> print(len(paths))  # 15
+        >>> path, meta = paths[0]
+        >>> print(path)  # /data/experiment/0/trial_0.mat
+        >>> print(meta)  # {'subject': 0, 'trial': 0}
+    """
+
+    def __init__(
+        self,
+        path_template: str,
+        root_folder: str | Path | None = None,
+        **metadata: Any,
+    ):
+        self.path_template = path_template
+        self.root_folder = Path(root_folder) if root_folder is not None else None
+        self.metadata_keys = list(metadata.keys())
+        self.metadata_values = [list(v) for v in metadata.values()]
+
+        # Pre-compute all combinations for efficient indexing
+        self._items: list[tuple[Path, dict[str, Any]]] = []
+        for combo in product(*self.metadata_values):
+            meta = dict(zip(self.metadata_keys, combo))
+            relative_path = Path(path_template.format(**meta))
+            if self.root_folder is not None:
+                full_path = (self.root_folder / relative_path).resolve()
+            else:
+                full_path = relative_path.resolve()
+            self._items.append((full_path, meta))
+
+    def __iter__(self) -> Iterator[tuple[Path, dict[str, Any]]]:
+        """Iterate over all path/metadata combinations."""
+        return iter(self._items)
+
+    def __len__(self) -> int:
+        """Return the total number of path/metadata combinations."""
+        return len(self._items)
+
+    def __getitem__(self, index: int) -> tuple[Path, dict[str, Any]]:
+        """Get a specific path/metadata combination by index."""
+        return self._items[index]
+
+    def __repr__(self) -> str:
+        """Return a string representation of the PathGenerator."""
+        return (
+            f"PathGenerator({self.path_template!r}, "
+            f"root_folder={self.root_folder!r}, "
+            f"{', '.join(f'{k}=...' for k in self.metadata_keys)})"
+        )
+
+    def to_list(self) -> list[tuple[Path, dict[str, Any]]]:
+        """Return all path/metadata combinations as a list."""
+        return list(self._items)