ssc_codegen 0.11.0__tar.gz → 0.12.0__tar.gz

{ssc_codegen-0.11.0 → ssc_codegen-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.11.0
+Version: 0.12.0
 Summary: Python-dsl code converter to html parser for web scraping 
 Project-URL: Documentation, https://github.com/vypivshiy/selector_schema_codegen#readme
 Project-URL: Issues, https://github.com/vypivshiy/selector_schema_codegen/issues

{ssc_codegen-0.11.0 → ssc_codegen-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ssc_codegen"
-version = "0.11.0"
+version = "0.12.0"
 description = "Python-dsl code converter to html parser for web scraping "
 readme = "README.md"
 requires-python = ">=3.10"

{ssc_codegen-0.11.0 → ssc_codegen-0.12.0}/ssc_codegen/__init__.py

@@ -1,4 +1,4 @@
-from ssc_codegen.document import HTMLDocument, ClassVarDocument, StringDocument, ArrayDocument, AssertDocument, NestedDocument, \
+from ssc_codegen.document import DocumentElementsFilter, HTMLDocument, ClassVarDocument, StringDocument, ArrayDocument, AssertDocument, NestedDocument, \
     DefaultDocument, \
     NumericDocument, JsonDocument, BooleanDocument, DocumentFilter
 from ssc_codegen.json_struct import Json
@@ -7,7 +7,7 @@ from ssc_codegen.schema import ItemSchema, DictSchema, ListSchema, FlatListSchem
 
 setup_logger()
 
-VERSION = "0.11.0"
+VERSION = "0.12.0"
 
 
 class __MISSING(object):
@@ -68,6 +68,11 @@ def F() -> DocumentFilter:
     return DocumentFilter()
 
 
+def FE() -> DocumentElementsFilter:
+    """Shortcut as a DocumentElementsFilter() object"""
+    return DocumentElementsFilter()
+
+
 def CV(value: int | str | float | bool | None | list, self_cls_path: str | None = None, *, returns: bool = False) -> ClassVarDocument:
     """Shortcut as ClassVarDocument(value, self_cls, parse_returns) object
 

{ssc_codegen-0.11.0 → ssc_codegen-0.12.0}/ssc_codegen/_compat.py

@@ -1,7 +1,10 @@
 import sys
 import warnings
 import functools
+from typing import Callable, ParamSpec, TypeVar
 
+P = ParamSpec("P")
+R = TypeVar("R")
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -12,10 +15,10 @@ else:
         pass
 
 
-def deprecated(reason=""):
-    def decorator(func):
+def deprecated(reason: str = "") -> Callable[[Callable[P, R]], Callable[P, R]]:
+    def decorator(func: Callable[P, R]) -> Callable[P, R]:
         @functools.wraps(func)
-        def wrapper(*args, **kwargs):
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             warnings.warn(
                 f"Function {func.__name__} is deprecated. {reason}",
                 category=DeprecationWarning,

ssc_codegen-0.12.0/ssc_codegen/ast_/__init__.py

@@ -0,0 +1,129 @@
+from .base import BaseAstNode
+from .nodes_array import (
+    ExprIndex,
+    ExprToListLength,
+    ExprListStringJoin,
+    ExprListUnique
+)
+from .nodes_cast import (
+    ExprNested,
+    ExprJsonify,
+    ExprToInt,
+    ExprToFloat,
+    ExprToListInt,
+    ExprToListFloat,
+    ExprToBool,
+    ExprJsonifyDynamic
+)
+from .nodes_core import (
+    ExprReturn,
+    ExprNoReturn,
+    ExprDefaultValueEnd,
+    ExprDefaultValueStart,
+    ExprDefaultValueWrapper,
+    ModuleProgram,
+    Docstring,
+    ModuleImports,
+    StructInitMethod,
+    StructPreValidateMethod,
+    StructFieldMethod,
+    StructPartDocMethod,
+    StartParseMethod,
+    StructParser,
+    JsonStruct,
+    JsonStructField,
+    TypeDef,
+    TypeDefField,
+    ExprCallStructMethod,
+    ExprClassVar,
+    ExprCallStructClassVar,
+    CodeStart,
+    CodeEnd
+)
+from .nodes_filter import (
+    FilterOr,
+    FilterAnd,
+    FilterNot,
+    FilterNotEqual,
+    FilterEqual,
+    FilterStrIn,
+    FilterStrStarts,
+    FilterStrEnds,
+    FilterStrRe,
+    ExprFilter,
+    FilterStrLenEq,
+    FilterStrLenNe,
+    FilterStrLenLt,
+    FilterStrLenLe,
+    FilterStrLenGt,
+    FilterStrLenGe,
+    ExprDocumentFilter,
+    FilterDocCss,
+    FilterDocHasAttr,
+    FilterDocHasRaw,
+    FilterDocHasText,
+    FilterDocIsRegexRaw,
+    FilterDocIsRegexText,
+    FilterDocXpath,
+    FilterDocAttrContains,
+    FilterDocAttrEnds,
+    FilterDocAttrEqual,
+    FilterDocAttrRegex,
+    FilterDocAttrStarts,
+)
+
+from .nodes_selectors import (
+    ExprCss,
+    ExprCssAll,
+    ExprXpathAll,
+    ExprXpath,
+    ExprGetHtmlText,
+    ExprGetHtmlRaw,
+    ExprGetHtmlAttr,
+    ExprGetHtmlAttrAll,
+    ExprGetHtmlRawAll,
+    ExprGetHtmlTextAll,
+    ExprMapAttrs,
+    ExprMapAttrsAll,
+    ExprCssElementRemove,
+    ExprXpathElementRemove
+)
+from .nodes_string import (
+    ExprStringTrim,
+    ExprStringRegex,
+    ExprStringSplit,
+    ExprStringReplace,
+    ExprStringLeftTrim,
+    ExprStringFormat,
+    ExprListStringTrim,
+    ExprStringRegexAll,
+    ExprStringRegexSub,
+    ExprStringRightTrim,
+    ExprListStringFormat,
+    ExprListStringReplace,
+    ExprListStringRightTrim,
+    ExprListStringLeftTrim,
+    ExprListStringRegexSub,
+    ExprStringRmPrefix,
+    ExprStringRmSuffix,
+    ExprStringRmPrefixAndSuffix,
+    ExprListStringRmPrefixAndSuffix,
+    ExprListStringRmPrefix,
+    ExprListStringRmSuffix,
+    ExprStringMapReplace,
+    ExprListStringMapReplace,
+    ExprStringUnescape,
+    ExprListStringUnescape
+)
+from .nodes_validate import (
+    ExprIsCss,
+    ExprIsEqual,
+    ExprStringIsRegex,
+    ExprIsXpath,
+    ExprIsNotEqual,
+    ExprIsContains,
+    ExprListStringAnyRegex,
+    ExprListStringAllRegex,
+    ExprHasAttr,
+    ExprListHasAttr
+)

{ssc_codegen-0.11.0 → ssc_codegen-0.12.0}/ssc_codegen/ast_/base.py

@@ -98,10 +98,10 @@ class BaseAstNode(Generic[T_MAPPING_FIELD, T_ARGUMENTS]):
 
     def find_node_all(
         self, func: Callable[["BaseAstNode"], bool]
-    ) -> "BaseAstNode":
+    ) -> list["BaseAstNode"]:
         """find nodes in body by func filter"""
         if len(self.body) == 0:
-            return []
+            return []  # type: ignore
         return [i for i in self.body if i.kind == func(i)]
 
     def find_node_by_token(
@@ -112,7 +112,7 @@ class BaseAstNode(Generic[T_MAPPING_FIELD, T_ARGUMENTS]):
 
     def find_nodes_by_token(self, token_type: TokenType) -> list["BaseAstNode"]:
         """find nodes by TokenType"""
-        return self.find_nodes_by_token(lambda n: n.kind == token_type)
+        return self.find_nodes_by_token(lambda n: n.kind == token_type)  # type: ignore[arg-type]
 
 
 @dataclass(kw_only=True)

{ssc_codegen-0.11.0 → ssc_codegen-0.12.0}/ssc_codegen/ast_/nodes_core.py

@@ -107,7 +107,7 @@ class ExprCallStructMethod(
 
 
 KW_EXPR_CALL_CLASSVAR = TypedDict(
-    "KW_EXPR_CALL_LITERAL",
+    "KW_EXPR_CALL_CLASSVAR",
     {"struct_name": str, "field_name": str, "type": VariableType},
 )
 ARGS_EXPR_CALL_CLASSVAR = tuple[str, str, VariableType]
@@ -253,7 +253,7 @@ class ExprNoReturn(_DisableReprBody, BaseAstNode[T_EMPTY_KWARGS, tuple]):
 # regex pattern auto converts to string
 T_CLASSVAR = int | str | bool | float | None
 KW_CLASSVAR = TypedDict(
-    "KW_LITERAL",
+    "KW_CLASSVAR",
     {
         "value": T_CLASSVAR,
         "struct_name": str,
@@ -262,7 +262,7 @@ KW_CLASSVAR = TypedDict(
         "is_regex": bool,
     },
 )
-ARGS_CLASSVAR = tuple[T_CLASSVAR, str, str]
+ARGS_CLASSVAR = tuple[T_CLASSVAR, str, str, bool, bool]
 
 
 @dataclass(kw_only=True)
@@ -286,7 +286,7 @@ class ExprClassVar(_DisableReprBody, BaseAstNode[KW_CLASSVAR, ARGS_CLASSVAR]):
         return self.kwargs["value"]
 
     @value.setter
-    def value(self, val) -> None:
+    def value(self, val: T_CLASSVAR) -> None:
         self.kwargs["value"] = val
 
     @property

ssc_codegen-0.12.0/ssc_codegen/ast_/nodes_filter.py

@@ -0,0 +1,285 @@
+from dataclasses import dataclass
+from typing import TypedDict, ClassVar
+
+from ssc_codegen.ast_.base import BaseAstNode, T_EMPTY_KWARGS
+from ssc_codegen.tokens import TokenType, VariableType
+
+
+# TODO: static analyzer for filter operations
+# TODO: implement operators for DOCUMENT, INT, FLOAT
+
+
+@dataclass(kw_only=True)
+class FilterOr(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_OR
+    # cast for reuse in Elements filters
+    # real accept: VariableType.STRING, VariableType.DOCUMENT
+    accept_type: VariableType = VariableType.ANY
+    ret_type: VariableType = VariableType.ANY
+    # TODO: typing body accept Filter-like nodes
+
+
+@dataclass(kw_only=True)
+class FilterAnd(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_AND
+    accept_type: VariableType = VariableType.ANY
+    ret_type: VariableType = VariableType.ANY
+    # TODO: typing body accept Filter-like nodes
+
+
+@dataclass(kw_only=True)
+class FilterNot(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_NOT
+    accept_type: VariableType = VariableType.ANY
+    ret_type: VariableType = VariableType.ANY
+    # TODO: typing body accept Filter-like nodes
+
+
+KW_STR_IN = TypedDict("KW_STR_IN", {"substr": tuple[str, ...]})
+ARGS_STR_IN = tuple[tuple[str, ...]]
+
+KW_STR_STARTS_OR_ENDS = TypedDict(
+    "KW_STR_STARTS_OR_ENDS", {"substr": tuple[str, ...]}
+)
+ARGS_STR_STARTS_OR_ENDS = tuple[tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class FilterStrIn(BaseAstNode[KW_STR_IN, ARGS_STR_IN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_IN
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrStarts(
+    BaseAstNode[KW_STR_STARTS_OR_ENDS, ARGS_STR_STARTS_OR_ENDS]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_STARTS
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrEnds(
+    BaseAstNode[KW_STR_STARTS_OR_ENDS, ARGS_STR_STARTS_OR_ENDS]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_ENDS
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+KW_STR_RE = TypedDict("KW_STR_RE", {"pattern": str, "ignore_case": bool})
+ARGS_STR_RE = tuple[str, bool]
+
+
+@dataclass(kw_only=True)
+class FilterStrRe(BaseAstNode[KW_STR_RE, ARGS_STR_RE]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_RE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+KW_STR_LEN = TypedDict("KW_STR_LEN", {"length": int})
+ARGS_STR_LEN = tuple[int]
+
+
+@dataclass(kw_only=True)
+class FilterStrLenEq(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_EQ
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrLenNe(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_NE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrLenLt(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_LT
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrLenLe(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_LE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrLenGt(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_GT
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrLenGe(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_GE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+# TODO: provide API for int, float, etc
+KW_STR_EQ_OR_NE = TypedDict("KW_STR_EQ_OR_NE", {"values": tuple[str, ...]})
+ARGS_STR_EQ_OR_NE = tuple[tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class FilterEqual(BaseAstNode[KW_STR_EQ_OR_NE, ARGS_STR_EQ_OR_NE]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_EQ
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterNotEqual(BaseAstNode[KW_STR_EQ_OR_NE, ARGS_STR_EQ_OR_NE]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_NE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class ExprFilter(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    kind: ClassVar[TokenType] = TokenType.EXPR_FILTER
+    accept_type: VariableType = VariableType.LIST_STRING
+    ret_type: VariableType = VariableType.LIST_STRING
+    # TODO: typing body accept Filter-like nodes
+
+
+# Elements filters
+@dataclass(kw_only=True)
+class ExprDocumentFilter(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    kind: ClassVar[TokenType] = TokenType.EXPR_DOC_FILTER
+    accept_type: VariableType = VariableType.LIST_DOCUMENT
+    ret_type: VariableType = VariableType.LIST_DOCUMENT
+
+
+KW_FILTER_CSS_OR_XPATH = TypedDict("KW_FILTER_CSS", {"query": str})
+ARGS_FILTER_CSS_OR_XPATH = tuple[str]
+
+
+@dataclass(kw_only=True)
+class FilterDocCss(
+    BaseAstNode[KW_FILTER_CSS_OR_XPATH, ARGS_FILTER_CSS_OR_XPATH]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_CSS
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocXpath(
+    BaseAstNode[KW_FILTER_CSS_OR_XPATH, ARGS_FILTER_CSS_OR_XPATH]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_XPATH
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+KW_FILTER_HAS_TEXT = TypedDict(
+    "KW_FILTER_HAS_TEXT", {"values": tuple[str, ...]}
+)
+ARGS_FILTER_HAS_TEXT = tuple[tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class FilterDocHasText(BaseAstNode[KW_FILTER_HAS_TEXT, ARGS_FILTER_HAS_TEXT]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_HAS_TEXT
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocHasRaw(BaseAstNode[KW_FILTER_HAS_TEXT, ARGS_FILTER_HAS_TEXT]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_HAS_RAW
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+KW_FILTER_HAS_ATTR = TypedDict("KW_FILTER_HAS_ATTR", {"keys": tuple[str, ...]})
+ARGS_FILTER_HAS_ATTR = tuple[tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class FilterDocHasAttr(BaseAstNode[KW_FILTER_HAS_ATTR, ARGS_FILTER_HAS_ATTR]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_HAS_ATTR
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+KW_FILTER_ATTR = TypedDict(
+    "KW_FILTER_ATTR", {"key": str, "values": tuple[str, ...]}
+)
+ARGS_FILTER_ATTR = tuple[str, tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class FilterDocAttrEqual(BaseAstNode[KW_FILTER_ATTR, ARGS_FILTER_ATTR]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_ATTR_EQ
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocAttrStarts(BaseAstNode[KW_FILTER_ATTR, ARGS_FILTER_ATTR]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_ATTR_STARTS
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocAttrEnds(BaseAstNode[KW_FILTER_ATTR, ARGS_FILTER_ATTR]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_ATTR_ENDS
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocAttrContains(BaseAstNode[KW_FILTER_ATTR, ARGS_FILTER_ATTR]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_ATTR_CONTAINS
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+KW_FILTER_ATTR_RE = TypedDict(
+    "KW_FILTER_ATTR", {"key": str, "pattern": str, "ignore_case": bool}
+)
+ARGS_FILTER_ATTR_RE = tuple[str, str, bool]
+
+
+@dataclass(kw_only=True)
+class FilterDocAttrRegex(BaseAstNode[KW_FILTER_ATTR_RE, ARGS_FILTER_ATTR_RE]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_ATTR_RE_MATCH
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+KW_FILTER_IS_REGEX = TypedDict(
+    "KW_FILTER_IS_REGEX", {"pattern": str, "ignore_case": bool}
+)
+ARGS_FILTER_IS_REGEX = tuple[str, bool]
+
+
+@dataclass(kw_only=True)
+class FilterDocIsRegexText(
+    BaseAstNode[KW_FILTER_IS_REGEX, ARGS_FILTER_IS_REGEX]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_IS_RE_TEXT
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocIsRegexRaw(
+    BaseAstNode[KW_FILTER_IS_REGEX, ARGS_FILTER_IS_REGEX]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_IS_RE_RAW
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT

{ssc_codegen-0.11.0 → ssc_codegen-0.12.0}/ssc_codegen/ast_build/builder.py

@@ -150,7 +150,7 @@ class AstBuilder:
 
     def _literal_struct_node(self, schema: Type[BaseSchema]) -> StructParser:
         # dont required TypeDef struct generate
-        literals = schema.__get_mro_literals__().copy()
+        literals = schema.__get_mro_classvars__().copy()
         st = StructParser(
             kwargs={
                 "name": schema.__name__,
@@ -175,7 +175,7 @@ class AstBuilder:
         parent = node_method
         for expr in node_method.body:
             expr.parent = parent
-            if expr.kind == TokenType.EXPR_FILTER:
+            if expr.kind in (TokenType.EXPR_FILTER, TokenType.EXPR_DOC_FILTER):
                 self._ref_filter_expr(expr, expr.body)
 
     def _unwrap_default_node(
@@ -251,7 +251,7 @@ class AstBuilder:
         exprs.append(ExprNoReturn())
         method.body.extend(exprs)
         self._ref_method_exprs(method)
-        node_start_parse.body.append(ExprCallStructMethod(kwargs={"type": VariableType.NULL, "name": "__PRE_VALIDATE__",}))
+        node_start_parse.body.append(ExprCallStructMethod(kwargs={"type": VariableType.NULL, "name": "__PRE_VALIDATE__",}, ret_type=VariableType.NULL))
         return method
         # fmt: on
 
@@ -270,7 +270,11 @@ class AstBuilder:
         exprs.append(ExprReturn(ret_type=VariableType.LIST_DOCUMENT))
         method.body.extend(exprs)
         self._ref_method_exprs(method)
-        node_start_parse.body.append(ExprCallStructMethod(kwargs={"type": VariableType.LIST_DOCUMENT, "name": "__SPLIT_DOC__",}))
+        node_start_parse.body.append(
+            ExprCallStructMethod(
+                kwargs={"type": VariableType.LIST_DOCUMENT, "name": "__SPLIT_DOC__",}, 
+                ret_type=VariableType.LIST_DOCUMENT)
+            )
         return method
         # fmt: on
 
@@ -314,7 +318,7 @@ class AstBuilder:
             self._ref_method_exprs(method)
             st_fields.append(method)
             node_start_parse.body.append(
-                ExprCallStructMethod(kwargs={"type": exprs[-1].ret_type, "name": field_name,}))
+                ExprCallStructMethod(kwargs={"type": exprs[-1].ret_type, "name": field_name,}, ret_type=exprs[-1].ret_type))
         return st_fields
         # fmt: on
 
@@ -368,7 +372,7 @@ class AstBuilder:
             kwargs={"name": schema.__name__, "struct_type": schema.__SCHEMA_TYPE__, "docstring": docstring if self.gen_docstr else "",},
             parent=self.module,
             )
-        literals = schema.__get_mro_literals__().copy()
+        literals = schema.__get_mro_classvars__().copy()
 
         for literal in literals.values():
             st.body.append(literal.expr())

{ssc_codegen-0.11.0 → ssc_codegen-0.12.0}/ssc_codegen/ast_build/utils.py

@@ -151,5 +151,5 @@ def exec_module_code(path: str | Path, add_sys_path: bool = True) -> ModuleType:
 def is_literals_only_schema(schema: Type[BaseSchema]) -> bool:
     return (
         len(schema.__get_mro_fields__()) == 0
-        and len(schema.__get_mro_literals__()) > 0
+        and len(schema.__get_mro_classvars__()) > 0
     )

{ssc_codegen-0.11.0 → ssc_codegen-0.12.0}/ssc_codegen/converters/base.py

@@ -154,8 +154,8 @@ class BaseCodeConverter:
             if for_struct_definition:
                 self.post_definitions[
                     (for_definition, for_struct_definition)
-                ] = post_callback
-            self.post_definitions[for_definition] = post_callback
+                ] = post_callback  # type: ignore[assignment]
+            self.post_definitions[for_definition] = post_callback  # type: ignore[assignment]
 
         return decorator
 
@@ -277,6 +277,7 @@ class BaseCodeConverter:
 
             case (
                 TokenType.EXPR_FILTER
+                | TokenType.EXPR_DOC_FILTER
                 | TokenType.FILTER_OR
                 | TokenType.FILTER_AND
                 | TokenType.FILTER_NOT