aas-core-codegen 0.0.16__py3-none-any.whl

aas_core_codegen-0.0.16.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aas_core_codegen-0.0.16.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+aas-core-codegen = aas_core_codegen.main:entry_point
+aas-core-codegen-smoke = aas_core_codegen.smoke.main:entry_point

aas_core_codegen-0.0.16.dist-info/licenses/AUTHORS

@@ -0,0 +1,9 @@
+Nico Braunisch (nico.braunisch@tu-dresden.de) for Dresden University of Technology - Institute of Applied Computer Science 
+Tom Gneuss (tom.gneuss@tu-dresden.de) for Dresden University of Technology - Institute of Applied Computer Science 
+Elodie Thiéblin (elodie.thieblin@logilab.fr) for Logilab and Siemens AG
+Fabien Amarger (fabien.amarger@logilab.fr) for Logilab and Siemens AG
+Igor Garmaev (i.garmaev@iat.rwth-aachen.de) for RWTH Aachen
+Marko Ristin (marko@ristin.ch, marko.ristin@gmail.com, rist@zhaw.ch) for Zurich University of Applied Sciences (ZHAW)
+Sebastian Heppner (s.heppner@iat.rwth-aachen.de) for RWTH Aachen
+Markus Böhm (Markus.Boehm@conplement.de) for conplement AG
+Tobias Langer (Tobias.Langer@conplement.de) for conplement AG

aas_core_codegen-0.0.16.dist-info/licenses/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2023 aas-core-codegen AUTHORS
+
+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.
+
+Please see the file AUTHORS for the full list of the authors of aas-core3.0-codegen.

aas_core_codegen-0.0.16.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+aas_core_codegen
+dev

dev/continuous_integration/__init__.py

@@ -0,0 +1 @@
+"""Provide scripts for the continuous integration."""

dev/continuous_integration/check_help_in_readme.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+
+"""Check that the help snippets in the Readme coincide with the actual output."""
+import argparse
+import difflib
+import os
+import pathlib
+import re
+import subprocess
+import sys
+from typing import List, Tuple, Optional
+
+import icontract
+
+
+class Block:
+    """Represent a block in the readme that needs to be checked."""
+
+    @icontract.require(lambda command: command != "")
+    @icontract.require(
+        lambda start_line_idx, end_line_idx: start_line_idx <= end_line_idx
+    )
+    def __init__(self, command: str, start_line_idx: int, end_line_idx: int) -> None:
+        """
+        Initialize with the given values.
+
+        :param command: help command
+        :param start_line_idx: index of the first relevant line
+        :param end_line_idx: index of the first line excluded from the block
+        """
+        self.command = command
+        self.start_line_idx = start_line_idx
+        self.end_line_idx = end_line_idx
+
+
+HELP_STARTS_RE = re.compile(r"^.. Help starts: (?P<command>.*)$")
+
+
+def parse_readme(lines: List[str]) -> Tuple[List[Block], List[str]]:
+    """
+    Parse the code blocks that represent help commands in the Readme.
+
+    :param lines: lines of the readme file
+    :return: (help blocks, errors if any)
+    """
+    blocks = []  # type: List[Block]
+    errors = []  # type: List[str]
+
+    i = 0
+    while i < len(lines):
+        mtch = HELP_STARTS_RE.match(lines[i])
+        if mtch:
+            command = mtch.group("command")
+            help_ends = ".. Help ends: {}".format(command)
+            try:
+                end_index = lines.index(help_ends, i)
+            except ValueError:
+                end_index = -1
+
+            if end_index == -1:
+                return [], [
+                    "Could not find_our_type the end marker {!r}".format(help_ends)
+                ]
+
+            blocks.append(
+                Block(command=command, start_line_idx=i + 1, end_line_idx=end_index)
+            )
+
+            i = end_index + 1
+
+        else:
+            i += 1
+
+    return blocks, errors
+
+
+def capture_output_lines(command: str) -> List[str]:
+    """Capture the output of a help command."""
+    command_parts = command.split(" ")
+    if command_parts[0] in ["python", "python3"]:
+        # We need to replace "python" with "sys.executable" on Windows as
+        # the environment is not properly inherited.
+        command_parts[0] = sys.executable
+
+    proc = None  # type: Optional[subprocess.Popen[str]]
+    try:
+        proc = subprocess.Popen(
+            command_parts,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            encoding="utf-8",
+        )
+    except Exception as exception:
+        raise RuntimeError(
+            f"Failed to start the command {command_parts!r} "
+            f"derived from the command {command!r} in the document"
+        ) from exception
+
+    assert proc is not None
+    with proc:
+        output, err = proc.communicate()
+        if err:
+            raise RuntimeError(
+                f"The command {command!r} failed with exit code {proc.returncode} and "
+                f"stderr:\n{err}"
+            )
+
+        return output.splitlines()
+
+
+def output_lines_to_code_block(output_lines: List[str]) -> List[str]:
+    """Translate the output of a help command to a RST code block."""
+    result = (
+        [".. code-block::", ""]
+        + ["    " + output_line for output_line in output_lines]
+        + [""]
+    )
+
+    result = [line.rstrip() for line in result]
+    return result
+
+
+def report_a_difference(
+    got_lines: List[str], expected_lines: List[str]
+) -> Optional[str]:
+    """
+    Report a difference between the ``got`` and ``expected``.
+
+    Return None if no difference.
+    """
+    if got_lines == expected_lines:
+        return None
+
+    diff = difflib.ndiff(got_lines, expected_lines)
+    return "\n".join(diff)
+
+
+def main() -> int:
+    """Execute the main routine."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--overwrite",
+        help="If set, overwrite the relevant part of README in-place.",
+        action="store_true",
+    )
+
+    args = parser.parse_args()
+    overwrite = bool(args.overwrite)
+
+    repo_root = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent
+    pth = repo_root / "README.rst"
+
+    text = pth.read_text(encoding="utf-8")
+    lines = text.splitlines()
+
+    blocks, errors = parse_readme(lines=lines)
+    if errors:
+        print("One or more errors in {}:".format(pth), file=sys.stderr)
+        for error in errors:
+            print(error, file=sys.stderr)
+
+        return -1
+
+    if len(blocks) == 0:
+        return 0
+
+    if overwrite:
+        result = []  # type: List[str]
+
+        previous_block = None  # type: Optional[Block]
+        for block in blocks:
+            output_lines = capture_output_lines(command=block.command)
+            code_block_lines = output_lines_to_code_block(output_lines=output_lines)
+
+            if previous_block is None:
+                result.extend(lines[: block.start_line_idx])
+            else:
+                result.extend(lines[previous_block.end_line_idx : block.start_line_idx])
+
+            result.extend(code_block_lines)
+            previous_block = block
+
+        assert previous_block is not None
+        result.extend(lines[previous_block.end_line_idx :])
+        result.append("")  # new line at the end of file
+
+        pth.write_text("\n".join(result), encoding="utf-8")
+
+    else:
+        for block in blocks:
+            output_lines = capture_output_lines(command=block.command)
+            code_block_lines = output_lines_to_code_block(output_lines=output_lines)
+
+            expected_lines = lines[block.start_line_idx : block.end_line_idx]
+            expected_lines = [line.rstrip() for line in expected_lines]
+
+            diff_error = report_a_difference(
+                got_lines=code_block_lines, expected_lines=expected_lines
+            )
+            if diff_error is not None:
+                print(diff_error, file=sys.stderr)
+                return -1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dev/continuous_integration/check_init_and_pyproject_consistent.py

@@ -0,0 +1,154 @@
+"""Check that metadata in ``pyproject.toml`` and ``__init__.py`` are consistent."""
+
+import importlib.metadata
+import sys
+from typing import List, TypeVar, Protocol, Iterator, Union, Any, Optional, cast
+
+import aas_core_codegen
+
+# NOTE (mristin):
+# We found the official PackageMetadata protocol to be unreliable, so we wrote our
+# own, closer to the actual implementation.
+
+_T = TypeVar("_T")
+
+
+class PackageMetadata(Protocol):  # pylint: disable=missing-docstring
+    def get_all(self, name: str, failobj: _T = ...) -> Union[List[Any], _T]:
+        """
+        Return all values associated with a possibly multi-valued key.
+        """
+
+    def __getitem__(self, key: str) -> Optional[str]:
+        ...  # pragma: no cover
+
+    def __iter__(self) -> Iterator[str]:
+        ...  # pragma: no cover
+
+    def __contains__(self, item: str) -> bool:
+        ...  # pragma: no cover
+
+    def __len__(self) -> int:
+        ...  # pragma: no cover
+
+
+def _extract_authors(metadata: PackageMetadata) -> List[str]:
+    """Extract author names listed in the metadata."""
+    author_email = metadata["Author-Email"]
+
+    authors = []
+    if author_email is not None:
+        # We parse "Name <email>, Name <email>" format.
+        for entry in author_email.split(","):
+            entry = entry.strip()
+            if "<" in entry:
+                name = entry.split("<")[0].strip()
+                if name:
+                    authors.append(name)
+            else:
+                authors.append(entry)
+
+    # We also check Author field as a fallback.
+    try:
+        author = metadata["Author"]
+    except KeyError:
+        author = None
+
+    if author is not None and len(authors) == 0:
+        authors = [author.strip()]
+
+    return authors
+
+
+def _extract_status_from_classifiers(
+    metadata: PackageMetadata,
+) -> str:
+    """Extract development status from classifiers listed in the metadata."""
+    classifiers = metadata.get_all("Classifier") or []
+
+    for classifier in classifiers:
+        assert isinstance(classifier, str)
+
+        if classifier.startswith("Development Status"):
+            parts = classifier.split("::")
+            if len(parts) >= 2:
+                status = parts[1].strip()
+                # We extract just the status part (e.g.,
+                # "5 - Production/Stable" -> "Production/Stable")
+                if " - " in status:
+                    return status.split(" - ", 1)[1]
+                return status
+    return ""
+
+
+def _extract_license_from_classifiers(
+    metadata: PackageMetadata,
+) -> str:
+    """Extract license from classifiers listed in the metadata."""
+    classifiers = metadata.get_all("Classifier") or []
+
+    for classifier in classifiers:
+        assert isinstance(classifier, str)
+
+        if classifier.startswith("License"):
+            return classifier
+    return ""
+
+
+def main() -> None:
+    """Execute the main routine."""
+    errors = []
+
+    metadata = cast(PackageMetadata, importlib.metadata.metadata("aas-core-codegen"))
+
+    # Check version
+    init_version = aas_core_codegen.__version__
+    pyproject_toml_version = metadata["version"]
+
+    if init_version != pyproject_toml_version:
+        errors.append(
+            f"Version mismatch: __init__.py has {init_version!r}, "
+            f"pyproject.toml has {pyproject_toml_version!r}"
+        )
+
+    # Check authors
+    init_authors = [author.strip() for author in aas_core_codegen.__author__.split(",")]
+    pyproject_authors = _extract_authors(metadata=metadata)
+
+    if init_authors != pyproject_authors:
+        errors.append(
+            f"Authors mismatch: __init__.py has {init_authors!r}, "
+            f"pyproject.toml has {pyproject_authors!r}"
+        )
+
+    # Check development status
+    init_status = aas_core_codegen.__status__
+    pyproject_status = _extract_status_from_classifiers(metadata=metadata)
+
+    if init_status != pyproject_status:
+        errors.append(
+            f"Status mismatch: __init__.py has {init_status!r}, "
+            f"pyproject.toml classifiers have {pyproject_status!r}"
+        )
+
+    # Check license
+    init_license = aas_core_codegen.__license__
+    pyproject_license = _extract_license_from_classifiers(metadata=metadata)
+
+    if init_license != pyproject_license:
+        errors.append(
+            f"License mismatch: __init__.py has {init_license!r}, "
+            f"pyproject.toml classifiers have {pyproject_license!r}"
+        )
+
+    if errors:
+        print("Metadata consistency check failed:", file=sys.stderr)
+        for error in errors:
+            print(f"  {error}", file=sys.stderr)
+        sys.exit(1)
+
+    print("All meta-data fields are consistent between __init__.py and pyproject.toml")
+
+
+if __name__ == "__main__":
+    main()