specitems 1.4.2__tar.gz → 1.4.4__tar.gz

{specitems-1.4.2 → specitems-1.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specitems
-Version: 1.4.2
+Version: 1.4.4
 Summary: Provides interfaces to work with specification items.
 Keywords: certification,documentation,markdown,qualification,requirements-management,traceability
 Author: The specitems Authors

{specitems-1.4.2 → specitems-1.4.4}/pyproject.toml

@@ -4,7 +4,7 @@
 
 [project]
 name = "specitems"
-version = "1.4.2"
+version = "1.4.4"
 description = "Provides interfaces to work with specification items."
 authors = [
     {name = "The specitems Authors", email = "specthings@embedded-brains.de"}
@@ -56,7 +56,7 @@ spechash = "specitems.clihash:clihash"
 specyamlquery = "specitems.cliyamlquery:cliyamlquery"
 
 [build-system]
-requires = ["uv_build>=0.10.0,<0.11.0"]
+requires = ["uv_build>=0.10.0"]
 build-backend = "uv_build"
 
 [dependency-groups]

{specitems-1.4.2 → specitems-1.4.4}/src/specitems/__init__.py

@@ -26,11 +26,13 @@
 
 from .cite import BibTeXCitationProvider
 from .cliutil import (
+    LoggingStatus,
     create_config,
     get_arguments,
     get_item_cache_arguments,
     init_logging,
     load_config,
+    monitor_logging,
 )
 from .content import (
     Content,
@@ -56,6 +58,10 @@ from .contenttext import (
     latex_escape,
     make_label,
 )
+from .contentcommonmark import (
+    CommonMarkContent,
+    CommonMarkMapper,
+)
 from .contentmarkdown import (
     MarkdownContent,
     MarkdownMapper,
@@ -129,7 +135,6 @@ from .specdoc import (SpecDocumentConfig, add_specification_documentation,
                       generate_specification_documentation)
 from .specverify import (
     SpecVerifier,
-    VerifyStatus,
     verify_specification_format,
 )
 from .subprocessaction import (
@@ -140,6 +145,8 @@ from .subprocessaction import (
 __all__ = [
     "BibTeXCitationProvider",
     "COL_SPAN",
+    "CommonMarkContent",
+    "CommonMarkMapper",
     "Content",
     "ContentAddContext",
     "Copyright",
@@ -170,6 +177,7 @@ __all__ = [
     "ItemViewGetMissing",
     "JSONItemCache",
     "Link",
+    "LoggingStatus",
     "MARKDOWN_ROLES",
     "MarkdownContent",
     "MarkdownMapper",
@@ -181,7 +189,6 @@ __all__ = [
     "SphinxMapper",
     "TextContent",
     "TextMapper",
-    "VerifyStatus",
     "add_specification_documentation",
     "augment_glossary_terms",
     "base64_to_hex",
@@ -219,6 +226,7 @@ __all__ = [
     "make_lines",
     "make_subprocess_environment",
     "make_text",
+    "monitor_logging",
     "pickle_load_data_by_uid",
     "run_subprocess_action",
     "save_data",

{specitems-1.4.2 → specitems-1.4.4}/src/specitems/cliutil.py

@@ -25,10 +25,12 @@
 # POSSIBILITY OF SUCH DAMAGE.
 
 import argparse
+import contextlib
 import itertools
 import logging
 import os
-from typing import Any, Callable, Iterable, Optional, Type, TypeVar
+from typing import (Any, Callable, Iterable, Iterator, NamedTuple, Optional,
+                    Type, TypeVar)
 
 import yaml
 
@@ -142,6 +144,70 @@ def init_logging(args: argparse.Namespace) -> None:
                         handlers=handlers)
 
 
+class LoggingStatus(NamedTuple):
+    """Counts of log messages grouped by severity.
+
+    Attributes:
+        critical: Number of CRITICAL messages.
+        error: Number of ERROR messages.
+        warning: Number of WARNING messages.
+        info: Number of INFO messages.
+        debug: Number of DEBUG messages.
+    """
+    critical: int
+    error: int
+    warning: int
+    info: int
+    debug: int
+
+
+class LogMonitor(logging.Filter):
+    """ Monitors log messages grouped by severity. """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._counts: dict[int, int] = {}
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Count the given logging record and allow propagation.
+
+        Args:
+            record: The logging record to count.
+
+        Returns:
+            True so the log record is processed by the logging system.
+        """
+        count = self._counts.get(record.levelno, 0)
+        self._counts[record.levelno] = count + 1
+        return True
+
+    def get_status(self) -> LoggingStatus:
+        """Return a LoggingStatus summarizing collected log counts.
+
+        Returns:
+            Aggregated counts for each standard logging level.
+        """
+        return LoggingStatus(self._counts.get(logging.CRITICAL, 0),
+                             self._counts.get(logging.ERROR, 0),
+                             self._counts.get(logging.WARNING, 0),
+                             self._counts.get(logging.INFO, 0),
+                             self._counts.get(logging.DEBUG, 0))
+
+
+@contextlib.contextmanager
+def monitor_logging() -> Iterator[LogMonitor]:
+    """
+    Monitors the logging and counts the log records grouped by severity.
+    """
+    logger = logging.getLogger()
+    monitor = LogMonitor()
+    logger.addFilter(monitor)
+    try:
+        yield monitor
+    finally:
+        logger.removeFilter(monitor)
+
+
 def load_config(config_filename: str) -> Any:
     """ Loads the configuration file with recursive includes. """
 

specitems-1.4.4/src/specitems/contentcommonmark.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: BSD-2-Clause
+""" Provides interfaces for CommonMark content generation. """
+
+# Copyright (C) 2025, 2026 embedded brains GmbH & Co. KG
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+from typing import Iterable, Optional, Sequence
+
+from .content import GenericContent, make_lines
+from .contentmarkdown import MarkdownContent
+from .contenttext import COL_SPAN, ROW_SPAN, TextContent, TextMapper
+
+
+def _make_simple(cell: str | int) -> str:
+    if isinstance(cell, str):
+        return cell
+    if cell == COL_SPAN | ROW_SPAN:
+        return "↖"
+    if cell == ROW_SPAN:
+        return "←"
+    return "↑"
+
+
+class CommonMarkContent(MarkdownContent):
+    """ This class builds CommonMark content. """
+
+    def reference(self, label: str, name: Optional[str] = None) -> str:
+        if not name:
+            name = label
+        return self.link(name, f"#{label}")
+
+    def term(self, text: str, term: str | None = None) -> str:
+        return text
+
+    def cite(self, identifier: str) -> str:
+        return ""
+
+    def add_label(self, label: str) -> None:
+        self.add(f"<a id=\"{label.strip()}\"></a>")
+
+    def add_rubric(self, name: str) -> None:
+        self.add([self.strong(name), ""])
+
+    def add_image(self, base: str, width: Optional[str] = None) -> None:
+        self.add(f"![]({base})")
+
+    def add_index_entries(self, entries: list[str]) -> None:
+        pass
+
+    def open_directive(self,
+                       name: str,
+                       value: Optional[str] = None,
+                       options: Optional[list[str]] = None) -> None:
+        self.add(f"```{name.strip()}")
+        self.gap = False
+
+    def add_simple_table(self,
+                         rows: Sequence[Iterable[str]],
+                         widths: Optional[list[int]] = None,
+                         font_size: Optional[str | int] = None) -> None:
+        super().add_simple_table(rows)
+
+    def add_grid_table(self,
+                       rows: Sequence[Iterable[str | int]],
+                       widths: Optional[list[int]] = None,
+                       header_rows: int = 1,
+                       font_size: Optional[str | int] = None) -> None:
+        if not rows:
+            return
+        simple_rows = [
+            tuple(_make_simple(cell) for cell in row) for row in rows
+        ]
+        self.add_simple_table(simple_rows)
+
+    def add_definition_item(self, name: GenericContent,
+                            definition: GenericContent) -> None:
+        self.add(f"{self.strong(', '.join(make_lines(name)))}:")
+        self.append(definition)
+
+    def add_glossary_term(self, term: str, definition: str) -> None:
+        self.add_definition_item(term, definition)
+
+    def add_code_block(self,
+                       code: list[str],
+                       language: str = "none",
+                       font_size: str | int = "footnotesize",
+                       line_number_start: int = 1) -> None:
+        with self.directive(language):
+            self.append(code)
+
+
+class CommonMarkMapper(TextMapper):
+    """ Provides an item mapper for CommonMark formatted text production. """
+
+    def create_content(
+            self,
+            section_level: int = 0,
+            the_license: str | set[str] | None = None) -> TextContent:
+        return CommonMarkContent(section_level, the_license)

{specitems-1.4.2 → specitems-1.4.4}/src/specitems/specverify.py

@@ -6,7 +6,7 @@ verify that a set of specification items is in line with a specification item
 format specification.  The format specification is defined by specification
 items.  Logging is used for informational messages and for reporting errors
 found during verification.  The result of the format verification is
-represented by a :py:class:`VerifyStatus` object.
+represented by a :py:class:`LoggingStatus` object.
 """
 
 # Copyright (C) 2020, 2026 embedded brains GmbH & Co. KG
@@ -32,65 +32,16 @@ represented by a :py:class:`VerifyStatus` object.
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 
-from contextlib import contextmanager
 import logging
 import re
-from typing import Any, Iterator, NamedTuple
+from typing import Any, NamedTuple
 
+from .cliutil import LoggingStatus, monitor_logging
 from .items import Item, ItemCache
 
 _VerifierMap = dict[str, "_Verifier"]
 
 
-class VerifyStatus(NamedTuple):
-    """Counts of log messages produced by a verification run.
-
-    Attributes:
-        critical: Number of CRITICAL messages.
-        error: Number of ERROR messages.
-        warning: Number of WARNING messages.
-        info: Number of INFO messages.
-        debug: Number of DEBUG messages.
-    """
-    critical: int
-    error: int
-    warning: int
-    info: int
-    debug: int
-
-
-class _Filter(logging.Filter):
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._counts: dict[int, int] = {}
-
-    def filter(self, record: logging.LogRecord) -> bool:
-        """Count the given logging record and allow propagation.
-
-        Args:
-            record: The logging record to count.
-
-        Returns:
-            True so the log record is processed by the logging system.
-        """
-        count = self._counts.get(record.levelno, 0)
-        self._counts[record.levelno] = count + 1
-        return True
-
-    def get_verify_info(self) -> VerifyStatus:
-        """Return a VerifyStatus summarizing collected log counts.
-
-        Returns:
-            Aggregated counts for each standard logging level.
-        """
-        return VerifyStatus(self._counts.get(logging.CRITICAL, 0),
-                            self._counts.get(logging.ERROR, 0),
-                            self._counts.get(logging.WARNING, 0),
-                            self._counts.get(logging.INFO, 0),
-                            self._counts.get(logging.DEBUG, 0))
-
-
 def _type_name(value: Any):
     type_name = type(value).__name__
     if type_name == "NoneType":
@@ -680,15 +631,6 @@ def _gather_item_verifiers(item: Item, verifier_map: _VerifierMap) -> None:
             _create_verifier(link.item, verifier_map)
 
 
-@contextmanager
-def _add_filter() -> Iterator[_Filter]:
-    logger = logging.getLogger()
-    log_filter = _Filter()
-    logger.addFilter(log_filter)
-    yield log_filter
-    logger.removeFilter(log_filter)
-
-
 class SpecVerifier:
     """Orchestrates construction of verifiers from spec items and running
     verification.
@@ -732,31 +674,23 @@ class SpecVerifier:
                 logging.info("type: %s", name)
                 verifier_map[name].resolve_type_refinements()
 
-    def verify_all(self, item_cache: ItemCache) -> VerifyStatus:
+    def verify_all(self, item_cache: ItemCache) -> None:
         """Verify all items in the provided item cache.
 
-        The method installs a logging filter to collect counts, iterates all
-        items in the cache and invokes the root verifier on each item's data.
-
         Args:
             item_cache: The cache containing items to verify.
-
-        Returns:
-            Status with counts of messages emitted during verification.
         """
-        with _add_filter() as log_filter:
-            if self._root_verifier is None:
-                logging.error("root type item does not exist in item cache")
-            else:
-                logging.info("start specification item verification")
-                for key in sorted(item_cache):
-                    item = item_cache[key]
-                    self._root_verifier.verify(_Path(item, f"{item.uid}:"),
-                                               item.data)
-                logging.info("finished specification item verification")
-        return log_filter.get_verify_info()
-
-    def verify(self, item: Item) -> VerifyStatus:
+        if self._root_verifier is None:
+            logging.error("root type item does not exist in item cache")
+        else:
+            logging.info("start specification item verification")
+            for key in sorted(item_cache):
+                item = item_cache[key]
+                self._root_verifier.verify(_Path(item, f"{item.uid}:"),
+                                           item.data)
+            logging.info("finished specification item verification")
+
+    def verify(self, item: Item) -> LoggingStatus:
         """Verify the item format.
 
         Args:
@@ -765,16 +699,16 @@ class SpecVerifier:
         Returns:
             Status with counts of messages emitted during verification.
         """
-        with _add_filter() as log_filter:
+        with monitor_logging() as monitor:
             if self._root_verifier is None:
                 logging.error("root type item does not exist in item cache")
             else:
                 self._root_verifier.verify(_Path(item, f"{item.uid}:"),
                                            item.data)
-        return log_filter.get_verify_info()
+            return monitor.get_status()
 
 
-def verify_specification_format(item_cache: ItemCache) -> VerifyStatus:
+def verify_specification_format(item_cache: ItemCache) -> LoggingStatus:
     """Verify all items using the specification root type from the item cache.
 
     Emits an error if the item cache has no specification root type.
@@ -785,9 +719,11 @@ def verify_specification_format(item_cache: ItemCache) -> VerifyStatus:
     Returns:
         The status summarizing the verification run.
     """
-    root_type_uid = item_cache.type_provider.root_type_uid
-    if root_type_uid is None:
-        logging.error("item cache has no root type")
-        return VerifyStatus(0, 1, 0, 0, 0)
-    verifier = SpecVerifier(item_cache, root_type_uid)
-    return verifier.verify_all(item_cache)
+    with monitor_logging() as monitor:
+        root_type_uid = item_cache.type_provider.root_type_uid
+        if root_type_uid is None:
+            logging.error("item cache has no root type")
+        else:
+            verifier = SpecVerifier(item_cache, root_type_uid)
+            verifier.verify_all(item_cache)
+        return monitor.get_status()