ssc_codegen 0.19.0__tar.gz → 0.19.2__tar.gz

{ssc_codegen-0.19.0 → ssc_codegen-0.19.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.19.0
+Version: 0.19.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.19.0 → ssc_codegen-0.19.2}/pyproject.toml

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

{ssc_codegen-0.19.0 → ssc_codegen-0.19.2}/ssc_codegen/converters/py_bs4.py

@@ -189,6 +189,16 @@ def _module_has_rest(node) -> bool:
     )
 
 
+def rest_imports(node) -> list[str]:
+    """Extra imports required when the module has any `struct type=rest`."""
+    if not _module_has_rest(node):
+        return []
+    return [
+        "from dataclasses import dataclass, field",
+        "from typing import Generic, Literal, Mapping, TypeVar",
+    ]
+
+
 @PY_BASE_CONVERTER(Imports)
 def pre_imports(node: Imports, _: ConverterContext):
     base_imports = [
@@ -198,11 +208,7 @@ def pre_imports(node: Imports, _: ConverterContext):
         "from typing import TypedDict, Optional, Any, List, Dict, Union",
         "from html import unescape as _html_unescape",
     ]
-    if _module_has_rest(node):
-        base_imports.append("from dataclasses import dataclass, field")
-        base_imports.append(
-            "from typing import Generic, Literal, Mapping, TypeVar"
-        )
+    base_imports.extend(rest_imports(node))
 
     # Get transform imports for Python (already collected during parsing)
     transform_imports = sorted(node.transform_imports.get("py", set()))
@@ -279,51 +285,55 @@ def pre_utilities(node: Utilities, _: ConverterContext):
         "UNMATCHED_TABLE_ROW = _UnmatchedTableRow()",
         "\n\n",
     ]
-    if _module_has_rest(node):
-        lines.extend(
-            [
-                "_T = TypeVar('_T')",
-                "_E = TypeVar('_E')",
-                "\n",
-                "@dataclass(frozen=True, kw_only=True)",
-                "class Ok(Generic[_T]):",
-                "    status: int",
-                "    headers: Mapping[str, str]",
-                "    value: _T",
-                "    is_ok: Literal[True] = True",
-                "\n",
-                "@dataclass(frozen=True, kw_only=True)",
-                "class Err(Generic[_E]):",
-                "    status: int",
-                "    headers: Mapping[str, str]",
-                "    value: _E",
-                "    is_ok: Literal[False] = False",
-                "\n",
-                "@dataclass(frozen=True, kw_only=True)",
-                "class UnknownErr(Err[Any]):",
-                "    pass",
-                "\n",
-                "@dataclass(frozen=True, kw_only=True)",
-                "class TransportErr(Err[None]):",
-                "    status: Literal[0] = 0",
-                "    cause: str = ''",
-                "    value: None = None",
-                "    headers: Mapping[str, str] = field(default_factory=dict)",
-                "\n\n",
-                "def _parse_response(_resp):",
-                "    _status = _resp.status_code",
-                "    _headers = {k.lower(): v for k, v in _resp.headers.items()}",
-                "    try:",
-                "        _body = _resp.json()",
-                "    except Exception:",
-                "        _body = None",
-                "    return _status, _headers, _body",
-                "\n\n",
-            ]
-        )
+    lines.extend(rest_utilities(node))
     return lines
 
 
+def rest_utilities(node) -> list[str]:
+    """Ok/Err/UnknownErr/TransportErr + _parse_response block; empty if no REST."""
+    if not _module_has_rest(node):
+        return []
+    return [
+        "_T = TypeVar('_T')",
+        "_E = TypeVar('_E')",
+        "\n",
+        "@dataclass(frozen=True)",
+        "class Ok(Generic[_T]):",
+        "    status: int = 0",
+        "    headers: Mapping[str, str] = field(default_factory=dict)",
+        "    value: _T = None  # type: ignore[assignment]",
+        "    is_ok: Literal[True] = True",
+        "\n",
+        "@dataclass(frozen=True)",
+        "class Err(Generic[_E]):",
+        "    status: int = 0",
+        "    headers: Mapping[str, str] = field(default_factory=dict)",
+        "    value: _E = None  # type: ignore[assignment]",
+        "    is_ok: Literal[False] = False",
+        "\n",
+        "@dataclass(frozen=True)",
+        "class UnknownErr(Err[Any]):",
+        "    pass",
+        "\n",
+        "@dataclass(frozen=True)",
+        "class TransportErr(Err[None]):",
+        "    status: Literal[0] = 0",
+        "    cause: str = ''",
+        "    value: None = None",
+        "    headers: Mapping[str, str] = field(default_factory=dict)",
+        "\n\n",
+        "def _parse_response(_resp):",
+        "    _status = _resp.status_code",
+        "    _headers = {k.lower(): v for k, v in _resp.headers.items()}",
+        "    try:",
+        "        _body = _resp.json()",
+        "    except Exception:",
+        "        _body = None",
+        "    return _status, _headers, _body",
+        "\n\n",
+    ]
+
+
 @PY_BASE_CONVERTER(JsonDef, post_callback="})")
 def pre_json_struct(node: JsonDef, _: ConverterContext):
     name = to_pascal_case(node.name)
@@ -415,7 +425,7 @@ def _rest_err_union_type(struct: Struct) -> str:
         if cls_name not in seen:
             seen.add(cls_name)
             variants.append(cls_name)
-    return " | ".join([*variants, "UnknownErr", "None"])
+    return "Union[" + ", ".join([*variants, "UnknownErr", "None"]) + "]"
 
 
 def _emit_dispatch_err_py(node: Struct, ctx: ConverterContext) -> list[str]:
@@ -498,7 +508,7 @@ def pre_struct(node: Struct, ctx: ConverterContext):
                 continue
             seen.add(cls_name)
             value_type = _err_value_type(err, node)
-            lines.append("@dataclass(frozen=True, kw_only=True)")
+            lines.append("@dataclass(frozen=True)")
             lines.append(f"class {cls_name}(Err[{value_type}]):")
             lines.append(f"    status: Literal[{err.status}] = {err.status}")
             lines.append("")
@@ -1650,14 +1660,14 @@ def _ph_to_py_annotation(ph: PlaceholderSpec) -> tuple[str, str]:
     """Return (annotation, default_suffix). Suffix is '' or ' = None'."""
     anno = _PY_PRIM_ANNO[ph.type_name]
     if ph.is_array:
-        anno = f"list[{anno}]"
+        anno = f"List[{anno}]"
     if ph.is_optional:
-        return f"{anno} | None", " = None"
+        return f"Optional[{anno}]", " = None"
     return anno, ""
 
 
 def _render_signature_params(placeholders: list[PlaceholderSpec]) -> str:
-    """Build keyword-only parameters clause: ', *, a: int, b: str | None = None'."""
+    """Build keyword-only parameters clause: ', *, a: int, b: Optional[str] = None'."""
     if not placeholders:
         return ""
     required = [p for p in placeholders if not p.is_optional]
@@ -1698,7 +1708,7 @@ def _resolve_response_type(node: RequestConfig) -> str:
                 seen.add(cls_name)
                 err_variants.append(cls_name)
     parts = [f"Ok[{payload}]", *err_variants, "UnknownErr", "TransportErr"]
-    return " | ".join(parts)
+    return "Union[" + ", ".join(parts) + "]"
 
 
 def _build_rest_method(

{ssc_codegen-0.19.0 → ssc_codegen-0.19.2}/ssc_codegen/converters/py_lxml.py

@@ -81,6 +81,7 @@ def pre_imports(node: Imports, _: ConverterContext):
         "from typing import TypedDict, Optional, Any, List, Dict, Union",
         "from html import unescape as _html_unescape",
     ]
+    base_imports.extend(py_bs4.rest_imports(node))
 
     # Get transform imports for Python (already collected during parsing)
     transform_imports = sorted(node.transform_imports.get("py", set()))
@@ -100,7 +101,7 @@ def post_imports(node: Imports, ctx: ConverterContext):
 
 @PY_LXML_CONVERTER(Utilities)
 def pre_utilities(node: Utilities, _: ConverterContext):
-    return [
+    lines = [
         'FALLBACK_HTML_STR = "<html><body></body></html>"',
         "_RE_HEX_ENTITY = re.compile(r'&#x([0-9a-fA-F]+);')",
         "_RE_UNICODE_ENTITY = re.compile(r'\\\\u([0-9a-fA-F]{4})')",
@@ -144,6 +145,8 @@ def pre_utilities(node: Utilities, _: ConverterContext):
         "UNMATCHED_TABLE_ROW = _UnmatchedTableRow()",
         "\n\n",
     ]
+    lines.extend(py_bs4.rest_utilities(node))
+    return lines
 
 
 # Override struct __init__ to use lxml instead of BeautifulSoup

{ssc_codegen-0.19.0 → ssc_codegen-0.19.2}/ssc_codegen/converters/py_parsel.py

@@ -67,6 +67,7 @@ def pre_imports(node: Imports, _: ConverterContext):
         "from typing import TypedDict, Optional, Any, List, Dict, Union",
         "from html import unescape as _html_unescape",
     ]
+    base_imports.extend(py_bs4.rest_imports(node))
 
     transform_imports = sorted(node.transform_imports.get("py", set()))
 

{ssc_codegen-0.19.0 → ssc_codegen-0.19.2}/ssc_codegen/converters/py_slax.py

@@ -66,6 +66,7 @@ def pre_imports(node: Imports, _: ConverterContext):
         "from typing import TypedDict, Optional, Any, List, Dict, Union",
         "from html import unescape as _html_unescape",
     ]
+    base_imports.extend(py_bs4.rest_imports(node))
 
     transform_imports = sorted(node.transform_imports.get("py", set()))