shacl2code 1.0.0__tar.gz → 1.1.0__tar.gz

{shacl2code-1.0.0 → shacl2code-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shacl2code
-Version: 1.0.0
+Version: 1.1.0
 Summary: Convert SHACL model file to code bindings
 Project-URL: Homepage, https://github.com/JPEWdev/shacl2code
 Project-URL: Repository, https://github.com/JPEWdev/shacl2code.git
@@ -25,13 +25,14 @@ Requires-Dist: rdflib>=7.0.0
 Provides-Extra: dev
 Requires-Dist: flake8-import-order>=0.19.2; extra == 'dev'
 Requires-Dist: flake8>=7.0.0; extra == 'dev'
-Requires-Dist: jsonschema>=4.21.1; extra == 'dev'
+Requires-Dist: jsonschema>=4.23.0; extra == 'dev'
 Requires-Dist: mypy>=1.14.1; extra == 'dev'
 Requires-Dist: pyrefly>=0.55.0; extra == 'dev'
 Requires-Dist: pyright>=1.1.403; extra == 'dev'
 Requires-Dist: pyshacl>=0.25.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.1; extra == 'dev'
 Requires-Dist: pytest>=7.4; extra == 'dev'
+Requires-Dist: types-jsonschema>=4.23.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Convert SHACL Model to code bindings

{shacl2code-1.0.0 → shacl2code-1.1.0}/pyproject.toml

@@ -30,13 +30,14 @@ license = "MIT"
 dev = [
     "flake8 >= 7.0.0",
     "flake8-import-order >= 0.19.2",
-    "jsonschema >= 4.21.1",
+    "jsonschema >= 4.23.0",  # latest version for Python 3.8 is 4.23.x
     "mypy >= 1.14.1",  # latest version for Python 3.8 is 1.14.x
     "pyrefly >= 0.55.0",
     "pyright >= 1.1.403",
     "pyshacl >= 0.25.0",
     "pytest >= 7.4",
     "pytest-cov >= 4.1",
+    "types-jsonschema >= 4.23.0",
 ]
 
 [project.urls]
@@ -54,6 +55,22 @@ build-backend = "hatchling.build"
 [tool.hatch.version]
 path = "src/shacl2code/version.py"
 
+[tool.mypy]
+disallow_incomplete_defs = true
+# disallow_untyped_defs = true
+extra_checks = true
+mypy_path = ["testfixtures"]
+pretty = true
+show_column_numbers = true
+# strict = true
+strict_bytes = true
+# strict_equality = true
+# strict_equality_for_none = true
+warn_redundant_casts = true
+# warn_return_any = true
+# warn_unreachable = true
+# warn_unused_ignores = true
+
 [tool.pytest.ini_options]
 addopts = [
     "--import-mode=importlib",

{shacl2code-1.0.0 → shacl2code-1.1.0}/src/shacl2code/lang/common.py

@@ -57,7 +57,7 @@ class JinjaTemplateRender(object):
         if render_args is None:
             render_args = {}  # pragma: no cover
 
-        def abort_helper(msg: str):
+        def abort_helper(msg: str) -> None:
             raise TemplateRuntimeError(msg)
 
         env = Environment(loader=FileSystemLoader([template.parent, THIS_DIR.parent]))

{shacl2code-1.0.0 → shacl2code-1.1.0}/src/shacl2code/lang/python.py

@@ -9,6 +9,7 @@ from pathlib import Path
 
 from .common import JinjaTemplateRender
 from .lang import TEMPLATE_DIR, language
+from ..util import convert_version_string
 
 DATATYPE_CLASSES = {
     "http://www.w3.org/2001/XMLSchema#string": "StringProp",
@@ -35,6 +36,30 @@ DATATYPE_PYTHON_TYPES = {
 }
 
 
+SHACLOBJECT_RESERVED_WORDS = {
+    "AUTO_NAMED_INDIVIDUALS",
+    "CLASSES",
+    "COMPACT_TYPE",
+    "ID_ALIAS",
+    "IS_ABSTRACT",
+    "IS_DEPRECATED",
+    "NAMED_INDIVIDUALS",
+    "NODE_KIND",
+    "PROPERTIES",
+    "TYPE",
+    "decode",
+    "encode",
+    "get_compact_type",
+    "get_id",
+    "get_type",
+    "iter_objects",
+    "link_helper",
+    "property_keys",
+    "set_id",
+    "walk",
+}
+
+
 def varname(*name):
     """Make a valid Python variable name."""
     name = "_".join(name)
@@ -44,8 +69,8 @@ def varname(*name):
     name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
     # Consolidate runs of "_" to a single one
     name = re.sub(r"__+", "_", name)
-    # Add a _ to anything that is a python keyword
-    while keyword.iskeyword(name):
+    # Append '_' to avoid collisions with Python or SHACLObject keywords
+    while keyword.iskeyword(name) or name in SHACLOBJECT_RESERVED_WORDS:
         name = name + "_"
     return name
 
@@ -58,16 +83,20 @@ class PythonRender(JinjaTemplateRender):
 
     FILES = (
         "__init__.py",
-        "__main__.py",
-        "cmd.py",
         "model.py",
-        "stub.pyi",
+        "model.pyi",
     )
 
     def __init__(self, args):
         super().__init__(args)
         self.__output = args.output
         self.__use_slots = args.use_slots
+        self.__include_main = args.include_main == "yes"
+        self.__version_str = args.version
+        if args.version:
+            self.__version = repr(convert_version_string(args.version))
+        else:
+            self.__version = ""
 
     @classmethod
     def get_arguments(cls, parser):
@@ -78,6 +107,12 @@ class PythonRender(JinjaTemplateRender):
             help="Output directory",
             required=True,
         )
+        parser.add_argument(
+            "--include-main",
+            choices=("yes", "no"),
+            default="yes",
+            help="Generate a main function for the module. Default is '%(default)s'",
+        )
         parser.add_argument(
             "--use-slots",
             choices=("auto", "yes", "no"),
@@ -87,13 +122,24 @@ class PythonRender(JinjaTemplateRender):
                 "Slots prevents multiple inheritance. Default is %(default)s"
             ),
         )
+        parser.add_argument(
+            "--version",
+            help="Specify model version",
+        )
 
     def get_outputs(self):
         t = TEMPLATE_DIR / "python"
         self.__output.mkdir(parents=True, exist_ok=True)
 
+        def get_file(name):
+            return self.__output / name, t / (name + ".j2"), {}
+
         for s in self.FILES:
-            yield self.__output / s, t / (s + ".j2"), {}
+            yield get_file(s)
+
+        if self.__include_main:
+            yield get_file("cmd.py")
+            yield get_file("__main__.py")
 
     def get_extra_env(self):
         return {
@@ -111,4 +157,7 @@ class PythonRender(JinjaTemplateRender):
             use_slots = False
         return {
             "use_slots": use_slots,
+            "include_main": self.__include_main,
+            "version_str": self.__version_str,
+            "version": self.__version,
         }

shacl2code-1.1.0/src/shacl2code/lang/templates/python/__init__.py.j2

@@ -0,0 +1,15 @@
+#! /usr/bin/env python3
+#
+# {{ disclaimer }}
+#
+# SPDX-License-Identifier: {{ spdx_license }}
+
+from .model import *  # noqa: F401, F403
+
+# fmt: off
+"""Format Guard{{ '"' }}{{ '"' }}{{ '"' }}
+{%- if include_main %}
+from .cmd import main  # noqa: F401, I100, I202
+{%- endif %}
+{{ '"' }}{{ '"' }}{{ '"' }}Format Guard"""
+# fmt on

{shacl2code-1.0.0 → shacl2code-1.1.0}/src/shacl2code/lang/templates/python/model.py.j2

@@ -21,22 +21,26 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from enum import Enum
-from typing import Generic, TYPE_CHECKING, TypeVar, Union, cast, overload
-
-if TYPE_CHECKING:
-    from typing import (
-        Any,
-        BinaryIO,
-        Callable,
-        Dict,
-        Iterable,
-        Iterator,
-        List,
-        Optional,
-        Set,
-        Tuple,
-        Type,
-    )
+from typing import (
+    Any,
+    BinaryIO,
+    Callable,
+    ClassVar,
+    Dict,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Set,
+    TYPE_CHECKING,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
 
 T_PropV = TypeVar("T_PropV")
 
@@ -60,7 +64,7 @@ class Property(ABC, Generic[T_PropV]):
     class
     """
 
-    VALID_TYPES: Union[Type[Any], Tuple[Type[Any], ...]] = ()
+    VALID_TYPES: ClassVar[Union[Type[Any], Tuple[Type[Any], ...]]] = ()
 
     __slots__ = ("pattern",)
 
@@ -713,6 +717,11 @@ def is_blank_node(s: Any) -> bool:
 # fmt: off
 """Format Guard{{ '"' }}{{ '"' }}{{ '"' }}
 _USE_SLOTS = {{ use_slots }}
+{% if version_str %}
+VERSION_STRING = "{{ version_str }}"
+{% endif %}{% if version %}
+VERSION = {{ version }}
+{% endif %}
 {{ '"' }}{{ '"' }}{{ '"' }}Format Guard"""
 # fmt: on
 
@@ -740,7 +749,7 @@ class SHACLObjectMeta(type):
     """Metaclass for SHACLObject that processes PROPERTIES, slots, and named individuals at class creation time."""
 
     def __new__(cls, name, bases, attrs):
-        def check_base_prop(name):
+        def check_base_prop(name: str) -> bool:
             return any(hasattr(b, name) or name in b._EXTRA_SLOTS for b in bases)
 
         is_base = name == "SHACLObject"
@@ -755,7 +764,8 @@ class SHACLObjectMeta(type):
         py_properties = {}
         iri_properties = {}
         compact_properties = {}
-        for p in attrs.get("PROPERTIES", []):
+        props: List[ClassProp] = attrs.get("PROPERTIES", [])
+        for p in props:
             if not is_base:
                 for b in bases:
                     if p.pyname in b._OBJ_PY_PROPS or p.pyname in b._EXTRA_SLOTS:
@@ -879,65 +889,65 @@ T_SHACLObject = TypeVar("T_SHACLObject", bound="SHACLObject")
 class SHACLObject(metaclass=SHACLObjectMeta):
     """Base class for all SHACL-defined objects, providing property access, encoding, and decoding."""
 
-    CLASSES: Dict[str, Type] = {}
+    CLASSES: ClassVar[Dict[str, Type[SHACLObject]]] = {}
 
     # Class properties that can be set in derived classes:
 
     # A dictionary of Named Individuals. The key is the python name of the
     # individual and the value is the IRI of the individual (not inherited)
-    NAMED_INDIVIDUALS: Dict[str, str] = {}
+    NAMED_INDIVIDUALS: ClassVar[Dict[str, str]] = {}
 
     # If True, class member variables will be automatically created for the class
     # from the NAMED_INDIVIDUALS dictionary
     # NOTE: This variable is not present in the class
-    AUTO_NAMED_INDIVIDUALS: bool = True
+    AUTO_NAMED_INDIVIDUALS: ClassVar[bool] = True
 
     # The type of ID the object is allowed to have (inherited from parent)
-    NODE_KIND = NodeKind.BlankNodeOrIRI
+    NODE_KIND: ClassVar[NodeKind] = NodeKind.BlankNodeOrIRI
 
     # An alternate IRI for the ID property, besides "@id" (inherited from
     # parent)
-    ID_ALIAS: Optional[str] = None
+    ID_ALIAS: ClassVar[Optional[str]] = None
 
     # If True, this class is abstract and cannot be implemented (not inherited
     # from parent)
-    IS_ABSTRACT: bool = True
+    IS_ABSTRACT: ClassVar[bool] = True
 
     # If True, this class is deprecated and will raise a warning when created
     # (not inherited from parent)
-    IS_DEPRECATED: bool = False
+    IS_DEPRECATED: ClassVar[bool] = False
 
     # The fully qualified Type IRI for the object. Required
     # NOTE: This variable is not present in the class. Use get_type() instead
-    TYPE: str = ""
+    TYPE: ClassVar[str] = ""
 
     # The compacted Type IRI of the object. Must match how the TYPE property
     # would be compacted by the context. Not inherited from parent
     # NOTE: This variable is not present in the class. Use get_compact_type()
     # instead
-    COMPACT_TYPE: Optional[str] = None
+    COMPACT_TYPE: ClassVar[Optional[str]] = None
 
     # A list of properties for this object. Each entry must be a ClassProp
     # object. Properties are automatically inherited from parent classes and do
     # not need to be re-listed here.
     # NOTE: The variable is not present in the class
-    PROPERTIES = [
+    PROPERTIES: ClassVar[List[ClassProp]] = [
         ClassProp("_id", lambda: StringProp(), "@id"),
     ]
 
     # Internal variables
-    _EXTRA_SLOTS: Union[Set[str], Tuple[str, ...]] = (
+    _EXTRA_SLOTS: ClassVar[Union[Set[str], Tuple[str, ...]]] = (
         "_extensible",
         "_metadata",
         "_birth_index",
     )
-    _OBJ_PY_PROPS: Dict[str, ClassProp] = {}
-    _OBJ_IRI_PROPS: Dict[str, ClassProp] = {}
-    _OBJ_COMPACT_PROPS: Dict[str, ClassProp] = {}
-    _NEEDS_REG: bool = True
-    _next_birth_index: int = 0
-    _TYPE: str
-    _COMPACT_TYPE: Optional[str]
+    _OBJ_PY_PROPS: ClassVar[Dict[str, ClassProp]] = {}
+    _OBJ_IRI_PROPS: ClassVar[Dict[str, ClassProp]] = {}
+    _OBJ_COMPACT_PROPS: ClassVar[Dict[str, ClassProp]] = {}
+    _NEEDS_REG: ClassVar[bool] = True
+    _next_birth_index: ClassVar[int] = 0
+    _TYPE: ClassVar[str]
+    _COMPACT_TYPE: ClassVar[Optional[str]]
     _extensible: Dict[str, Any]
 
     # Instance variables
@@ -998,6 +1008,18 @@ class SHACLObject(metaclass=SHACLObjectMeta):
         for k, v in kwargs.items():
             setattr(self, k, v)
 
+    def get_id(self) -> Optional[str]:
+        """Return the IRI or blank node ID of this object, or None if not set."""
+        return self._id
+
+    def set_id(self, value: Optional[str]) -> None:
+        """Set the IRI or blank node ID of this object,
+        or clear it if value is None."""
+        if value is None:
+            del self._id
+        else:
+            self._id = value
+
     def get_type(self) -> str:
         """Return the fully qualified IRI type of this object."""
         return self._TYPE
@@ -1035,7 +1057,7 @@ class SHACLObject(metaclass=SHACLObjectMeta):
             )
         object.__setattr__(self, p.pyname, p.prop.set(value))
 
-    def __del(self, p: ClassProp):
+    def __del(self, p: ClassProp) -> None:
         object.__setattr__(self, p.pyname, p.prop.init())
 
     def __get_attr(self, name: str) -> ClassProp:
@@ -1272,7 +1294,7 @@ class SHACLObject(metaclass=SHACLObjectMeta):
                 ),
             )
 
-    def __str__(self):
+    def __str__(self) -> str:
         parts = [
             f"{self.__class__.__name__}(",
         ]
@@ -1281,10 +1303,10 @@ class SHACLObject(metaclass=SHACLObjectMeta):
         parts.append(")")
         return "".join(parts)
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return super().__hash__()
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return super().__eq__(other)
 
     @staticmethod
@@ -1347,7 +1369,7 @@ class SHACLExtensibleObject(SHACLObject):
         return obj
 
     def _decode_properties(self, decoder: Decoder, state: DecodeState) -> None:
-        def decode_value(d):
+        def decode_value(d: Decoder) -> Any:
             if not d.is_list():
                 return d.read_value()
 
@@ -1372,6 +1394,7 @@ class SHACLExtensibleObject(SHACLObject):
                 )
 
             with decoder.read_property(key) as prop_d:
+                assert prop_d is not None
                 self._ext_data[expanded_key] = decode_value(prop_d)
 
     def _encode_properties(self, encoder: Encoder, state: EncodeState) -> None:
@@ -1519,7 +1542,7 @@ class SHACLObjectSet(object):
 
         self.obj_by_id[obj._id] = obj
 
-    def add(self, obj: SHACLObject) -> SHACLObject:
+    def add(self, obj: T_SHACLObject) -> T_SHACLObject:
         """
         Add object to object set
 
@@ -1535,6 +1558,22 @@ class SHACLObjectSet(object):
             self.add_index(obj)
         return obj
 
+    def remove(self, obj: SHACLObject) -> None:
+        """
+        Remove object from object set
+
+        Remove a SHACLObject from the object set and rebuild index.
+
+        NOTE: If the object is still referenced by another object in
+        the object set, it will remain indexed
+        """
+        if not isinstance(obj, SHACLObject):
+            raise TypeError("Object is not of type SHACLObject")
+
+        if obj in self.objects:
+            self.objects.remove(obj)
+            self.create_index()
+
     def update(self, *others: Iterable[SHACLObject]) -> None:
         """
         Update object set adding all objects in each other iterable
@@ -1781,7 +1820,7 @@ class SHACLObjectSet(object):
         elif objects:
             objects[0].encode(encoder, state)
 
-    def decode(self, decoder: Decoder, state: DecodeState):
+    def decode(self, decoder: Decoder, state: DecodeState) -> None:
         """Decode objects from the decoder and add them to this set, then link all references."""
         self.create_index()
         for obj_d in decoder.read_list():
@@ -1931,7 +1970,7 @@ class Decoder(ABC):
         raise NotImplementedError("Subclasses must implement read_iri method")
 
     @abstractmethod
-    def read_enum(self, e) -> Optional[str]:
+    def read_enum(self, e: EnumProp) -> Optional[str]:
         """
         Consumes the next item as an Enum value string
 
@@ -2087,7 +2126,7 @@ class JSONLDDecoder(Decoder):
             return self.data
         return None
 
-    def read_enum(self, e) -> Optional[str]:
+    def read_enum(self, e: EnumProp) -> Optional[str]:
         if isinstance(self.data, str):
             return self.data
         return None
@@ -2442,7 +2481,7 @@ class JSONLDSerializer(object):
         objectset: SHACLObjectSet,
         f: BinaryIO,
         force_at_graph: bool = False,
-        **kwargs,
+        **kwargs: Any,
     ) -> str:
         """
         Write a SHACLObjectSet to a JSON LD file
@@ -2582,7 +2621,7 @@ class JSONLDInlineSerializer(object):
         objectset: SHACLObjectSet,
         f: BinaryIO,
         force_at_graph: bool = False,
-    ):
+    ) -> str:
         """
         Write a SHACLObjectSet to a JSON LD file
 
@@ -2607,7 +2646,7 @@ def encode_context(encoder: Encoder, objectset: SHACLObjectSet) -> None:
     if not context:
         return
 
-    def write_context(e, ctx):
+    def write_context(e: Encoder, ctx: Union[str, Dict[str, str]]) -> None:
         if isinstance(ctx, str):
             e.write_string(ctx)
         else:
@@ -2627,7 +2666,7 @@ def encode_context(encoder: Encoder, objectset: SHACLObjectSet) -> None:
 
 
 def decode_context(decoder: Decoder, objectset: SHACLObjectSet) -> None:
-    def _decode_ctx(d: Decoder):
+    def _decode_ctx(d: Decoder) -> None:
         if not d.is_object():
             return
 
@@ -2650,7 +2689,7 @@ try:
     from rdflib.term import IdentifiedNode
 
     if TYPE_CHECKING:
-        from rdflib import Graph
+        from rdflib import Graph  # noqa: I300
         from rdflib.term import Node
 
     class RDFDecoder(Decoder):
@@ -2718,7 +2757,7 @@ try:
                 return v.n3()
             return None
 
-        def read_enum(self, e) -> Optional[str]:
+        def read_enum(self, e: EnumProp) -> Optional[str]:
             v = self.__read_node()
             if isinstance(v, URIRef):
                 return v.toPython()
@@ -2792,7 +2831,7 @@ try:
 
             return typ.toPython(), self.__class__(self.graph, s)
 
-        def read_object_id(self, alias=None) -> Optional[Any]:
+        def read_object_id(self, alias: Optional[str] = None) -> Optional[Any]:
             if isinstance(self.subject, BNode):
                 return self.subject.n3()
             if not isinstance(self.subject, IdentifiedNode):
@@ -2830,29 +2869,31 @@ try:
                 raise TypeError("Subject and predicate of URIRef value cannot be None")
             self.graph.add((self.subject, self.predicate, URIRef(v)))
 
-        def write_string(self, v):
+        def write_string(self, v: str) -> None:
             self.__add_literal(v)
 
-        def write_datetime(self, v):
+        def write_datetime(self, v: str) -> None:
             self.__add_literal(v)
 
-        def write_integer(self, v):
+        def write_integer(self, v: int) -> None:
             self.__add_literal(v)
 
-        def write_iri(self, v, compact=None):
+        def write_iri(self, v: str, compact: Optional[str] = None) -> None:
             self.__add_uriref(v)
 
-        def write_enum(self, v, e, compact=None):
+        def write_enum(self, v: str, e: Any, compact: Optional[str] = None) -> None:
             self.__add_uriref(v)
 
-        def write_bool(self, v):
+        def write_bool(self, v: bool) -> None:
             self.__add_literal(v)
 
-        def write_float(self, v):
+        def write_float(self, v: float) -> None:
             self.__add_literal(v)
 
         @contextmanager
-        def write_property(self, iri: str, compact: Optional[str] = None):
+        def write_property(
+            self, iri: str, compact: Optional[str] = None
+        ) -> Iterator[Encoder]:
             yield self.__class__(self.graph, self.subject, URIRef(iri))
 
         @contextmanager
@@ -2864,7 +2905,7 @@ try:
             _id: str,
             compact_id: Optional[str],
             needs_id: bool,
-        ):
+        ) -> Iterator[Encoder]:
             obj: Node
             if _id.startswith("_:"):
                 obj = BNode(_id[2:])
@@ -2879,19 +2920,19 @@ try:
             yield self.__class__(self.graph, obj)
 
         @contextmanager
-        def write_list(self):
+        def write_list(self) -> Iterator["RDFEncoder"]:
             yield self
 
         @contextmanager
-        def write_list_item(self):
+        def write_list_item(self) -> Iterator["RDFEncoder"]:
             yield self
 
         @contextmanager
-        def write_object_list(self):
+        def write_object_list(self) -> Iterator["RDFEncoder"]:
             yield self
 
         @contextmanager
-        def write_dict(self):
+        def write_dict(self) -> Iterator["RDFEncoder"]:
             yield self
 
     class RDFSerializer(object):
@@ -2940,22 +2981,22 @@ class {{ varname(*class.clsname) }}(
     {%- endfor %}
     {{ '"' }}{{ '"' }}{{ '"' }}
 {% endif %}
-    TYPE = "{{ class._id }}"
+    TYPE: ClassVar[str] = "{{ class._id }}"
     {%- if context.compact_iri(class._id) != class._id %}
-    COMPACT_TYPE = "{{ context.compact_iri(class._id) }}"
+    COMPACT_TYPE: ClassVar[Optional[str]] = "{{ context.compact_iri(class._id) }}"
     {%- endif %}
-    NODE_KIND: NodeKind = NodeKind.{{ class.node_kind.split("#")[-1] }}
+    NODE_KIND: ClassVar[NodeKind] = NodeKind.{{ class.node_kind.split("#")[-1] }}
     {%- if class.id_property %}
-    ID_ALIAS: Optional[str] = "{{ class.id_property }}"
+    ID_ALIAS: ClassVar[Optional[str]] = "{{ class.id_property }}"
     {%- endif %}
     {%- if class.is_abstract %}
-    IS_ABSTRACT: bool = True
+    IS_ABSTRACT: ClassVar[bool] = True
     {%- endif %}
     {%- if class.deprecated %}
-    IS_DEPRECATED: bool = True
+    IS_DEPRECATED: ClassVar[bool] = True
     {%- endif %}
     {%- if class.named_individuals %}
-    NAMED_INDIVIDUALS: Dict[str, str] = {
+    NAMED_INDIVIDUALS: ClassVar[Dict[str, str]] = {
         {%- for member in class.named_individuals %}
         {%- if member.comment %}
         {%- for l in member.comment.split("\n") %}
@@ -2968,7 +3009,7 @@ class {{ varname(*class.clsname) }}(
     {%- endif %}
 
     {%- if class.properties %}
-    PROPERTIES = [
+    PROPERTIES: ClassVar[List[ClassProp]] = [
     {%- for prop in class.properties %}
         {%- set is_list = prop.max_count is none or prop.max_count != 1 %}
         {%- if prop.comment %}