ssc_codegen 0.13.0__tar.gz → 0.13.2__tar.gz

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.13.0
+Version: 0.13.2
 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.13.0 → ssc_codegen-0.13.2}/pyproject.toml

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

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/__init__.py

@@ -7,7 +7,7 @@ from ssc_codegen.schema import ItemSchema, DictSchema, ListSchema, FlatListSchem
 
 setup_logger()
 
-VERSION = "0.13.0"
+VERSION = "0.13.2"
 
 
 class __MISSING(object):

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/ast_/__init__.py

@@ -120,7 +120,6 @@ from .nodes_validate import (
     ExprIsEqual,
     ExprStringIsRegex,
     ExprIsXpath,
-    ExprIsNotEqual,
     ExprIsContains,
     ExprListStringAnyRegex,
     ExprListStringAllRegex,

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/ast_build/main.py

@@ -13,7 +13,7 @@ from ssc_codegen.schema import BaseSchema
 from ssc_codegen.static_checker import run_analyze_schema
 import logging
 
-LOGGER = logging.getLogger("ssc-gen")
+LOGGER = logging.getLogger("ssc_gen")
 
 
 def build_ast_module_parser(
@@ -37,6 +37,9 @@ def build_ast_module_parser(
     py_module = exec_module_code(path)
     # check code configs before build AST
     schemas = extract_schemas_from_module(py_module)
+    if len(schemas) == 0:
+        LOGGER.warning(f"{path} does not contains defined schemas")
+
     count_errors = 0
     for schema in schemas:
         errors = run_analyze_schema(schema)

ssc_codegen-0.13.2/ssc_codegen/ast_grep_rules/py_drop_prefix_suffix_backport.yml

@@ -0,0 +1,47 @@
+id: py_drop_prefix_backport
+language: python
+rule:
+  pattern:
+    context: |-
+      def ssc_rm_prefix($$$) -> str:$$$
+fix: ''
+---
+id: py_fix_new_prefix_syntax
+language: python
+rule:
+  pattern:
+    context: ssc_rm_prefix($V, $P)
+fix: '$V.removeprefix($P)'
+
+---
+id: py_drop_suffix_backport
+language: python
+rule:
+  pattern:
+    context: |-
+      def ssc_rm_suffix($$$) -> str:$$$
+fix: ''
+---
+id: py_fix_new_suffix_syntax
+language: python
+rule:
+  pattern:
+    context: ssc_rm_suffix($V, $P)
+fix: '$V.removesuffix($P)'
+---
+
+id: py_drop_prefix_suffix_backport
+language: python
+rule:
+  pattern:
+    context: |-
+      def ssc_rm_prefix_and_suffix($$$) -> str:$$$
+fix: ''
+---
+id: py_fix_new_prefix_suffix_syntax
+language: python
+rule:
+  pattern:
+    context: ssc_rm_prefix_and_suffix($V, $P1, $P2)
+fix: 
+  '$V.removeprefix($P1).removesuffix($P2)'

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/cli/ast_grep.py

@@ -4,4 +4,5 @@ from importlib import resources
 RULES_PATH = resources.files("ssc_codegen.ast_grep_rules")
 
 PY_RULES = str(RULES_PATH.joinpath("py_rules.yml"))
+PY_NEW_RM_PREFIX_SUFFIX_SYNTAX = str(RULES_PATH.joinpath("py_drop_prefix_suffix_backport.yml"))
 JS_RULES = str(RULES_PATH.joinpath("js_rules.yml"))

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/cli/main.py

@@ -11,7 +11,7 @@ from ichrome.exceptions import ChromeRuntimeError
 from typer import Argument, BadParameter, Option, Typer
 
 from ssc_codegen.ast_build import build_ast_module_parser
-from ssc_codegen.cli.ast_grep import JS_RULES, PY_RULES
+from ssc_codegen.cli.ast_grep import JS_RULES, PY_RULES, PY_NEW_RM_PREFIX_SUFFIX_SYNTAX
 from ssc_codegen.cli.cli_callbacks import cb_check_ssc_files, cb_folder_out
 from ssc_codegen.cli.cli_utils import (
     ConverterLike,
@@ -168,6 +168,9 @@ def gen_py(
     docstring: Annotated[
         bool, Option(help=HELP_DOCSTRING, is_flag=True)
     ] = True,
+    fmt_prefix_suffix_backport: Annotated[
+        bool, Option("-frps", '--fmt-remove-prefix-suffix',
+            help="[PY39+]: replace backport funcs to str.removeprefix(...) and str.removesuffix(...)")] = False
 ) -> None:
     converter = import_converter(f"py_{lib.value}")
     if fmt:
@@ -176,10 +179,14 @@ def gen_py(
             "ruff check {} --fix",
             f"ast-grep scan --rule {PY_RULES} -U " + "{}",
         ]
+        if fmt_prefix_suffix_backport:
+            commands.append(f"ast-grep scan --rule {PY_NEW_RM_PREFIX_SUFFIX_SYNTAX} -U " + "{}")
         fmt_cmd = create_fmt_cmd(ssc_files, prefix, suffix, out, commands)
     else:
         fmt_cmd = []
 
+
+
     generate_code(
         converter=converter,
         out=out,

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/converters/base.py

@@ -28,6 +28,18 @@ CB_AST_DECORATOR = Callable[[CB_AST_BIND], CB_AST_BIND]
 
 
 def debug_comment_cb(node: BaseAstNode, comment_prefix: str) -> str:
+    """Generate a debug comment for an AST node.
+
+    Creates a formatted string containing information about the node's type,
+    return type (if applicable), and other relevant details for debugging purposes.
+
+    Args:
+        node: The AST node to generate a comment for.
+        comment_prefix: The prefix to add to each line of the comment.
+
+    Returns:
+        A formatted string containing debug information about the node.
+    """
     match node.kind:
         case TokenType.EXPR_RETURN:
             token = f"{comment_prefix}Token: {node.kind.name} ret_type: {node.ret_type.name}"
@@ -48,16 +60,60 @@ def debug_comment_cb(node: BaseAstNode, comment_prefix: str) -> str:
 
 
 class BaseCodeConverter:
-    """base ast visitor class and code converter
-
-    Visitor is set using decorators pointing to the TokenType
-
-    decorators hooks can be overridden
-
-    - as defaults __call__ methods - set @pre decorator
-    - @pre - first trigger visitor entrypoint
-    - @post - second trigger visitor entrypoint (for close brackets or other logic, for example)
-
+    """Base AST visitor class and code converter.
+
+    This class serves as the foundation for converting AST nodes into code.
+    Visitors are set using decorators that point to specific TokenTypes.
+
+    Decorator hooks can be overridden:
+    - As defaults, __call__ methods set @pre decorator
+    - @pre - First trigger visitor entrypoint
+    - @post - Second trigger visitor entrypoint (for closing brackets or other logic).
+    It will be called when the broadcast of all nodes and the container body is transpiled.
+
+    Example:
+        ```
+        CONVERTER = BaseCodeConverter()
+
+        # recommended use <node>.kind call as key in decorators instead TokenType.<TOKEN>
+        @CONVERTER(ModuleImports.kind)
+        def pre_imports(_node: ModuleImports) -> str:
+            # implement imports stmt
+            return '''from bs4 import BeautifulSoap'''
+
+        # TypeDef and StartParseMethod node allow add extra second shortcut as StructType for
+        # increase code readability and simplify codegen
+
+        # TYPEDEF Impl
+        # post_callback - shortcut for minify typical end expr (eg: close parens)
+
+        # generate type for StructType.ITEM parser
+        @CONVERTER(TypeDef.kind, StructType.ITEM, post_callback=lambda _: "})")
+        def pre_typedef_item(node: TypeDef) -> str:
+            name, _ = node.unpack_args()
+            return f'T_{name} = TypedDict("T_{name}", ' + "{"
+
+        # generate type for StructType.DICT parser
+        @CONVERTER(TypeDef.kind, StructType.DICT)
+        def pre_typedef_dict(node: TypeDef) -> str:
+            name, _ = node.unpack_args()
+            type_ = get_typedef_field_by_name(node, "__VALUE__")
+            return f"T_{name} = Dict[str, {type_}]"
+
+        # StartParse impl
+        @CONVERTER(StartParseMethod.kind, StructType.ITEM)
+        def pre_start_parse_item(node: StartParseMethod) -> str:
+            # some impl for ItEM struct
+            return ""
+
+        @CONVERTER(StartParseMethod.kind, StructType.LIST)
+        def pre_start_parse_list(node: StartParseMethod) -> str:
+            # some impl for LIST struct
+            return ""
+        ```
+
+    Attributes:
+        TEST_EXCLUDE_NODES: List of token types to exclude from tests.
     """
 
     TEST_EXCLUDE_NODES: ClassVar[list[TokenType]] = [
@@ -70,7 +126,7 @@ class BaseCodeConverter:
         TokenType.STRUCT_CALL_FUNCTION,
         TokenType.STRUCT_CALL_CLASSVAR,
     ]
-    """dev classvar marks exclude nodes in tests"""
+    """Developer class variable that marks nodes to exclude in tests."""
 
     def __init__(
         self,
@@ -80,10 +136,10 @@ class BaseCodeConverter:
         debug_cb: CB_FMT_DEBUG_COMMENT = debug_comment_cb,
     ) -> None:
         """
-
-        :param debug_instructions: enable debug instructions (add comment for every generated instruction)
-        :param debug_comment_prefix: comment line prefix
-        :param debug_cb: callback formatting comment
+        Arguments:
+        debug_instructions: enable debug instructions (add comment for every generated instruction. used in debug codegen output)
+        debug_comment_prefix: comment line prefix (used in debug codegen output)
+        debug_cb: callback formatting comment (used in debug codegen output)
         """
         self._debug_instructions = debug_instructions
         self._debug_comment_prefix = debug_comment_prefix
@@ -131,14 +187,14 @@ class BaseCodeConverter:
 
         optional allow set post callback for simple string casts like close brackets etc
 
-        StartParseMethod has shortcut (StartParseMethod.kind, StructType.<TYPE>) for simplify callback generators
+        StartParseMethod and TypeDef nodes has shortcut (StartParseMethod.kind, StructType.<TYPE>) for simplify callback generators
         """
         if for_struct_definition and for_definition not in (
             StartParseMethod.kind,
             TypeDef.kind,
         ):
             raise TypeError(
-                "Add struct definition allowed only for `StartParseMethod` nodes"
+                "Add struct definition allowed only for `StartParseMethod` and `TypeDef` nodes"
             )
 
         def decorator(func: CB_AST_BIND) -> CB_AST_BIND:
@@ -164,7 +220,23 @@ class BaseCodeConverter:
         for_definition: TokenType,
         for_struct_definition: StructType | None = None,
     ) -> CB_AST_DECORATOR:
-        """Define a post-conversion decorator for the given TokenType."""
+        """Define a post-conversion decorator for the given TokenType.
+
+        This method creates a decorator that registers a function to be called
+        after the main conversion of a node of the specified type. It's typically
+        used for closing brackets or other logic that should happen after the
+        main node processing.
+
+        Args:
+            for_definition: The TokenType to associate with this post-conversion function.
+            for_struct_definition: Optional StructType for specific struct definitions (for StartParseMethod and TypeDef).
+
+        Returns:
+            A decorator function that registers the post-conversion handler.
+
+        Raises:
+            TypeError: If struct definition is provided for unsupported node types.
+        """
         if for_struct_definition and for_definition not in (
             StartParseMethod.kind,
             TypeDef.kind,
@@ -191,7 +263,19 @@ class BaseCodeConverter:
         *,
         post_callback: Callable[[BaseAstNode], str] | None = None,
     ) -> CB_AST_DECORATOR:
-        """Alias for pre decorator."""
+        """Alias for pre decorator.
+
+        Provides a convenient way to use the pre decorator by calling the class instance
+        directly. This is equivalent to calling the pre() method.
+
+        Args:
+            for_definition: The TokenType to associate with this conversion function.
+            for_struct_definition: Optional StructType for specific struct definitions (only for StartParseMethod and TypeDef nodes).
+            post_callback: Optional callback function for post-processing.
+
+        Returns:
+            A decorator function that registers the conversion handler.
+        """
         return self.pre(
             for_definition, for_struct_definition, post_callback=post_callback
         )
@@ -199,7 +283,20 @@ class BaseCodeConverter:
     def _pre_convert_node(
         self, node: BaseAstNode, st_type: StructType | None = None
     ) -> str:
-        """Convert the AST node using the pre-definition function."""
+        """Convert the AST node using the pre-definition function.
+
+        This method applies the registered pre-conversion function to an AST node,
+        optionally using a specific struct type for more granular control. It handles
+        both simple node conversions and struct-specific conversions.
+
+        Args:
+            node: The AST node to convert.
+            st_type: Optional StructType for struct-specific conversions.
+
+        Returns:
+            The result of applying the pre-conversion function to the node,
+            or an empty string if no matching function is found.
+        """
         # syntax sugar: split generate start_parse methods by part callbacks
         if (
             node.kind in (StartParseMethod.kind, TypeDef.kind)
@@ -220,7 +317,21 @@ class BaseCodeConverter:
     def _post_convert_node(
         self, node: BaseAstNode, st_type: StructType | None = None
     ) -> str:
-        """Convert the AST node using the post-definition function."""
+        """Convert the AST node using the post-definition function.
+
+        This method applies the registered post-conversion function to an AST node,
+        optionally using a specific struct type for more granular control. It's typically
+        used for closing brackets or other logic that should happen after the main
+        node processing.
+
+        Args:
+            node: The AST node to convert.
+            st_type: Optional StructType for struct-specific conversions.
+
+        Returns:
+            The result of applying the post-conversion function to the node,
+            or an empty string if no matching function is found.
+        """
         # syntax sugar: split generate start_parse methods by part callbacks
         if (
             node.kind in (StartParseMethod.kind, TypeDef.kind)
@@ -239,7 +350,19 @@ class BaseCodeConverter:
     def convert_program(
         self, ast_program: ModuleProgram, comment: str = ""
     ) -> list[str]:
-        """Convert the module AST to code parts."""
+        """Convert the module AST to code parts.
+
+        This method converts an entire module AST into a list of code parts,
+        starting with an optional comment and processing all nodes in the AST.
+
+        Args:
+            ast_program: The ModuleProgram AST node to convert.
+            comment: An optional comment to include at the beginning of the output.
+
+        Returns:
+            A list of strings representing the converted code parts,
+            with empty strings filtered out.
+        """
         acc = [comment]
         result = self.convert(ast_program, acc)
         return [i for i in result if i]
@@ -247,7 +370,19 @@ class BaseCodeConverter:
     def convert(
         self, ast_entry: BaseAstNode, acc: list[str] | None = None
     ) -> list[str]:
-        """Convert an AST node into code parts."""
+        """Convert an AST node into code parts.
+
+        This method dispatches the conversion of an AST node to the appropriate
+        conversion method based on the node's type. It builds up a list of code
+        parts by processing the node and its children.
+
+        Args:
+            ast_entry: The AST node to convert.
+            acc: An optional accumulator list to append code parts to.
+
+        Returns:
+            A list of strings representing the converted code parts.
+        """
         acc = acc or []
         match ast_entry.kind:
             case TokenType.MODULE:
@@ -307,6 +442,22 @@ class BaseCodeConverter:
     def _convert_logic_filter(
         self, ast_entry: FilterOr | FilterAnd | FilterNot, acc: list[str]
     ) -> None:
+        """Convert a logical filter node (OR, AND, NOT) and its children.
+
+        This method handles the conversion of logical filter operations, appending
+        the pre-conversion result, processing all child nodes, and then appending
+        the post-conversion result.
+
+        For example, an AND filter with two children would be converted as:
+        AND(body=[F1, F2]) ->
+        AND ( (OPEN)
+              F1 and F2
+        ) (CLOSE)
+
+        Args:
+            ast_entry: The logical filter node (FilterOr, FilterAnd, or FilterNot) to convert.
+            acc: The accumulator list to append code parts to.
+        """
         # AND(body=[F1, F2]) ->
         # AND ( (OPEN)
         #       F1 and F2
@@ -317,7 +468,15 @@ class BaseCodeConverter:
         acc.append(self._post_convert_node(ast_entry))
 
     def _convert_module(self, ast_entry: ModuleProgram, acc: list[str]) -> None:
-        """Handle module conversion."""
+        """Handle module conversion.
+
+        This method processes all nodes in a module's body by recursively converting
+        each one and appending the results to the accumulator.
+
+        Args:
+            ast_entry: The ModuleProgram node to convert.
+            acc: The accumulator list to append code parts to.
+        """
         for node in ast_entry.body:
             self.convert(node, acc)
 

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/converters/js_pure.py

@@ -51,7 +51,6 @@ from ssc_codegen.ast_ import (
     ExprIndex,
     ExprListStringJoin,
     ExprIsEqual,
-    ExprIsNotEqual,
     ExprIsContains,
     ExprStringIsRegex,
     ExprToInt,
@@ -848,7 +847,7 @@ def pre_is_css(node: ExprIsCss) -> str:
     expr = f"({prv}.querySelector({query}) === null)"
     if invert:
         expr = f"!{expr}"
-    expr = f'if {expr}'
+    expr = f"if {expr}"
     expr = f"{expr} throw new Error({msg});"
     if is_last_var_no_ret(node):
         return expr
@@ -865,7 +864,7 @@ def pre_is_xpath(node: ExprIsXpath) -> str:
     expr = f"(document.evaluate({query}, {prv}, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue === null)"
     if invert:
         expr = f"!{expr}"
-    expr = f'if {expr}'
+    expr = f"if {expr}"
     code = [
         f"{expr}",
         "{",
@@ -1076,8 +1075,8 @@ def pre_has_attr(node: ExprHasAttr) -> str:
     invert = node.kwargs["invert"]
     expr = f"!{prv}?.hasAttribute({key})"
     if invert:
-        expr = f'!({expr})'
-    expr = f"if ({expr})"
+        expr = f"!({expr})"
+    expr = f"if ({expr}) throw new Error({msg}); "
     if is_last_var_no_ret(node):
         return expr
     return expr + f"let {nxt} = {prv};"

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/converters/py_base.py

@@ -963,7 +963,7 @@ def pre_is_contains(node: ExprIsContains) -> str:
 
     item = py_get_classvar_hook_or_value(node, "item")
     msg = py_get_classvar_hook_or_value(node, "msg")
-    
+
     if invert:
         expr = f"{item} not in {prv}"
     else:

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/converters/py_lxml.py

@@ -67,17 +67,16 @@ CONVERTER = BasePyCodeConverter()
 def pre_init(_node: StructInitMethod) -> str:
     return (
         INDENT_METHOD
-        + "def __init__(self, document: Union[str, etree._Element]) -> None:\n"
+        + "def __init__(self, document: Union[str, html.HtmlElement]) -> None:\n"
         + INDENT_METHOD_BODY
-        + "self._document = etree.HTML(document) if isinstance(document, str) else document"
+        + "self._document = html.fromstring(document) if isinstance(document, str) else document"
     )
 
 
 @CONVERTER(StructPreValidateMethod.kind)
 def pre_struct_pre_validate(_node: StructPreValidateMethod) -> str:
     return (
-        INDENT_METHOD
-        + "def _pre_validate(self, v: Union[etree._Element, List[etree._Element]]) -> None:"
+        INDENT_METHOD + "def _pre_validate(self, v: html.HtmlElement) -> None:"
     )
 
 
@@ -85,7 +84,7 @@ def pre_struct_pre_validate(_node: StructPreValidateMethod) -> str:
 def pre_struct_part_doc_method(_node: StructPartDocMethod) -> str:
     return (
         INDENT_METHOD
-        + "def _split_doc(self, v: Union[etree._Element, List[etree._Element]]) -> List[etree._Element]:"
+        + "def _split_doc(self, v: html.HtmlElement) -> List[html.HtmlElement]:"
     )
 
 
@@ -96,13 +95,13 @@ def pre_struct_field_method(node: StructFieldMethod) -> str:
     name = MAGIC_METHODS.get(name, name)
     return (
         INDENT_METHOD
-        + f"def _parse_{name}(self, v: Union[etree._Element, List[etree._Element]]) -> {type_}:"
+        + f"def _parse_{name}(self, v: html.HtmlElement) -> {type_}:"
     )
 
 
 @CONVERTER(ModuleImports.kind)
 def pre_imports(_: ModuleImports) -> str:
-    return IMPORTS_MIN + """from lxml import etree, html"""
+    return IMPORTS_MIN + """from lxml import html, etree"""
 
 
 @CONVERTER(ExprCss.kind)
@@ -112,7 +111,7 @@ def pre_css(node: ExprCss) -> str:
     )
     prv, nxt = prev_next_var(node)
     query = py_get_classvar_hook_or_value(node, "query")
-    return indent + f"{nxt} = etree.CSSSelector({query})({prv})[0]"
+    return indent + f"{nxt} = {prv}.cssselect({query})[0]"
 
 
 @CONVERTER(ExprCssAll.kind)
@@ -122,7 +121,7 @@ def pre_css_all(node: ExprCssAll) -> str:
     )
     prv, nxt = prev_next_var(node)
     query = py_get_classvar_hook_or_value(node, "query")
-    return indent + f"{nxt} = etree.CSSSelector({query})({prv})"
+    return indent + f"{nxt} = {prv}.cssselect({query})"
 
 
 @CONVERTER(ExprXpath.kind)
@@ -154,8 +153,9 @@ def pre_html_attr(node: ExprGetHtmlAttr) -> str:
     keys = node.kwargs["key"]
     if len(keys) == 1:
         key = keys[0]
-        return indent + f"{nxt} = {prv}.attrib[{key!r}]"
-    return indent + f"{nxt} = [{prv}.attrib[k] for k in {keys}]"
+        return indent + f"{nxt} = {prv}.get({key!r})"
+    key_accesses = [f"{prv}.get({k!r})" for k in keys]
+    return indent + f"{nxt} = [{', '.join(key_accesses)}]"
 
 
 @CONVERTER(ExprGetHtmlAttrAll.kind)
@@ -167,8 +167,8 @@ def pre_html_attr_all(node: ExprGetHtmlAttrAll) -> str:
     keys = node.kwargs["key"]
     if len(keys) == 1:
         key = keys[0]
-        return indent + f"{nxt} = [e.attrib[{key!r}] for e in {prv}]"
-    return indent + f"{nxt} = [e.attrib[k] for e in {prv} for k in {keys}]"
+        return indent + f"{nxt} = [e.get({key!r}) for e in {prv}]"
+    return indent + f"{nxt} = [e.get(k) for e in {prv} for k in {keys}]"
 
 
 @CONVERTER(ExprGetHtmlText.kind)
@@ -177,7 +177,7 @@ def pre_html_text(node: ExprGetHtmlText) -> str:
         INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY
     )
     prv, nxt = prev_next_var(node)
-    return indent + f"{nxt} = ''.join({prv}.itertext())"
+    return indent + f"{nxt} = {prv}.text_content()"
 
 
 @CONVERTER(ExprGetHtmlTextAll.kind)
@@ -186,7 +186,7 @@ def pre_html_text_all(node: ExprGetHtmlTextAll) -> str:
         INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY
     )
     prv, nxt = prev_next_var(node)
-    return indent + f"{nxt} = [text for e in {prv} for text in e.itertext()]"
+    return indent + f"{nxt} = [e.text_content() for e in {prv}]"
 
 
 @CONVERTER(ExprGetHtmlRaw.kind)
@@ -195,7 +195,7 @@ def pre_html_raw(node: ExprGetHtmlRaw) -> str:
         INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY
     )
     prv, nxt = prev_next_var(node)
-    return indent + f"{nxt} = etree.tostring({prv}, encoding='unicode')"
+    return indent + f"{nxt} = html.tostring({prv}, encoding='unicode')"
 
 
 @CONVERTER(ExprGetHtmlRawAll.kind)
@@ -206,7 +206,7 @@ def pre_html_raw_all(node: ExprGetHtmlRawAll) -> str:
     prv, nxt = prev_next_var(node)
     return (
         indent
-        + f"{nxt} = [etree.tostring(e, encoding='unicode') for e in {prv}]"
+        + f"{nxt} = [html.tostring(e, encoding='unicode') for e in {prv}]"
     )
 
 
@@ -220,9 +220,9 @@ def pre_is_css(node: ExprIsCss) -> str:
     msg = py_get_classvar_hook_or_value(node, "msg")
     invert = node.kwargs["invert"]
 
-    expr = f"etree.CSSSelector({query})({prv})"
+    expr = f"{prv}.cssselect({query})"
     if invert:
-        expr = f"not ({expr})"
+        expr = f"not {expr}"
 
     expr = indent + f"assert {expr}, {msg}"
     if is_last_var_no_ret(node):
@@ -255,19 +255,19 @@ def pre_has_attr(node: ExprHasAttr) -> str:
         INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY
     )
     prv, nxt = prev_next_var(node)
-    key, msg = node.unpack_args()
     key = py_get_classvar_hook_or_value(node, "key")
     msg = py_get_classvar_hook_or_value(node, "msg")
     invert = node.kwargs["invert"]
 
-    expr = f"{prv}.attrib[{key}]"
+    expr = f"{prv}.get({key}) is not None"
     if invert:
         expr = f"not ({expr})"
 
     expr = indent + f"assert {expr}, {msg}"
     if is_last_var_no_ret(node):
         return expr
-    return "\n".join(expr, indent + f"{nxt} = {prv}")
+    # Исправлено: добавлена запятая в join
+    return "\n".join([expr, indent + f"{nxt} = {prv}"])
 
 
 @CONVERTER(ExprListHasAttr.kind)
@@ -280,7 +280,7 @@ def pre_list_has_attr(node: ExprListHasAttr) -> str:
     msg = py_get_classvar_hook_or_value(node, "msg")
     invert = node.kwargs["invert"]
 
-    expr = f"all(i.attrib[{key}] for i in {prv})"
+    expr = f"all(i.get({key}) is not None for i in {prv})"
     if invert:
         expr = f"not ({expr})"
 
@@ -318,7 +318,7 @@ def pre_css_remove(node: ExprCssElementRemove) -> str:
 
     return (
         indent
-        + f"[e.getparent().remove(e) for e in etree.CSSSelector({query})({prv}) if e.getparent() is not None]\n"
+        + f"[e.getparent().remove(e) for e in {prv}.cssselect({query}) if e.getparent() is not None]\n"
         + indent
         + f"{nxt} = {prv}"
     )
@@ -365,9 +365,9 @@ def pre_doc_filter_css(node: FilterDocCss) -> str:
 def pre_doc_filter_has_attr(node: FilterDocHasAttr) -> str:
     keys = node.kwargs["keys"]
     if len(keys) == 1:
-        expr = f"{keys[0]!r} in e.attrib"
+        expr = f"e.get({keys[0]!r}) is not None"
     else:
-        expr = f"any(i in e.attrib for i in {keys})"
+        expr = f"any(e.get(i) is not None for i in {keys})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return "and " + expr
     return expr
@@ -377,9 +377,9 @@ def pre_doc_filter_has_attr(node: FilterDocHasAttr) -> str:
 def pre_doc_filter_attr_eq(node: FilterDocAttrEqual) -> str:
     key, values = node.unpack_args()
     if len(values) == 1:
-        expr = f"e.attrib[{key!r}] == {values[0]!r}"
+        expr = f"e.get({key!r}) == {values[0]!r}"
     else:
-        expr = f"e.attrib[{key!r}] in {values}"
+        expr = f"e.get({key!r}) in {values}"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return "and " + expr
     return expr
@@ -389,9 +389,9 @@ def pre_doc_filter_attr_eq(node: FilterDocAttrEqual) -> str:
 def pre_doc_filter_attr_contains(node: FilterDocAttrContains) -> str:
     key, values = node.unpack_args()
     if len(values) == 1:
-        expr = f"{values[0]!r} in e.attrib[{key!r}]"
+        expr = f"{values[0]!r} in (e.get({key!r}) or '')"
     else:
-        expr = f"any(i in e.attrib[{key!r}] for i in {values})"
+        expr = f"any(i in (e.get({key!r}) or '') for i in {values})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return "and " + expr
     return expr
@@ -401,10 +401,10 @@ def pre_doc_filter_attr_contains(node: FilterDocAttrContains) -> str:
 def pre_doc_filter_attr_starts(node: FilterDocAttrContains) -> str:
     key, values = node.unpack_args()
     if len(values) == 1:
-        expr = f"e.attrib[{key!r}].startswith({values[0]!r})"
+        expr = f"(e.get({key!r}) or '').startswith({values[0]!r})"
     else:
         # str.startswith() arg allow tuple[str, ...]
-        expr = f"e.attrib[{key!r}].startswith({values})"
+        expr = f"(e.get({key!r}) or '').startswith({values})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return "and " + expr
     return expr
@@ -414,10 +414,10 @@ def pre_doc_filter_attr_starts(node: FilterDocAttrContains) -> str:
 def pre_doc_filter_attr_ends(node: FilterDocAttrContains) -> str:
     key, values = node.unpack_args()
     if len(values) == 1:
-        expr = f"e.attrib[{key!r}].endswith({values[0]!r})"
+        expr = f"(e.get({key!r}) or '').endswith({values[0]!r})"
     else:
         # str.endswith() arg allow tuple[str, ...]
-        expr = f"e.attrib[{key!r}].endswith({values})"
+        expr = f"(e.get({key!r}) or '').endswith({values})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return "and " + expr
     return expr
@@ -427,11 +427,12 @@ def pre_doc_filter_attr_ends(node: FilterDocAttrContains) -> str:
 def pre_doc_filter_attr_re(node: FilterDocAttrRegex) -> str:
     key, pattern, ignore_case = node.unpack_args()
     flags = py_regex_flags(ignore_case)
+
+    attr_value = f"e.get({key!r}) or ''"
     if flags:
-        expr = f"re.search({pattern!r}, e.attrib[{key!r}], {flags})"
+        expr = f"re.search({pattern!r}, {attr_value}, {flags})"
     else:
-        expr = f"re.search({pattern!r}, e.attrib[{key!r}], ''))"
-    expr = f"bool({expr})"
+        expr = f"re.search({pattern!r}, {attr_value})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return "and " + expr
     return expr
@@ -442,10 +443,12 @@ def pre_doc_filter_is_regex_text(node: FilterDocIsRegexText) -> str:
     pattern, ignore_case = node.unpack_args()
 
     flags = py_regex_flags(ignore_case)
+
+    text_content_call = "e.text_content()"
     if flags:
-        expr = f"re.search({pattern!r}, ''.join(e.itertext()), {flags})"
+        expr = f"re.search({pattern!r}, {text_content_call}, {flags})"
     else:
-        expr = f"re.search({pattern!r}, ''.join(e.itertext()))"
+        expr = f"re.search({pattern!r}, {text_content_call})"
     expr = f"bool({expr})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return "and " + expr
@@ -457,10 +460,11 @@ def pre_doc_filter_is_regex_raw(node: FilterDocIsRegexText) -> str:
     pattern, ignore_case = node.unpack_args()
 
     flags = py_regex_flags(ignore_case)
+    raw_content_call = "etree.tostring(e, encoding='unicode')"
     if flags:
-        expr = f"re.search({pattern!r}, etree.tostring(e, encoding='unicode'), {flags})"
+        expr = f"re.search({pattern!r}, {raw_content_call}, {flags})"
     else:
-        expr = f"re.search({pattern!r}, etree.tostring(e, encoding='unicode'))"
+        expr = f"re.search({pattern!r}, {raw_content_call})"
     expr = f"bool({expr})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return "and " + expr
@@ -470,10 +474,12 @@ def pre_doc_filter_is_regex_raw(node: FilterDocIsRegexText) -> str:
 @CONVERTER(FilterDocHasText.kind)
 def pre_doc_filter_has_text(node: FilterDocHasText) -> str:
     values = node.kwargs["values"]
+
+    text_content_call = "e.text_content()"
     if len(values) == 1:
-        expr = f"{values[0]!r} in ''.join(e.itertext())"
+        expr = f"{values[0]!r} in {text_content_call}"
     else:
-        expr = f"any(i in ''.join(e.itertext()) for i in {values})"
+        expr = f"any(i in {text_content_call} for i in {values})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return "and " + expr
     return expr
@@ -482,11 +488,12 @@ def pre_doc_filter_has_text(node: FilterDocHasText) -> str:
 @CONVERTER(FilterDocHasRaw.kind)
 def pre_doc_filter_has_raw(node: FilterDocHasText) -> str:
     values = node.kwargs["values"]
+
     if len(values) == 1:
-        expr = f"{values[0]!r} in etree.tostring(e, encoding='unicode')"
+        expr = f"{values[0]!r} in html.tostring(e, encoding='unicode')"
     else:
         expr = (
-            f"any(i in etree.tostring(e, encoding='unicode') for i in {values})"
+            f"any(i in html.tostring(e, encoding='unicode') for i in {values})"
         )
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return "and " + expr

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/converters/py_selectolax.py

@@ -211,7 +211,7 @@ def pre_is_css(node: ExprIsCss) -> str:
     msg = py_get_classvar_hook_or_value(node, "msg")
     invert = node.kwargs["invert"]
 
-    expr = {prv}.css_first({query})
+    expr = f"{prv}.css_first({query})"
     if invert:
         expr = f"not {expr}"
 

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/converters/templates/lua_re_compat.py

@@ -79,7 +79,7 @@ import logging
 __all__ = ["py_regex_to_lua_pattern"]
 
 
-LOGGER = logging.getLogger("ssc-gen")
+LOGGER = logging.getLogger("ssc_gen")
 
 
 @dataclass

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/logs.py

@@ -26,8 +26,8 @@ def setup_logger(
     name: str = "ssc_gen",
     level: int = logging.INFO,
     colored: bool = True,
-    fmt: str = "[%(levelname)-8s] %(name)s: %(asctime)s - %(message)s",
-    datefmt: str = "%Y-%m-%d %H:%M:%S",
+    fmt: str = "[%(levelname)-8s] %(name)s: - %(message)s",  # %(asctime)s
+    datefmt: str | None = None,  # "%Y-%m-%d %H:%M:%S",
 ) -> logging.Logger:
     logger = logging.getLogger(name)
     logger.setLevel(level)

{ssc_codegen-0.13.0 → ssc_codegen-0.13.2}/ssc_codegen/static_checker/base.py

@@ -58,7 +58,6 @@ FMT_MAPPING_METHODS = {
     TokenType.EXPR_LIST_JOIN: "join",
     TokenType.EXPR_LIST_LEN: "to_len",
     TokenType.IS_EQUAL: "is_equal",
-    TokenType.IS_NOT_EQUAL: "is_not_equal",
     TokenType.IS_CONTAINS: "is_contains",
     TokenType.IS_CSS: "is_css",
     TokenType.IS_XPATH: "is_xpath",