ssc_codegen 0.41.0__tar.gz → 0.42.0__tar.gz

{ssc_codegen-0.41.0 → ssc_codegen-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ssc_codegen
-Version: 0.41.0
+Version: 0.42.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.41.0 → ssc_codegen-0.42.0}/pyproject.toml

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

{ssc_codegen-0.41.0 → ssc_codegen-0.42.0}/ssc_codegen/naming.py

@@ -22,6 +22,23 @@ def to_snake_case(s: str) -> str:
     return s.lower()
 
 
+def json_descriptor_var_name(name: str) -> str:
+    """Format canonical module-level JSON descriptor constant identifier.
+
+    Args:
+        name: Struct, type, or response schema name to format.
+
+    Returns:
+        Canonical uppercase identifier prefixed with ``JSON_DESCRIPTOR_``.
+
+    Examples:
+        'Episode'                 -> 'JSON_DESCRIPTOR_EPISODE'
+        'CatalogReleasesResponse' -> 'JSON_DESCRIPTOR_CATALOG_RELEASES_RESPONSE'
+    """
+    clean_name = to_snake_case(name).lstrip("_").upper()
+    return f"JSON_DESCRIPTOR_{clean_name}"
+
+
 def to_pascal_case(s: str) -> str:
     """
     'my_field_name' -> 'MyFieldName'

{ssc_codegen-0.41.0 → ssc_codegen-0.42.0}/ssc_codegen/targets/javascript/rest.py

@@ -8,14 +8,12 @@ Called by JsVisitor via thin delegate methods.  The HTTP library strategy
 from __future__ import annotations
 
 import json
-from typing import Mapping
 
 from ssc_codegen.ast import (
     JsonDef,
     MatcherListDef,
     MethodFetch,
     MethodRest,
-    Module,
     PlaceholderSpec,
     PlaceholderTemplate,
     ResultAliasDef,
@@ -23,18 +21,21 @@ from ssc_codegen.ast import (
     StructBase,
 )
 from ssc_codegen.ast.struct import RequestHttp
-from ssc_codegen.naming import to_camel_case, to_pascal_case, to_snake_case
+from ssc_codegen.naming import (
+    json_descriptor_var_name,
+    to_camel_case,
+    to_pascal_case,
+    to_snake_case,
+)
 from ssc_codegen.request_spec import parse_json_template
 from ssc_codegen.targets.javascript.http_libs.base import JsHttpLibStrategy
 from ssc_codegen.traversal.context import WalkContext
 from ssc_codegen.traversal.utils import (
     dict_needs_builder,
     err_subclass_name,
-    json_def_descriptors,
-    json_def_mapping,
+    find_enclosing_module,
 )
 
-
 # ===========================================================================
 # REST shared runtime source (Ok/Err/sscDispatchErr/etc.)
 # ===========================================================================
@@ -287,8 +288,7 @@ def js_name(name: str) -> str:
 def ok_payload_type(node: MethodRest) -> str:
     if not node.response_schema:
         return "null"
-    struct = node.parent
-    module = struct.parent if struct is not None else None
+    module = find_enclosing_module(node)
     schema_type = f"{to_pascal_case(node.response_schema)}Json"
     if module is not None:
         for n in module.body:
@@ -376,21 +376,28 @@ def emit_method_rest(
     )
 
     fn_name = http.fn_name
-    response_desc = _response_descriptors(node)
+    module = find_enclosing_module(node)
+    has_response_schema = False
+    if node.response_schema and module is not None:
+        has_response_schema = any(
+            isinstance(n, JsonDef) and n.name == node.response_schema
+            for n in module.body
+        )
+
     if node.response_path:
         accessor = "".join(
             f"[{json.dumps(p)}]" for p in node.response_path.split(".")
         )
-        if response_desc is None:
-            value_fn = f"(_b) => _b{accessor}"
+        if has_response_schema:
+            desc_var = json_descriptor_var_name(node.response_schema)
+            value_fn = f"(_b) => sscJsonProject(_b{accessor}, {desc_var})"
         else:
-            value_fn = f"(_b) => sscJsonProject(_b{accessor}, {_render_descriptors(response_desc)})"
+            value_fn = f"(_b) => _b{accessor}"
     elif not node.response_schema:
         value_fn = "(_b) => null"
-    elif response_desc is not None:
-        value_fn = (
-            f"(_b) => sscJsonProject(_b, {_render_descriptors(response_desc)})"
-        )
+    elif has_response_schema:
+        desc_var = json_descriptor_var_name(node.response_schema)
+        value_fn = f"(_b) => sscJsonProject(_b, {desc_var})"
     else:
         value_fn = "null"
 
@@ -466,82 +473,6 @@ def emit_method_rest(
     return lines
 
 
-def _response_descriptors(
-    node: MethodRest,
-) -> dict[str, tuple[str, bool, bool, object]] | None:
-    if not node.response_schema:
-        return None
-    module = node.parent.parent if node.parent is not None else None
-    if not isinstance(module, Module):
-        return None
-    definitions = {n.name: n for n in module.body if isinstance(n, JsonDef)}
-    definition = definitions.get(node.response_schema)
-    if definition is None:
-        return None
-    return json_def_descriptors(definition, definitions)
-
-
-def _render_descriptors(descriptors: Mapping[str, object]) -> str:
-    def render(value: object) -> str:
-        if value is None:
-            return "null"
-        if isinstance(value, bool):
-            return "true" if value else "false"
-        if isinstance(value, str):
-            return json.dumps(value)
-        if isinstance(value, tuple):
-            return "[" + ", ".join(render(x) for x in value) + "]"
-        if isinstance(value, list):
-            return "[" + ", ".join(render(item) for item in value) + "]"
-        if isinstance(value, dict):
-            return (
-                "{"
-                + ", ".join(
-                    f"{json.dumps(key)}: {render(item)}"
-                    for key, item in value.items()
-                )
-                + "}"
-            )
-        raise TypeError(f"unsupported JSON descriptor value: {value!r}")
-
-    return render(descriptors)
-
-
-def _response_mapping(node: MethodRest) -> dict[str, object] | None:
-    if not node.response_schema:
-        return None
-    module = node.parent.parent if node.parent is not None else None
-    if not isinstance(module, Module):
-        return None
-    definitions = {n.name: n for n in module.body if isinstance(n, JsonDef)}
-    definition = definitions.get(node.response_schema)
-    if definition is None or not definition.has_alias_key:
-        return None
-    return json_def_mapping(definition, definitions)
-
-
-def _render_mapping(mapping: dict[str, object]) -> str:
-    def render(value: object) -> str:
-        if isinstance(value, str):
-            return json.dumps(value)
-        if isinstance(value, tuple):
-            return "[" + json.dumps(value[0]) + ", " + render(value[1]) + "]"
-        if isinstance(value, list):
-            return "[" + ", ".join(render(item) for item in value) + "]"
-        if isinstance(value, dict):
-            return (
-                "{"
-                + ", ".join(
-                    f"{json.dumps(key)}: {render(item)}"
-                    for key, item in value.items()
-                )
-                + "}"
-            )
-        raise TypeError(f"unsupported JSON mapping value: {value!r}")
-
-    return render(mapping)
-
-
 def emit_method_fetch(
     node: MethodFetch, ctx: WalkContext, http: JsHttpLibStrategy
 ) -> list[str]:
@@ -679,26 +610,21 @@ def emit_result_alias_def(node: ResultAliasDef) -> list[str]:
 def emit_matcher_list_def(node: MatcherListDef) -> list[str]:
     var = f"_{to_snake_case(node.struct_name)}Matchers"
     lines = [f"const {var} = ["]
-    module = (
-        node.parent
-        if isinstance(node.parent, Module)
-        else (node.parent.parent if node.parent is not None else None)
-    )
+    module = find_enclosing_module(node)
     definitions = (
         {n.name: n for n in module.body if isinstance(n, JsonDef)}
-        if isinstance(module, Module)
+        if module is not None
         else {}
     )
     for e in node.entries:
         check = render_js_condition_check(e.required_keys, e.conditions)
         check_arg = check if check else "null"
-        desc = None
-        definition = definitions.get(e.error_schema)
-        if definition is not None:
-            desc = _render_descriptors(
-                json_def_descriptors(definition, definitions)
-            )
-        value_expr = f"sscJsonProject(_b, {desc})" if desc is not None else "_b"
+        desc_var = None
+        if e.error_schema and e.error_schema in definitions:
+            desc_var = json_descriptor_var_name(e.error_schema)
+        value_expr = (
+            f"sscJsonProject(_b, {desc_var})" if desc_var is not None else "_b"
+        )
         lines.append(
             f"    {{ status: {e.status}, check: {check_arg}, "
             f"factory: (_s, _h, _b) => ({{ isOk: false, status: _s, "

{ssc_codegen-0.41.0 → ssc_codegen-0.42.0}/ssc_codegen/targets/javascript/visitor.py

@@ -18,8 +18,8 @@ import re as _re
 from typing import Any
 
 from ssc_codegen.ast import (
-    Attr,
     Assert,
+    Attr,
     CheckMethod,
     CodeEndHook,
     CodeStartHook,
@@ -33,14 +33,14 @@ from ssc_codegen.ast import (
     Filter,
     Fmt,
     FunctionDef,
+    Index,
     Init,
     InitField,
     InitFieldCall,
-    Index,
+    Join,
     JsonDef,
     JsonDefField,
     Jsonify,
-    Join,
     Key,
     Len,
     LogicAnd,
@@ -49,12 +49,12 @@ from ssc_codegen.ast import (
     Lower,
     Ltrim,
     Match,
+    MatcherListDef,
     MethodFetch,
     MethodRest,
     Module,
     Nested,
     NormalizeSpace,
-    PreValidate,
     PredAttrContains,
     PredAttrEnds,
     PredAttrEq,
@@ -83,15 +83,15 @@ from ssc_codegen.ast import (
     PredTextRe,
     PredTextStarts,
     PredXpath,
+    PreValidate,
     Raw,
     Re,
     ReAll,
-    ReSub,
     Repl,
     ReplMap,
+    ReSub,
     ResultAliasDef,
     ResultVariantDef,
-    MatcherListDef,
     Return,
     RmPrefix,
     RmPrefixSuffix,
@@ -105,7 +105,6 @@ from ssc_codegen.ast import (
     Struct,
     StructBase,
     StructRest,
-    StructType as ST,
     TableConfig,
     TableMatchKey,
     TableRows,
@@ -117,36 +116,44 @@ from ssc_codegen.ast import (
     TypeDef,
     TypeDefField,
     TypeInfo,
-    Unique,
     Unescape,
+    Unique,
     Upper,
     Utilities,
     Value,
-    VariableType as VT,
     XpathRemove,
     XpathSelect,
     XpathSelectAll,
 )
+from ssc_codegen.ast import (
+    StructType as ST,
+)
+from ssc_codegen.ast import (
+    VariableType as VT,
+)
 from ssc_codegen.exceptions import BuildTimeError
-from ssc_codegen.naming import to_camel_case, to_pascal_case, to_snake_case
+from ssc_codegen.generation.builder import ModuleBuilder
+from ssc_codegen.naming import (
+    json_descriptor_var_name,
+    to_camel_case,
+    to_pascal_case,
+)
+from ssc_codegen.targets.javascript import rest
+from ssc_codegen.targets.javascript.http_libs.axios import AxiosStrategy
+from ssc_codegen.targets.javascript.http_libs.base import JsHttpLibStrategy
+from ssc_codegen.targets.javascript.http_libs.fetch import FetchStrategy
+from ssc_codegen.traversal.context import WalkContext
 from ssc_codegen.traversal.utils import (
+    DescriptorRef,
+    find_enclosing_module,
     find_predicate_container,
     json_def_descriptors,
-    json_def_mapping,
     jsonify_path_to_segments,
     module_has_rest,
     resolve_json_def,
 )
-
-from ssc_codegen.generation.builder import ModuleBuilder
-from ssc_codegen.targets.javascript import rest
-from ssc_codegen.targets.javascript.http_libs.axios import AxiosStrategy
-from ssc_codegen.targets.javascript.http_libs.base import JsHttpLibStrategy
-from ssc_codegen.targets.javascript.http_libs.fetch import FetchStrategy
-from ssc_codegen.traversal.context import WalkContext
 from ssc_codegen.traversal.walker import BaseWalker
 
-
 _JS_JSON_PROJECT_HELPER = """class SscJsonError extends Error {
   constructor(message) {
     super(message);
@@ -286,8 +293,6 @@ function sscRemapJsonKeys(value, mapping) {
   return result;
 }"""
 
-_JS_JSON_REMAP_HELPER = _JS_JSON_PROJECT_HELPER
-
 
 def _js_json_descriptors(
     node: JsonDef, definitions: dict[str, JsonDef]
@@ -295,6 +300,8 @@ def _js_json_descriptors(
     descriptors = json_def_descriptors(node, definitions)
 
     def render(value: object) -> str:
+        if isinstance(value, DescriptorRef):
+            return json_descriptor_var_name(value.schema_name)
         if value is None:
             return "null"
         if isinstance(value, bool):
@@ -317,36 +324,7 @@ def _js_json_descriptors(
         raise TypeError(f"unsupported JSON descriptor value: {value!r}")
 
     return [
-        f"const _{to_snake_case(node.name)}JsonDescriptors = {render(descriptors)};",
-        "",
-    ]
-
-
-def _js_json_mapping(
-    node: JsonDef, definitions: dict[str, JsonDef]
-) -> list[str]:
-    mapping = json_def_mapping(node, definitions)
-
-    def render(value: object) -> str:
-        if isinstance(value, str):
-            return json.dumps(value)
-        if isinstance(value, tuple):
-            return "[" + json.dumps(value[0]) + ", " + render(value[1]) + "]"
-        if isinstance(value, list):
-            return "[" + ", ".join(render(item) for item in value) + "]"
-        if isinstance(value, dict):
-            return (
-                "{"
-                + ", ".join(
-                    f"{json.dumps(key)}: {render(item)}"
-                    for key, item in value.items()
-                )
-                + "}"
-            )
-        raise TypeError(f"unsupported JSON mapping value: {value!r}")
-
-    return [
-        f"const _{to_snake_case(node.name)}JsonMapping = {render(mapping)};",
+        f"const {json_descriptor_var_name(node.name)} = {render(descriptors)};",
         "",
     ]
 
@@ -728,9 +706,7 @@ class JsVisitor(BaseWalker):
                 f" * @typedef {{Record<{key_type}, {val_type}>}} {name}Json",
                 " */",
             ]
-            module = node.parent
-            while module is not None and not isinstance(module, Module):
-                module = module.parent
+            module = find_enclosing_module(node)
             if isinstance(module, Module):
                 definitions = {
                     n.name: n for n in module.body if isinstance(n, JsonDef)
@@ -744,9 +720,7 @@ class JsVisitor(BaseWalker):
         lines = ["/**", f" * @typedef {{Object}} {name}Json"]
         lines.extend(self.walk_children(node, ctx))
         lines.append(" */")
-        module = node.parent
-        while module is not None and not isinstance(module, Module):
-            module = module.parent
+        module = find_enclosing_module(node)
         if isinstance(module, Module):
             definitions = {
                 n.name: n for n in module.body if isinstance(n, JsonDef)
@@ -1530,7 +1504,7 @@ class JsVisitor(BaseWalker):
             self._builder.require_std(
                 "sscJsonProject", code=_JS_JSON_PROJECT_HELPER
             )
-            desc_name = f"_{to_snake_case(node.schema_name)}JsonDescriptors"
+            desc_name = json_descriptor_var_name(node.schema_name)
             return [
                 f"{ctx.indent}let {ctx.nxt} = sscJsonProject({raw_expr}, {desc_name});"
             ]

{ssc_codegen-0.41.0 → ssc_codegen-0.42.0}/ssc_codegen/targets/python/rest.py

@@ -7,7 +7,7 @@ Called by PythonVisitor via thin delegate methods.  The HTTP library strategy
 
 from __future__ import annotations
 
-from typing import Mapping, cast
+from typing import cast
 
 from ssc_codegen.ast import (
     JsonDef,
@@ -22,18 +22,21 @@ from ssc_codegen.ast import (
     StructBase,
 )
 from ssc_codegen.ast.struct import RequestHttp
-from ssc_codegen.naming import to_pascal_case, to_snake_case
+from ssc_codegen.naming import (
+    json_descriptor_var_name,
+    to_pascal_case,
+    to_snake_case,
+)
 from ssc_codegen.request_spec import parse_json_template
 from ssc_codegen.targets.python.http_libs.base import HttpLibStrategy
 from ssc_codegen.traversal.context import WalkContext
 from ssc_codegen.traversal.utils import (
     dict_needs_builder,
+    find_enclosing_module,
     module_has_html_struct,
     module_has_rest,
-    json_def_descriptors,
 )
 
-
 # ===========================================================================
 # Placeholder / Template rendering (pure functions)
 # ===========================================================================
@@ -464,21 +467,27 @@ def emit_method_rest(
     pre_lines, kw_lines = _build_kw_dict(spec, i2, i3)
 
     value_kwarg: list[str] = []
-    response_desc = _response_descriptors(node)
+    module = find_enclosing_module(node)
+    has_response_schema = False
+    if node.response_schema and isinstance(module, Module):
+        has_response_schema = any(
+            isinstance(n, JsonDef) and n.name == node.response_schema
+            for n in module.body
+        )
+
     if node.response_path:
         accessor = "".join(f"[{p!r}]" for p in node.response_path.split("."))
-        if response_desc is None:
-            value_kwarg = [f"{i3}value_fn=lambda _b: _b{accessor},"]
-        else:
+        if has_response_schema:
             value_kwarg = [
-                f"{i3}value_fn=lambda _b: ssc_json_project(_b{accessor}, {_render_descriptors(response_desc)}),"
+                f"{i3}value_fn=lambda _b: ssc_json_project(_b{accessor}, {json_descriptor_var_name(node.response_schema)}),"
             ]
+        else:
+            value_kwarg = [f"{i3}value_fn=lambda _b: _b{accessor},"]
     elif not node.response_schema:
         value_kwarg = [f"{i3}value_fn=lambda _: None,"]
-    elif response_desc is not None:
-        desc_str = _render_descriptors(response_desc)
+    elif has_response_schema:
         value_kwarg = [
-            f"{i3}value_fn=lambda _b: ssc_json_project(_b, {desc_str}),"
+            f"{i3}value_fn=lambda _b: ssc_json_project(_b, {json_descriptor_var_name(node.response_schema)}),"
         ]
 
     def _body(fn_name: str, await_kw: str) -> list[str]:
@@ -518,82 +527,6 @@ def emit_method_rest(
     return lines
 
 
-def _response_descriptors(
-    node: MethodRest,
-) -> dict[str, tuple[str, bool, bool, object]] | None:
-    if not node.response_schema:
-        return None
-    module = node.parent.parent if node.parent is not None else None
-    if not isinstance(module, Module):
-        return None
-    definitions = {n.name: n for n in module.body if isinstance(n, JsonDef)}
-    definition = definitions.get(node.response_schema)
-    if definition is None:
-        return None
-    return json_def_descriptors(definition, definitions)
-
-
-def _schema_descriptors_for_entry(
-    entry: object, module: Module | None
-) -> dict[str, tuple[str, bool, bool, object]] | None:
-    schema = getattr(entry, "error_schema", "")
-    if not schema or not isinstance(module, Module):
-        return None
-    definitions = {n.name: n for n in module.body if isinstance(n, JsonDef)}
-    definition = definitions.get(schema)
-    if definition is None:
-        return None
-    return json_def_descriptors(definition, definitions)
-
-
-def _render_descriptors(descriptors: Mapping[str, object]) -> str:
-    def render(value: object) -> str:
-        if value is None:
-            return "None"
-        if isinstance(value, bool):
-            return "True" if value else "False"
-        if isinstance(value, str):
-            return repr(value)
-        if isinstance(value, tuple):
-            return "(" + ", ".join(render(x) for x in value) + ")"
-        if isinstance(value, list):
-            return "[" + ", ".join(render(item) for item in value) + "]"
-        if isinstance(value, dict):
-            return (
-                "{"
-                + ", ".join(
-                    f"{key!r}: {render(item)}" for key, item in value.items()
-                )
-                + "}"
-            )
-        raise TypeError(f"unsupported JSON descriptor value: {value!r}")
-
-    return render(descriptors)
-
-
-def _render_mapping(mapping: dict[str, object]) -> str:
-    def render(value: object) -> str:
-        if isinstance(value, str):
-            return repr(value)
-        if isinstance(value, tuple):
-            return f"({value[0]!r}, {_render_mapping(value[1])})"
-        if isinstance(value, list):
-            return (
-                "[" + ", ".join(_render_mapping(item) for item in value) + "]"
-            )
-        if isinstance(value, dict):
-            return (
-                "{"
-                + ", ".join(
-                    f"{key!r}: {render(item)}" for key, item in value.items()
-                )
-                + "}"
-            )
-        raise TypeError(f"unsupported JSON mapping value: {value!r}")
-
-    return render(mapping)
-
-
 def emit_result_variant_def(node: ResultVariantDef) -> list[str]:
     if node.schema_name:
         base = f"{to_pascal_case(node.schema_name)}Json"
@@ -626,22 +559,20 @@ def emit_result_alias_def(node: ResultAliasDef) -> list[str]:
 def emit_matcher_list_def(node: MatcherListDef) -> list[str]:
     var = f"{to_snake_case(node.struct_name).upper()}_MATCHERS"
     lines = [f"{var}: List[ErrMatcher] = ["]
+    module = find_enclosing_module(node)
+    definitions = (
+        {n.name: n for n in module.body if isinstance(n, JsonDef)}
+        if isinstance(module, Module)
+        else {}
+    )
     for e in node.entries:
         check = render_py_condition_lambda(e.required_keys, e.conditions)
         check_arg = check if check else "None"
-        module = (
-            node.parent
-            if isinstance(node.parent, Module)
-            else (node.parent.parent if node.parent is not None else None)
-        )
-        desc = _schema_descriptors_for_entry(
-            e, module if isinstance(module, Module) else None
-        )
         factory = e.factory_name
-        if desc is not None:
+        if e.error_schema and e.error_schema in definitions:
             factory = (
                 f"lambda headers, value: {e.factory_name}(headers=headers, "
-                f"value=ssc_json_project(value, {_render_descriptors(desc)}))"
+                f"value=ssc_json_project(value, {json_descriptor_var_name(e.error_schema)}))"
             )
         lines.append(f"    ErrMatcher({e.status}, {check_arg}, {factory}),")
     lines.append("]")