appm 0.0.1__py3-none-any.whl

appm/__init__.py

@@ -0,0 +1,3 @@
+from appm.manager import ProjectManager
+
+__all__ = ("ProjectManager",)

appm/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

appm/exceptions.py

@@ -0,0 +1,13 @@
+class TemplateEngineException(Exception): ...
+
+
+class ProjectNotFoundErr(TemplateEngineException): ...
+
+
+class FileFormatMismatch(TemplateEngineException): ...
+
+
+class MetadataFileNotFoundErr(TemplateEngineException): ...
+
+
+class UnsupportedFileExtension(TemplateEngineException): ...

appm/manager.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import re
+import shutil
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any, Sequence, overload
+
+from ruamel.yaml import YAML, CommentedMap, CommentedSeq
+
+from appm.__version__ import __version__
+from appm.exceptions import (
+    FileFormatMismatch,
+    MetadataFileNotFoundErr,
+    ProjectNotFoundErr,
+    UnsupportedFileExtension,
+)
+from appm.model import ExtDecl, ProjectMetadata
+
+yaml = YAML()
+yaml.indent(mapping=2, sequence=4, offset=2)
+yaml.preserve_quotes = True  # optional, if you want to preserve quotes
+
+
+def to_flow_style(obj: Any) -> Any:
+    """Recursively convert dict/list to ruamel structures with ALL lists using flow-style."""
+    if isinstance(obj, Mapping):
+        cm = CommentedMap()
+        for k, v in obj.items():
+            cm[k] = to_flow_style(v)
+        return cm
+    if isinstance(obj, Sequence) and not isinstance(obj, str):
+        cs = CommentedSeq()
+        for item in obj:
+            cs.append(to_flow_style(item))
+        cs.fa.set_flow_style()
+        return cs
+    return obj
+
+
+class ExtManager:
+    def __init__(self, ext: str, decl: ExtDecl) -> None:
+        self.ext = ext
+        self.decl = decl
+
+    @property
+    def pattern(self) -> str:
+        return (
+            r"^"
+            + self.decl.sep.join([f"({p})" for _, p in self.decl.format])
+            + r"(.*)$"
+        )
+
+    def match(self, name: str) -> dict[str, str]:
+        match = re.match(self.pattern, name)
+        if not match:
+            raise FileFormatMismatch(f"Name: {name}. Pattern: {self.pattern}")
+        groups = match.groups()
+        result = {}
+        for i, (field, _) in enumerate(self.decl.format):
+            result[field] = groups[i]
+        result["*"] = groups[-1]
+        return result
+
+
+class ProjectManager:
+    METADATA_NAME: str = "metadata.yaml"
+
+    def __init__(
+        self,
+        metadata: dict[str, Any],
+        root: str | Path,
+    ) -> None:
+        self.root = Path(root)
+        self.metadata = ProjectMetadata.model_validate(metadata)
+        self.handlers = {
+            ext: ExtManager(ext, ext_decl)
+            for ext, ext_decl in self.metadata.file.items()
+        }
+
+    def match(self, name: str) -> dict[str, str]:
+        ext = name.split(".")[-1]
+        if ext not in self.handlers:
+            raise UnsupportedFileExtension(ext)
+        return self.handlers[ext].match(name)
+
+    def get_file_placement(self, name: str) -> str:
+        layout = self.metadata.layout
+        groups = self.match(name)
+        values = [groups[component] for component in layout]
+        return "/".join(values)
+
+    def init_project(self) -> None:
+        self.root.mkdir(exist_ok=True, parents=True)
+        self.save_metadata()
+
+    def save_metadata(self) -> None:
+        metadata_path = self.root / self.METADATA_NAME
+        with metadata_path.open("w") as file:
+            data = self.metadata.model_dump(mode="json")
+            data["version"] = __version__
+            yaml.dump(
+                to_flow_style(data),
+                file,
+            )
+
+    def copy_file(self, src_path: Path) -> None:
+        if src_path.exists():
+            raise FileNotFoundError(str(src_path))
+        location = self.get_file_placement(src_path.name)
+        dst_path = self.root / location
+        dst_path.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(src_path, dst_path)
+
+    @overload
+    @classmethod
+    def from_metadata(
+        cls,
+        root: str | Path,
+        metadata: str | Path,
+        year: int,
+        summary: str,
+        internal: bool = True,
+        researcher: str | None = None,
+        organisation: str | None = None,
+    ) -> ProjectManager: ...
+
+    @overload
+    @classmethod
+    def from_metadata(
+        cls,
+        root: str | Path,
+        metadata: dict[str, Any],
+        year: int,
+        summary: str,
+        internal: bool = True,
+        researcher: str | None = None,
+        organisation: str | None = None,
+    ) -> ProjectManager: ...
+
+    @classmethod
+    def from_metadata(
+        cls,
+        root: str | Path,
+        metadata: str | Path | dict[str, Any],
+        year: int,
+        summary: str,
+        internal: bool = True,
+        researcher: str | None = None,
+        organisation: str | None = None,
+    ) -> ProjectManager:
+        if isinstance(metadata, str | Path):
+            metadata = Path(metadata)
+            if not metadata.exists():
+                raise MetadataFileNotFoundErr(str(metadata))
+            with metadata.open("r") as file:
+                _metadata = yaml.load(file)
+        else:
+            _metadata = metadata
+        _metadata.update(
+            {
+                "year": year,
+                "summary": summary,
+                "internal": internal,
+                "researcher": researcher,
+                "organisation": organisation,
+            }
+        )
+        return cls(root=root, metadata=_metadata)
+
+    @classmethod
+    def load_project(
+        cls, project_path: Path | str, metadata_name: str | None = None
+    ) -> ProjectManager:
+        project_path = Path(project_path)
+        if not project_path.exists():
+            raise ProjectNotFoundErr(str(project_path))
+        metadata_path = (
+            project_path / cls.METADATA_NAME
+            if not metadata_name
+            else project_path / metadata_name
+        )
+        if not metadata_path.exists():
+            raise MetadataFileNotFoundErr(str(metadata_path))
+        with metadata_path.open("r") as file:
+            metadata = yaml.load(file)
+        return cls(metadata=metadata, root=project_path)

appm/model.py

@@ -0,0 +1,82 @@
+from typing import Self
+
+from pydantic import BaseModel, model_validator
+
+from appm.__version__ import __version__
+from appm.utils import slugify
+
+STRUCTURES = {"year", "summary", "internal", "researcher", "organisation"}
+
+
+class ExtDecl(BaseModel):
+    sep: str = "_"
+    format: list[tuple[str, str]]
+
+    @property
+    def fields(self) -> set[str]:
+        return {item[0] for item in self.format}
+
+
+class NamingConventionDecl(BaseModel):
+    sep: str = "_"
+    structure: list[str] = ["year", "summary", "internal", "researcher", "organisation"]
+
+    @model_validator(mode="after")
+    def validate_structure_values(self) -> Self:
+        counter: dict[str, int] = {}
+        if len(self.structure) == 0:
+            raise ValueError("Invalid naming structure - empty structure")
+        for field in self.structure:
+            counter[field] = counter.get(field, 0) + 1
+            if counter[field] > 1:
+                raise ValueError(f"Invalid naming structure - repetition: {field}")
+            if field not in STRUCTURES:
+                raise ValueError(
+                    f"Invalid naming structure - invalid field: {field}. Structure must be a non empty permutation of {STRUCTURES}"
+                )
+        return self
+
+
+class ProjectDecl(BaseModel):
+    layout: list[str]
+    file: dict[str, ExtDecl]
+    naming_convention: NamingConventionDecl = NamingConventionDecl()
+
+    @property
+    def layout_set(self) -> set[str]:
+        return set(self.layout)
+
+    @model_validator(mode="after")
+    def validate_format_and_layout(self) -> Self:
+        for ext, decl in self.file.items():
+            if not self.layout_set.issubset(decl.fields):
+                raise ValueError(
+                    f"""Format fields must be a superset of layout fields. 
+                    Extension: {ext}. Format fields: {decl.fields}. Layout fields: {self.layout_set}"""
+                )
+        return self
+
+
+class ProjectMetadata(ProjectDecl):
+    year: int
+    summary: str
+    internal: bool
+    researcher: str | None = None
+    organisation: str | None = None
+    version: str | None = __version__
+
+    @property
+    def name(self) -> str:
+        fields = self.naming_convention.structure
+        name: list[str] = []
+        for field in fields:
+            value = getattr(self, field)
+            if value is not None:
+                if isinstance(value, str):
+                    name.append(slugify(value))
+                elif field == "year":
+                    name.append(str(value))
+                elif field == "internal":
+                    value = "internal" if value else "external"
+                    name.append(value)
+        return self.naming_convention.sep.join(name)

appm/utils.py

@@ -0,0 +1,27 @@
+import re
+
+
+def slugify(text: str) -> str:
+    """Generate a slug from a text
+
+    Used for generating project name and url slug
+
+    https://developer.mozilla.org/en-US/docs/Glossary/Slug
+
+    Example:
+    - The Plant Accelerator -> the-plant-accelerator
+
+    - APPN -> appn
+
+    Args:
+        text (str): source text
+
+    Returns:
+        str: slug
+    """
+    text = text.lower()
+    # Replace non slug characters
+    text = re.sub(r"[^\w\s-]", "", text, flags=re.UNICODE)
+    # Replace spaces with hyphens
+    text = re.sub(r"[\s\-]+", "-", text)
+    return text.strip("-")

appm-0.0.1.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.3
+Name: appm
+Version: 0.0.1
+Summary: APPN Project Manager Package
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: ruamel-yaml>=0.18.14
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+

appm-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+appm/__init__.py,sha256=70a098d1ac000a7e4f9aa72fa542e63b165b884837cf4e5c31a56af7df6fc6db,71
+appm/__version__.py,sha256=b172e1ee0dca0b84021717191814e91b6b1c47b866981b0c8eae8ba91a6d9118,22
+appm/exceptions.py,sha256=3be0e11cfa9cef94fbf2c442f81fc571760f33e26b6fc0b1201b1961057d4d9d,285
+appm/manager.py,sha256=7e1add7d357300aa5e9287bf7683f4ec623ca02cd683f252526f0f416646a594,5633
+appm/model.py,sha256=d5a928f0c07b4927933de7b93fb2efaa3dc631318fe0dcd9b2b14b98d0a4aa1b,2708
+appm/utils.py,sha256=f72c5864d51ce2e37734c7724ca076fb5e5a5ce6d427ca6eeebd10d27511351e,578
+appm-0.0.1.dist-info/WHEEL,sha256=b70116f4076fa664af162441d2ba3754dbb4ec63e09d563bdc1e9ab023cce400,78
+appm-0.0.1.dist-info/METADATA,sha256=408a8aad2d5a60df543a2a24d0323e82534a866cabf8ce75fab757291fb89361,219
+appm-0.0.1.dist-info/RECORD,,

appm-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.3
+Root-Is-Purelib: true
+Tag: py3-none-any