SimpleSchemaGenerator 0.12.6__tar.gz → 0.12.8__tar.gz

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/.github/workflows/CICD.yml

@@ -26,8 +26,8 @@ jobs:
     with:
       # These values can be customized for your specific requirements.
       operating_system_json_string: "[ 'macos-latest', 'ubuntu-latest', 'windows-latest' ]"
-      python_version_json_string: "['3.13', '3.12', '3.11', '3.10']"
-      python_package_version: "3.10"
+      python_version_json_string: "['3.13']"
+      python_package_version: "3.13"
       coverage_badge_gist_id: "f15146b1b8fdc0a5d45ac0eb786a84f7"
       coverage_badge_gist_username: "davidbrownell"
 

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SimpleSchemaGenerator
-Version: 0.12.6
+Version: 0.12.8
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/davidbrownell/SimpleSchemaGenerator
 Project-URL: Documentation, https://github.com/davidbrownell/SimpleSchemaGenerator
@@ -12,11 +12,8 @@ Classifier: Operating System :: MacOS
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
+Requires-Python: >=3.13
 Requires-Dist: antlr-denter>=1.3.1
 Requires-Dist: dbrownell-common>=0.14.6
 Requires-Dist: emoji>=2.14.1

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/pyproject.toml

@@ -5,7 +5,7 @@ readme = "README.md"
 authors = [
     { name = "David Brownell", email = "github@DavidBrownell.com" }
 ]
-requires-python = ">= 3.10"
+requires-python = ">= 3.13"
 dependencies = [
     "antlr-denter>=1.3.1",
     "dbrownell-common>=0.14.6",
@@ -19,9 +19,6 @@ classifiers = [
     "Operating System :: POSIX :: Linux",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3.13",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.10",
 ]
 
 [project.license]
@@ -70,17 +67,35 @@ extend-exclude = ["src/SimpleSchemaGenerator/Schema/Parse/ANTLR/GeneratedCode"]
 [tool.ruff.lint]
 exclude = ["tests/**"]
 
+select = ["ALL"]
+
 ignore = [
     "ANN002", # Missing type annotation for `*args`
     "ANN003", # Missing type annotation for `**kwargs`
     "BLE001", # Do not catch blind exception: `Exception`
     "COM812", # Trailing comma missing
+    "D100", # Missing docstring in public module
+    "D101", # Missing docstring in public class
+    "D102", # Missing docstring in public method
+    "D103", # Missing docstring in public function
+    "D104", # Missing docstring in public package
+    "D105", # Missing docstring in magic method
+    "D106", # Missing docstring in public nested class
+    "D107", # Missing docstring in `__init__` method
     "D202", # No blank lines allowed after function docstring
+    "D400", # First line should end with a period
+    "D415", # First line should end with a period, question mark, or exclamation point
     "E501", # Line too long
+    "FIX002", # Line contains TODO, consider resolving the issue
     "I001", # Import block is un-sorted or un-formatted
     "N802", # Function name `xxx` should be lowercase
     "N999", # Invalid module name
     "S101", # Use of assert detected
+    "TC006", # Add quotes to type expression in `typing.cast()`
+    "TD002", # Missing author in TODO
+    "TD003", # Missing issue link for this TODO
+    "TRY002", # Create your own exception
+    "TRY300", # Consider moving this statement to an `else` block
     "UP032", # Use f-string instead of `format` call
 ]
 

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Common/Error.py

@@ -22,7 +22,6 @@ from enum import Enum
 from functools import singledispatch, singledispatchmethod
 from io import StringIO
 from pathlib import Path
-from typing import Optional, Type as PythonType
 
 from .Location import Location
 from .Region import Region
@@ -66,10 +65,10 @@ class Error:
     # ----------------------------------------------------------------------
     @Create.register
     @classmethod
-    def _(
+    def _(  # noqa: ANN206
         cls,
         ex: Exception,
-        region: Optional[Region] = None,
+        region: Region | None = None,
         *,
         include_callstack: bool = True,
     ):  # -> "Error":
@@ -130,7 +129,7 @@ class Error:
 
 # ----------------------------------------------------------------------
 @dataclass
-class SimpleSchemaGeneratorException(Exception):
+class SimpleSchemaGeneratorError(Exception):
     """Exception raised by functionality in SimpleSchemaGenerator."""
 
     # ----------------------------------------------------------------------
@@ -142,7 +141,7 @@ class SimpleSchemaGeneratorException(Exception):
         self,
         error: Error,
     ) -> None:
-        super(SimpleSchemaGeneratorException, self).__init__(str(error))
+        super().__init__(str(error))
 
         object.__setattr__(
             self,
@@ -164,8 +163,8 @@ class SimpleSchemaGeneratorException(Exception):
 # ----------------------------------------------------------------------
 def CreateErrorType(
     message_template: str,
-    **args: PythonType,
-) -> PythonType[Error]:
+    **args: type,
+) -> type[Error]:
     dynamic_fields_class = make_dataclass(
         "DynamicFields",
         args.items(),
@@ -182,8 +181,8 @@ def CreateErrorType(
         message: str = field(init=False)
 
         # ----------------------------------------------------------------------
-        def __post_init__(self, *args, **kwargs):
-            super(NewError, self).__post_init__(*args, **kwargs)
+        def __post_init__(self, *args, **kwargs) -> None:
+            super().__post_init__(*args, **kwargs)
 
             object.__setattr__(
                 self,
@@ -202,7 +201,7 @@ def CreateErrorType(
 # ----------------------------------------------------------------------
 # ----------------------------------------------------------------------
 @singledispatch
-def _ArgToString(value) -> str:
+def _ArgToString(value: object) -> str:
     return str(value)
 
 

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Common/Location.py

@@ -27,11 +27,11 @@ class Location:
     column: int
 
     # ----------------------------------------------------------------------
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if self.line < 1:
-            raise ValueError(f"Invalid line value: {self.line}")
+            raise ValueError(f"Invalid line value: {self.line}")  # noqa: EM102, TRY003
         if self.column < 1:
-            raise ValueError(f"Invalid column value: {self.column}")
+            raise ValueError(f"Invalid column value: {self.column}")  # noqa: EM102, TRY003
 
     # ----------------------------------------------------------------------
     def __str__(self) -> str:
@@ -54,22 +54,22 @@ class Location:
         return 0
 
     # ----------------------------------------------------------------------
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: object) -> bool:
         return isinstance(other, Location) and self.__class__.Compare(self, other) == 0
 
-    def __ne__(self, other) -> bool:
+    def __ne__(self, other: object) -> bool:
         return not isinstance(other, Location) or self.__class__.Compare(self, other) != 0
 
-    def __lt__(self, other) -> bool:
+    def __lt__(self, other: object) -> bool:
         return isinstance(other, Location) and self.__class__.Compare(self, other) < 0
 
-    def __le__(self, other) -> bool:
+    def __le__(self, other: object) -> bool:
         return isinstance(other, Location) and self.__class__.Compare(self, other) <= 0
 
-    def __gt__(self, other) -> bool:
+    def __gt__(self, other: object) -> bool:
         return isinstance(other, Location) and self.__class__.Compare(self, other) > 0
 
-    def __ge__(self, other) -> bool:
+    def __ge__(self, other: object) -> bool:
         return isinstance(other, Location) and self.__class__.Compare(self, other) >= 0
 
     # ----------------------------------------------------------------------

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Common/Region.py

@@ -72,8 +72,8 @@ class Region:
     # ----------------------------------------------------------------------
     @staticmethod
     def Compare(
-        this: "Region",  # type: ignore
-        that: "Region",  # type: ignore
+        this: "Region",
+        that: "Region",
     ) -> int:
         if this.filename != that.filename:
             return -1 if this.filename < that.filename else 1
@@ -89,22 +89,22 @@ class Region:
         return 0
 
     # ----------------------------------------------------------------------
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: object) -> bool:
         return isinstance(other, Region) and self.__class__.Compare(self, other) == 0
 
-    def __ne__(self, other) -> bool:
+    def __ne__(self, other: object) -> bool:
         return not isinstance(other, Region) or self.__class__.Compare(self, other) != 0
 
-    def __lt__(self, other) -> bool:
+    def __lt__(self, other: object) -> bool:
         return isinstance(other, Region) and self.__class__.Compare(self, other) < 0
 
-    def __le__(self, other) -> bool:
+    def __le__(self, other: object) -> bool:
         return isinstance(other, Region) and self.__class__.Compare(self, other) <= 0
 
-    def __gt__(self, other) -> bool:
+    def __gt__(self, other: object) -> bool:
         return isinstance(other, Region) and self.__class__.Compare(self, other) > 0
 
-    def __ge__(self, other) -> bool:
+    def __ge__(self, other: object) -> bool:
         return isinstance(other, Region) and self.__class__.Compare(self, other) >= 0
 
     # ----------------------------------------------------------------------
@@ -121,7 +121,7 @@ class Region:
         if isinstance(location_or_region, Location):
             return self.begin <= location_or_region <= self.end
 
-        assert False, location_or_region  # pragma: no cover
+        raise AssertionError(location_or_region)  # pragma: no cover
 
     # ----------------------------------------------------------------------
     # ----------------------------------------------------------------------

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/EntryPoint.py

@@ -4,7 +4,7 @@
 # |  Distributed under the MIT License.
 # |
 # ----------------------------------------------------------------------
-"""This file serves as an example of how to create scripts that can be invoked from the command line once the package is installed."""
+"""Example of how to create scripts that can be invoked from the command line once the package is installed."""
 
 import sys
 
@@ -19,8 +19,8 @@ from SimpleSchemaGenerator import __version__
 class NaturalOrderGrouper(TyperGroup):
     # pylint: disable=missing-class-docstring
     # ----------------------------------------------------------------------
-    def list_commands(self, *args, **kwargs):  # pylint: disable=unused-argument
-        return self.commands.keys()
+    def list_commands(self, *args, **kwargs) -> list[str]:  # noqa: ARG002
+        return list(self.commands.keys())
 
 
 # ----------------------------------------------------------------------
@@ -45,7 +45,7 @@ def EntryPoint(
 # ----------------------------------------------------------------------
 @app.command("Version")
 def Version() -> None:
-    """Prints the version of the package."""
+    """Print the version of the package."""
 
     sys.stdout.write(__version__)
 

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Errors.py

@@ -20,7 +20,7 @@ from pathlib import Path
 from .Common.Error import CreateErrorType, Region
 
 # Convenience imports
-from .Common.Error import SimpleSchemaGeneratorException  # noqa: F401
+from .Common.Error import SimpleSchemaGeneratorError  # noqa: F401
 
 
 # TODO: Search for 'range' and replace with 'region'
@@ -32,8 +32,8 @@ from .Common.Error import SimpleSchemaGeneratorException  # noqa: F401
 # ----------------------------------------------------------------------
 # These errors are defined as strings rather than ErrorType because they only have a beginning
 # Location and not a start and end Location as required by the Region in ErrorType.
-antlr_invalid_opening_token = "Triple-quote delimiters that initiate multiline strings cannot have any content on the same line as the opening token."
-antlr_invalid_closing_token = "Triple-quote delimiters that terminate multiline strings cannot have any content on the same line as the closing token."
+antlr_invalid_opening_token = "Triple-quote delimiters that initiate multiline strings cannot have any content on the same line as the opening token."  # noqa: S105
+antlr_invalid_closing_token = "Triple-quote delimiters that terminate multiline strings cannot have any content on the same line as the closing token."  # noqa: S105
 antlr_invalid_indentation = "Invalid multiline string indentation."
 
 ParseStructureStatementInvalidBase = CreateErrorType("Base types must be identifiers.")

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Schema/Elements/Common/Cardinality.py

@@ -15,16 +15,15 @@
 
 from dataclasses import dataclass, field, InitVar
 from functools import cached_property
-from typing import Any, Optional
 
-from dbrownell_Common.InflectEx import inflect  # type: ignore[import-untyped]
-from dbrownell_Common.Types import override  # type: ignore[import-untyped]
+from dbrownell_Common.InflectEx import inflect
+from dbrownell_Common.Types import override
 
 from .Element import Element
-from ..Expressions.Expression import Expression
-from ..Expressions.IntegerExpression import IntegerExpression
-from ....Common.Error import Error
-from .... import Errors
+from SimpleSchemaGenerator.Schema.Elements.Expressions.Expression import Expression
+from SimpleSchemaGenerator.Schema.Elements.Expressions.IntegerExpression import IntegerExpression
+from SimpleSchemaGenerator.Common.Error import Error
+from SimpleSchemaGenerator import Errors
 
 
 # ----------------------------------------------------------------------
@@ -32,17 +31,17 @@ from .... import Errors
 class Cardinality(Element):
     """Specifies the minimum and maximum number of times an element can appear within a collection."""
 
-    min_param: InitVar[Optional[IntegerExpression]]
-    max_param: InitVar[Optional[IntegerExpression]]
+    min_param: InitVar[IntegerExpression | None]
+    max_param: InitVar[IntegerExpression | None]
 
     min: IntegerExpression = field(init=False)
-    max: Optional[IntegerExpression] = field(init=False)
+    max: IntegerExpression | None = field(init=False)
 
     # ----------------------------------------------------------------------
     def __post_init__(
         self,
-        min_param: Optional[IntegerExpression],
-        max_param: Optional[IntegerExpression],
+        min_param: IntegerExpression | None,
+        max_param: IntegerExpression | None,
     ) -> None:
         if min_param is None and max_param is None:
             min_param = IntegerExpression(self.region, 1)
@@ -56,7 +55,7 @@ class Cardinality(Element):
         assert min_param is not None
 
         if max_param is not None and max_param.value < min_param.value:
-            raise Errors.SimpleSchemaGeneratorException(
+            raise Errors.SimpleSchemaGeneratorError(
                 Errors.CardinalityInvalidRange.Create(
                     max_param.region,
                     min_param.value,
@@ -88,11 +87,11 @@ class Cardinality(Element):
     # ----------------------------------------------------------------------
     def Validate(
         self,
-        expression_or_value: Expression | Any,
+        expression_or_value: Expression | object,
     ) -> None:
         # ----------------------------------------------------------------------
         def Impl(
-            value: Any,
+            value: object,
         ) -> None:
             if value is None:
                 if self.is_optional:
@@ -128,13 +127,13 @@ class Cardinality(Element):
 
                 return
 
-            elif self.is_optional:
+            if self.is_optional:
                 # We don't have enough context to validate the cardinality, but it will be validated
                 # at a later time.
                 return
 
             if isinstance(value, list):
-                raise Exception(Errors.cardinality_validate_list_not_expected)
+                raise TypeError(Errors.cardinality_validate_list_not_expected)
 
         # ----------------------------------------------------------------------
 
@@ -143,7 +142,7 @@ class Cardinality(Element):
                 Impl(expression_or_value.value)
                 return
             except Exception as ex:
-                raise Errors.SimpleSchemaGeneratorException(
+                raise Errors.SimpleSchemaGeneratorError(
                     Error.Create(
                         ex,
                         expression_or_value.region,
@@ -182,7 +181,7 @@ class Cardinality(Element):
     # ----------------------------------------------------------------------
     @override
     def _GenerateAcceptDetails(self) -> Element._GenerateAcceptDetailsResultType:
-        yield Element._GenerateAcceptDetailsItem("min", self.min)
+        yield Element._GenerateAcceptDetailsItem("min", self.min)  # noqa: SLF001
 
         if self.max is not None:
-            yield Element._GenerateAcceptDetailsItem("max", self.max)
+            yield Element._GenerateAcceptDetailsItem("max", self.max)  # noqa: SLF001

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Schema/Elements/Common/Element.py

@@ -14,11 +14,12 @@
 """Contains the Element object"""
 
 from abc import ABC
+from collections.abc import Generator
 from dataclasses import dataclass, field
-from typing import Generator, Optional, Union
+from typing import Union
 from weakref import ReferenceType as WeakReferenceType
 
-from dbrownell_Common.Types import extension  # type: ignore[import-untyped]
+from dbrownell_Common.Types import extension
 
 from SimpleSchemaGenerator.Common.Region import Region
 from SimpleSchemaGenerator.Schema.Visitors.ElementVisitor import ElementVisitor, VisitResult
@@ -49,7 +50,7 @@ class Element(ABC):
         object.__setattr__(self, "_disabled", True)
 
     # ----------------------------------------------------------------------
-    def Accept(
+    def Accept(  # noqa: C901
         self,
         visitor: ElementVisitor,
         *,
@@ -144,7 +145,7 @@ class Element(ABC):
             list[WeakReferenceType["Element"]],
         ]
 
-    _GenerateAcceptDetailsResultType = Generator[_GenerateAcceptDetailsItem, None, None]
+    _GenerateAcceptDetailsResultType = Generator[_GenerateAcceptDetailsItem]
 
     # ----------------------------------------------------------------------
     @dataclass(frozen=True)
@@ -152,7 +153,7 @@ class Element(ABC):
         children_name: str
         children: list["Element"]
 
-    _GetAcceptChildrenResultType = Optional[_GetAcceptChildrenResult]
+    type _GetAcceptChildrenResultType = _GetAcceptChildrenResult | None
 
     # ----------------------------------------------------------------------
     # |

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Schema/Elements/Common/Metadata.py

@@ -15,12 +15,12 @@
 
 from dataclasses import dataclass, field, InitVar
 
-from dbrownell_Common.Types import override  # type: ignore[import-untyped]
+from dbrownell_Common.Types import override
 
 from .Element import Element
 from .TerminalElement import TerminalElement
-from ..Expressions.Expression import Expression
-from .... import Errors
+from SimpleSchemaGenerator.Schema.Elements.Expressions.Expression import Expression
+from SimpleSchemaGenerator import Errors
 
 
 # ----------------------------------------------------------------------
@@ -37,8 +37,8 @@ class MetadataItem(Element):
     # ----------------------------------------------------------------------
     @override
     def _GenerateAcceptDetails(self) -> Element._GenerateAcceptDetailsResultType:
-        yield Element._GenerateAcceptDetailsItem("name", self.name)
-        yield Element._GenerateAcceptDetailsItem("expression", self.expression)
+        yield Element._GenerateAcceptDetailsItem("name", self.name)  # noqa: SLF001
+        yield Element._GenerateAcceptDetailsItem("expression", self.expression)  # noqa: SLF001
 
 
 # ----------------------------------------------------------------------
@@ -60,9 +60,9 @@ class Metadata(Element):
         for item in items_param:
             key = item.name.value
 
-            prev_value = items.get(key, None)
+            prev_value = items.get(key)
             if prev_value is not None:
-                raise Errors.SimpleSchemaGeneratorException(
+                raise Errors.SimpleSchemaGeneratorError(
                     Errors.MetadataItemDuplicated.Create(
                         item.name.region,
                         key,
@@ -80,4 +80,4 @@ class Metadata(Element):
     # ----------------------------------------------------------------------
     @override
     def _GetAcceptChildren(self) -> Element._GetAcceptChildrenResultType:
-        return Element._GetAcceptChildrenResult("items", list(self.items.values()))
+        return Element._GetAcceptChildrenResult("items", list(self.items.values()))  # noqa: SLF001

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Schema/Elements/Common/UniqueNameTrait.py

@@ -14,7 +14,6 @@
 """Contains the UniqueNameTrait object."""
 
 from dataclasses import dataclass, field
-from typing import Union
 
 
 # ----------------------------------------------------------------------
@@ -23,10 +22,10 @@ class UniqueNameTrait:
     """Trait for Elements that are given an unique name during parsing."""
 
     # ----------------------------------------------------------------------
-    _unique_name: Union[
-        None,  # Before NormalizeUniqueName is called
-        str,  # After NormalizeUniqueName is called
-    ] = field(init=False, default=None)
+    _unique_name: (
+        None  # Before NormalizeUniqueName is called
+        | str  # After NormalizeUniqueName is called
+    ) = field(init=False, default=None)
 
     # ----------------------------------------------------------------------
     @property

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Schema/Elements/Common/Visibility.py

@@ -16,7 +16,7 @@
 from dataclasses import dataclass
 from enum import auto, Enum
 
-from dbrownell_Common.Types import override  # type: ignore[import-untyped]
+from dbrownell_Common.Types import override
 
 from .TerminalElement import Element, TerminalElement
 
@@ -42,7 +42,7 @@ class VisibilityTrait(Element):
     # ----------------------------------------------------------------------
     @override
     def _GenerateAcceptDetails(self) -> Element._GenerateAcceptDetailsResultType:
-        yield Element._GenerateAcceptDetailsItem(  # pylint: disable=protected-access
+        yield Element._GenerateAcceptDetailsItem(  # noqa: SLF001
             "visibility",
             self.visibility,
         )

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Schema/Elements/Expressions/Expression.py

@@ -16,7 +16,7 @@
 from dataclasses import dataclass
 from typing import Any, ClassVar
 
-from ..Common.Element import Element
+from SimpleSchemaGenerator.Schema.Elements.Common.Element import Element
 
 
 # ----------------------------------------------------------------------
@@ -30,6 +30,6 @@ class Expression(Element):
     value: Any
 
     # ----------------------------------------------------------------------
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if self.NAME == "":
-            raise Exception(f"NAME must be defined for '{self.__class__.__name__}'.")
+            raise Exception(f"NAME must be defined for '{self.__class__.__name__}'.")  # noqa: EM102, TRY003

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Schema/Elements/Expressions/ListExpression.py

@@ -16,10 +16,10 @@
 from dataclasses import dataclass
 from typing import cast, ClassVar
 
-from dbrownell_Common.Types import override  # type: ignore[import-untyped]
+from dbrownell_Common.Types import override
 
 from .Expression import Expression
-from ..Common.Element import Element
+from SimpleSchemaGenerator.Schema.Elements.Common.Element import Element
 
 
 # ----------------------------------------------------------------------
@@ -37,6 +37,6 @@ class ListExpression(Expression):
     # ----------------------------------------------------------------------
     @override
     def _GenerateAcceptDetails(self) -> Element._GenerateAcceptDetailsResultType:
-        yield Element._GenerateAcceptDetailsItem(  # pylint: disable=protected-access
+        yield Element._GenerateAcceptDetailsItem(  # noqa: SLF001
             "value", cast(list[Element], self.value)
         )

{simpleschemagenerator-0.12.6 → simpleschemagenerator-0.12.8}/src/SimpleSchemaGenerator/Schema/Elements/Expressions/TupleExpression.py

@@ -16,11 +16,11 @@
 from dataclasses import dataclass
 from typing import ClassVar
 
-from dbrownell_Common.Types import override  # type: ignore[import-untyped]
+from dbrownell_Common.Types import override
 
 from .Expression import Expression
-from ..Common.Element import Element
-from .... import Errors
+from SimpleSchemaGenerator.Schema.Elements.Common.Element import Element
+from SimpleSchemaGenerator import Errors
 
 
 # ----------------------------------------------------------------------
@@ -34,17 +34,17 @@ class TupleExpression(Expression):
     value: tuple[Expression, ...]
 
     # ----------------------------------------------------------------------
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.value:
-            raise Errors.SimpleSchemaGeneratorException(Errors.TupleExpressionEmpty.Create(self.region))
+            raise Errors.SimpleSchemaGeneratorError(Errors.TupleExpressionEmpty.Create(self.region))
 
-        super(TupleExpression, self).__post_init__()
+        super().__post_init__()
 
     # ----------------------------------------------------------------------
     # ----------------------------------------------------------------------
     # ----------------------------------------------------------------------
     @override
     def _GenerateAcceptDetails(self) -> Element._GenerateAcceptDetailsResultType:
-        yield Element._GenerateAcceptDetailsItem(  # pylint: disable=protected-access
+        yield Element._GenerateAcceptDetailsItem(  # noqa: SLF001
             "value", list(self.value)
         )