xtce2py 0.1.0__tar.gz

xtce2py-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 nrmiersen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

xtce2py-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: xtce2py
+Version: 0.1.0
+Summary: A generator for creating a Python package from an XTCE file.
+Author-Email: Nathan Miersen <nrmiersen@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Project-URL: Homepage, https://github.com/nrmiersen/xtce2py
+Project-URL: Repository, https://github.com/nrmiersen/xtce2py
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: xsdata>=25.7
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: ruff>=0.12.4
+Requires-Dist: docformatter>=1.7.7
+Requires-Dist: typer[rich]>=0.16.0
+Requires-Dist: setuptools>=80.9.0
+Requires-Dist: lxml>=6.0.0
+Requires-Dist: lxml-stubs>=0.5.1
+Requires-Dist: pydantic-settings>=2.11.0
+Description-Content-Type: text/markdown
+
+# xtce2py
+Generates a Python package from a source XTCE file.
+
+**Alpha Software:** This package is currently in the alpha stage of development. The API is not stable and is subject to breaking changes in future releases. Please use with caution and report any bugs or issues you find.

xtce2py-0.1.0/README.md

@@ -0,0 +1,4 @@
+# xtce2py
+Generates a Python package from a source XTCE file.
+
+**Alpha Software:** This package is currently in the alpha stage of development. The API is not stable and is subject to breaking changes in future releases. Please use with caution and report any bugs or issues you find.

xtce2py-0.1.0/pyproject.toml

@@ -0,0 +1,90 @@
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[project]
+name = "xtce2py"
+version = "0.1.0"
+description = "A generator for creating a Python package from an XTCE file."
+authors = [
+    { name = "Nathan Miersen", email = "nrmiersen@gmail.com" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+]
+dependencies = [
+    "pydantic>=2.11.7",
+    "xsdata>=25.7",
+    "jinja2>=3.1.6",
+    "ruff>=0.12.4",
+    "docformatter>=1.7.7",
+    "typer[rich]>=0.16.0",
+    "setuptools>=80.9.0",
+    "lxml>=6.0.0",
+    "lxml-stubs>=0.5.1",
+    "pydantic-settings>=2.11.0",
+]
+requires-python = ">=3.11"
+readme = "README.md"
+license = "MIT"
+
+[project.scripts]
+xtce2py = "xtce2py.main:app"
+
+[project.urls]
+Homepage = "https://github.com/nrmiersen/xtce2py"
+Repository = "https://github.com/nrmiersen/xtce2py"
+
+[dependency-groups]
+dev = [
+    "xsdata[cli]>=25.7",
+    "bitstring>=4.3.1",
+]
+
+[tool.pdm]
+distribution = true
+
+[tool.pdm.scripts]
+xtce2py = "python -m xtce2py.main"
+
+[tool.setuptools.package-data]
+xtce2py = [
+    "static/*",
+    "templates/*",
+    "xtce_1_1/*.xsd",
+    "xtce_1_2/*.xsd",
+    "xtce_1_3/*.xsd",
+]
+
+[tool.ruff]
+line-length = 88
+exclude = [
+    "src/xtce2py/xtce_1_1/dtc_06_11_06.py",
+    "src/xtce2py/xtce_1_2/dtc_18_02_04.py",
+    "src/xtce2py/xtce_1_3/dtc_25_02_18.py",
+]
+
+[tool.ruff.lint]
+select = [
+    "D",
+    "I",
+]
+ignore = [
+    "D203",
+    "D213",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = [
+    "xtce2py",
+]
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.docformatter]
+wrap-summaries = 72
+wrap-descriptions = 72

xtce2py-0.1.0/src/xtce2py/__init__.py

@@ -0,0 +1,12 @@
+"""Top level package for xtce2py."""
+
+from xtce2py import config, generator, xtce_1_1, xtce_1_2, xtce_1_3, xtce_common
+
+__all__ = [
+    "config",
+    "generator",
+    "xtce_1_1",
+    "xtce_1_2",
+    "xtce_1_3",
+    "xtce_common",
+]

xtce2py-0.1.0/src/xtce2py/_validation.py

@@ -0,0 +1,31 @@
+"""Validation-related data structures and exceptions."""
+
+import enum
+from dataclasses import dataclass
+from typing import List
+
+
+class ValidationSeverity(enum.Enum):
+    """Enumeration for the severity of a validation issue."""
+
+    ERROR = "ERROR"
+    WARNING = "WARNING"
+
+
+@dataclass
+class ValidationResult:
+    """A structured container for a single validation finding."""
+
+    severity: ValidationSeverity
+    message: str
+    location: str
+
+
+class XtceSemanticValidationError(Exception):
+    """Custom exception raised when fatal semantic errors are found."""
+
+    def __init__(self, errors: List[ValidationResult]):
+        """Initialize with a list of validation errors."""
+        self.errors = errors
+        error_list = "\n".join(f"  - [in {e.location}]: {e.message}" for e in errors)
+        super().__init__(f"XTCE file has semantic validation errors:\n{error_list}")

xtce2py-0.1.0/src/xtce2py/config.py

@@ -0,0 +1,88 @@
+"""Global configuration settings."""
+
+import functools
+from pathlib import Path
+from typing import Literal
+
+from pydantic import BaseModel, field_validator
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+    TomlConfigSettingsSource,
+)
+
+
+class LoggingSettings(BaseModel):
+    """Logging configuration settings."""
+
+    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = None
+    file: Path | None = None
+
+    @field_validator("file", mode="before")
+    @classmethod
+    def expand_path(cls, v):
+        """Expand user home directory and resolve path."""
+        if v is None:
+            return v
+        if isinstance(v, str):
+            # Expand ~ to user home directory
+            return Path(v).expanduser()
+        return v
+
+
+class AuthorSettings(BaseModel):
+    """Author information for output package."""
+
+    name: str = "Anonymous"
+    email: str = "user@example.com"
+
+
+class PackageDefaults(BaseModel):
+    """Default values for package generation."""
+
+    suffix: str = "toolkit"
+    version: str = "1.0.0"
+    license: str = "MIT"
+
+
+class NamingSettings(BaseModel):
+    """Naming conventions for generated package."""
+
+    use_existing_names: bool = True
+    acronyms: list[str] = ["CCSDS"]
+
+
+class Settings(BaseSettings):
+    """Settings model."""
+
+    author: AuthorSettings = AuthorSettings()
+    package_defaults: PackageDefaults = PackageDefaults()
+    naming_convention: NamingSettings = NamingSettings()
+    logging: LoggingSettings = LoggingSettings()
+
+    model_config = SettingsConfigDict(toml_file="xtce2py.toml")
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        """Define the order of precedence for settings sources."""
+        return (
+            init_settings,
+            env_settings,
+            dotenv_settings,
+            file_secret_settings,
+            TomlConfigSettingsSource(settings_cls),
+        )
+
+
+@functools.lru_cache(maxsize=1)
+def get_settings() -> Settings:
+    """Load and validate the settings, then cache the result."""
+    return Settings()

xtce2py-0.1.0/src/xtce2py/context_models.py

@@ -0,0 +1,76 @@
+"""Context models for Jinja2 templates."""
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from xtce2py.xtce_common.context_models import ContainerDetailsContext
+
+
+@dataclass
+class XtceMetadataContext:
+    """Container for XTCE metadata information."""
+
+    name: str = "unknown"
+    description: Optional[str] = ""
+    version: Optional[str] = "1.0.0"
+    date: Optional[str] = ""
+    classification: Optional[str] = ""
+    authors: list[str] = field(default_factory=list)
+    notes: list[str] = field(default_factory=list)
+    history: list[str] = field(default_factory=list)
+
+
+@dataclass
+class PyprojectContext:
+    """Container for the data needed by the pyproject.toml template."""
+
+    dist_name: str
+    package_name: str
+    version: str
+    metadata: XtceMetadataContext
+
+
+@dataclass
+class ReadMeContext:
+    """Container for the data needed by the README.md template."""
+
+    dist_name: str
+    package_name: str
+    xtce_version: str
+    metadata: XtceMetadataContext
+
+
+@dataclass
+class InitContext:
+    """Container for the data needed by the __init__.py template."""
+
+    metadata: XtceMetadataContext
+
+
+@dataclass
+class ModelContext:
+    """Container for the data needed by a model within the models.py template."""
+
+    name: str
+    parent: str = "PacketBase"
+    entries: list[dict[str, Any]] = field(default_factory=list)
+    description: Optional[str] = ""
+
+
+@dataclass
+class ModelsContext:
+    """Container for the data needed by the models.py template."""
+
+    imports: dict[str, list[str]] = field(default_factory=dict)
+    containers: list[ModelContext] = field(default_factory=list)
+
+
+@dataclass
+class ParserContext:
+    """Container for the data needed by the parser template."""
+
+    container_tree: dict[str, Any] = field(default_factory=dict)
+    concrete_container_names: set[str] = field(default_factory=set)
+    container_details_map: dict[str, ContainerDetailsContext] = field(
+        default_factory=dict
+    )

xtce2py-0.1.0/src/xtce2py/generator.py

@@ -0,0 +1,209 @@
+"""Contains the core logic for generating parser package files.
+
+It includes functions for creating directory layouts, rendering Jinja2
+templates, and formatting the final output.
+"""
+
+import importlib.resources as pkg_resources
+import logging
+import shutil
+from pathlib import Path
+from typing import Any
+
+import jinja2
+
+from xtce2py import config, xtce_1_1, xtce_1_2, xtce_1_3
+from xtce2py.context_models import (
+    InitContext,
+    ModelContext,
+    ModelsContext,
+    PyprojectContext,
+    ReadMeContext,
+)
+
+log = logging.getLogger(__name__)
+
+
+def setup_jinja_environment() -> jinja2.Environment:
+    """Set up the Jinja2 environment for template rendering."""
+    template_dir_ref = pkg_resources.files("xtce2py").joinpath("templates")
+
+    with pkg_resources.as_file(template_dir_ref) as template_dir:
+        loader = jinja2.FileSystemLoader(template_dir)
+
+    return jinja2.Environment(loader=loader)
+
+
+TEMPLATE_ENV = setup_jinja_environment()
+STATIC_FILE_MAP = [
+    ("setup.py", "setup.py"),
+    ("_decoding.py", "src/{package_name}/_decoding.py"),
+]
+
+
+def create_project_names(
+    space_system_name: str, package_name_suffix: str
+) -> tuple[str, str]:
+    """Create a package name based on the space system's name."""
+    dist_name = f"{space_system_name.lower().replace(' ', '-').replace('_', '-')}-{package_name_suffix}"
+    package_name = f"{space_system_name.lower().replace(' ', '_').replace('-', '_')}_{package_name_suffix}"
+    return dist_name, package_name
+
+
+def create_directory_structure(
+    package_dir: Path,
+    package_name: str,
+    parser: xtce_1_1.XtceParser,  # | xtce_1_2.XtceParser | xtce_1_3.XtceParser,
+) -> None:
+    """Create the necessary directory structure for the generated package."""
+    # Delete existing output directory if it exists
+    if package_dir.exists():
+        for item in package_dir.iterdir():
+            if item.is_dir():
+                shutil.rmtree(item)
+            else:
+                item.unlink()
+    package_dir.mkdir(parents=True, exist_ok=True)
+    (package_dir / "src").mkdir(parents=True, exist_ok=True)
+
+    # Create main package directory
+    main_package_dir = package_dir / "src" / package_name
+    main_package_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create sub-directories for each sub-space system
+    hierarchy = parser.get_space_system_hierarchy()
+    for module_name in hierarchy["sub_systems"].keys():
+        sub_module_dir = main_package_dir / module_name
+        sub_module_dir.mkdir(parents=True, exist_ok=True)
+
+    log.info(f"Generated directory structure at {package_dir}")
+
+
+def copy_static_files(package_dir: Path):
+    """Copy static files to the generated package."""
+    for src_filename, dest_template_path in STATIC_FILE_MAP:
+        dest_path = package_dir / dest_template_path.format(
+            package_name=package_dir.name
+        )
+
+        with pkg_resources.as_file(
+            pkg_resources.files("xtce2py").joinpath(f"static/{src_filename}")
+        ) as src_path:
+            shutil.copy2(src_path, dest_path)
+
+    log.info(f"Copied static files to {package_dir}")
+
+
+def generate_readme(package_dir: Path, readme_context: ReadMeContext):
+    """Generate a README.md file in the output package directory."""
+    template = TEMPLATE_ENV.get_template("README.md.j2")
+
+    generated_code = template.render(context=readme_context)
+
+    output_filename = package_dir / "README.md"
+    with open(output_filename, "w", encoding="utf-8") as f:
+        f.write(generated_code)
+
+    log.info(f"Generated {output_filename.name} at {output_filename}")
+
+
+def generate_pyproject_toml(
+    package_dir: Path,
+    pyproject_context: PyprojectContext,
+):
+    """Generate a pyproject.toml file in the output package directory."""
+    template = TEMPLATE_ENV.get_template("pyproject.toml.j2")
+
+    generated_code = template.render(context=pyproject_context)
+
+    output_filename = package_dir / "pyproject.toml"
+    with open(output_filename, "w", encoding="utf-8") as f:
+        f.write(generated_code)
+
+    log.info(f"Generated {output_filename.name} at {output_filename}")
+
+
+def generate_init(
+    package_src_dir: Path,
+    init_context: InitContext,
+    parser: xtce_1_1.XtceParser,  # | xtce_1_2.XtceParser | xtce_1_3.XtceParser,
+):
+    """Generate a __init__.py file in the output src directory."""
+    template = TEMPLATE_ENV.get_template("__init__.py.j2")
+
+    model_class_names = [
+        container.name for container in parser.generate_model_context()
+    ]
+    public_api_names = ["parse_packet", "parse_packets", "PacketBase"]
+    all_public_names = sorted(model_class_names + public_api_names)
+
+    generated_code = template.render(
+        context=init_context,
+        model_class_names=model_class_names,
+        all_public_names=all_public_names,
+    )
+
+    output_filename = package_src_dir / "__init__.py"
+    with open(output_filename, "w", encoding="utf-8") as f:
+        f.write(generated_code)
+
+    log.info(f"Generated {output_filename.name} at {output_filename}")
+
+
+def generate_models(
+    package_src_dir: Path,
+    parser: xtce_1_1.XtceParser,  # | xtce_1_2.XtceParser | xtce_1_3.XtceParser,
+):
+    """Generate models.py files for the main package and sub-systems."""
+    template = TEMPLATE_ENV.get_template("models.py.j2")
+
+    hierarchy = parser.get_space_system_hierarchy()
+
+    # Generate models for the root space system
+    root_system = hierarchy["root"]
+    models_context = ModelsContext(
+        imports={
+            "typing": ["Literal"],
+            "pydantic": ["BaseModel", "Field", "field_validator"],
+        },
+        containers=list(parser.generate_model_context()),
+    )
+    generated_code = template.render(context=models_context)
+
+    output_filename = package_src_dir / "models.py"
+    with open(output_filename, "w", encoding="utf-8") as f:
+        f.write(generated_code)
+
+    log.info(f"Generated {output_filename.name} at {output_filename}")
+
+    # Generate models for each sub-system in separate modules
+    for module_name, sub_system in hierarchy["sub_systems"].items():
+        print(f"Generating models for sub-system: {sub_system.name} -> {module_name}")
+        sub_module_dir = package_src_dir / module_name
+        # TODO: Generate models.py in sub_module_dir
+
+
+def generate_parser(
+    package_src_dir: Path,
+    parser: xtce_1_1.XtceParser,  # | xtce_1_2.XtceParser | xtce_1_3.XtceParser,
+):
+    """Generate a parser.py file in the output src directory."""
+    if parser.is_simple_dispatcher:
+        log.info("Generating simple dispatcher parser.")
+        # template = TEMPLATE_ENV.get_template("simple_parser.py.j2") # TODO
+        template = TEMPLATE_ENV.get_template("tree_parser.py.j2")
+    else:
+        log.info("Generating tree parser.")
+        template = TEMPLATE_ENV.get_template("tree_parser.py.j2")
+
+    parser_context = parser.generate_parser_context()
+
+    generated_code = template.render(
+        context=parser_context, dispatcher_parameter=parser.dispatcher_parameter
+    )
+
+    output_filename = package_src_dir / "parser.py"
+    with open(output_filename, "w", encoding="utf-8") as f:
+        f.write(generated_code)
+
+    log.info(f"Generated {output_filename.name} at {output_filename}")