ssc_codegen 0.8.20__tar.gz → 0.8.22__tar.gz

{ssc_codegen-0.8.20 → ssc_codegen-0.8.22}/PKG-INFO

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

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

{ssc_codegen-0.8.20 → ssc_codegen-0.8.22}/ssc_codegen/__init__.py

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

{ssc_codegen-0.8.20 → ssc_codegen-0.8.22}/ssc_codegen/ast_/__init__.py

@@ -1,5 +1,5 @@
 from .base import BaseAstNode
-from .nodes_array import ExprIndex, ExprToListLength, ExprListStringJoin
+from .nodes_array import ExprIndex, ExprToListLength, ExprListStringJoin, ExprListUnique
 from .nodes_cast import ExprNested, ExprJsonify, ExprToInt, ExprToFloat, ExprToListInt, ExprToListFloat, ExprToBool
 from .nodes_core import (ExprReturn,
                          ExprNoReturn,
@@ -31,6 +31,6 @@ from .nodes_string import ExprStringTrim, ExprStringRegex, ExprStringSplit, Expr
     ExprListStringFormat, ExprListStringReplace, ExprListStringRightTrim, ExprListStringLeftTrim, \
     ExprListStringRegexSub, \
     ExprStringRmPrefix, ExprStringRmSuffix, ExprStringRmPrefixAndSuffix, ExprListStringRmPrefixAndSuffix, \
-    ExprListStringRmPrefix, ExprListStringRmSuffix
+    ExprListStringRmPrefix, ExprListStringRmSuffix, ExprStringMapReplace, ExprListStringMapReplace
 from .nodes_validate import ExprIsCss, ExprIsEqual, ExprStringIsRegex, ExprIsXpath, ExprIsNotEqual, ExprIsContains, \
     ExprListStringAnyRegex, ExprListStringAllRegex, ExprHasAttr, ExprListHasAttr

{ssc_codegen-0.8.20 → ssc_codegen-0.8.22}/ssc_codegen/ast_/nodes_array.py

@@ -31,3 +31,11 @@ class ExprToListLength(BaseAstNode[T_EMPTY_KWARGS, tuple]):
     kind: ClassVar[TokenType] = TokenType.EXPR_LIST_LEN
     accept_type: VariableType = VariableType.LIST_ANY
     ret_type: VariableType = VariableType.INT
+
+
+@dataclass(kw_only=True)
+class ExprListUnique(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    # TODO: support LIST_INT, LIST_FLOAT
+    kind: ClassVar[TokenType] = TokenType.EXPR_LIST_UNIQUE
+    accept_type: VariableType = VariableType.LIST_STRING
+    ret_type: VariableType = VariableType.LIST_STRING

{ssc_codegen-0.8.20 → ssc_codegen-0.8.22}/ssc_codegen/ast_/nodes_string.py

@@ -93,6 +93,26 @@ class ExprListStringReplace(BaseAstNode[KW_STR_REPL, tuple[str, str]]):
     ret_type: VariableType = VariableType.LIST_STRING
 
 
+KW_STR_MAP_REPL = TypedDict(
+    "KW_STR_MAP_REPL", {"old": tuple[str, ...], "new": tuple[str, ...]}
+)
+ARGS_STR_MAP_REPL = tuple[tuple[str, ...], tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class ExprStringMapReplace(BaseAstNode[KW_STR_MAP_REPL, ARGS_STR_MAP_REPL]):
+    kind: ClassVar[TokenType] = TokenType.EXPR_STRING_MAP_REPLACE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class ExprListStringMapReplace(BaseAstNode[KW_STR_MAP_REPL, ARGS_STR_MAP_REPL]):
+    kind: ClassVar[TokenType] = TokenType.EXPR_LIST_STRING_MAP_REPLACE
+    accept_type: VariableType = VariableType.LIST_STRING
+    ret_type: VariableType = VariableType.LIST_STRING
+
+
 KW_STR_RE = TypedDict(
     "KW_STR_RE", {"pattern": str, "group": int, "ignore_case": bool}
 )

{ssc_codegen-0.8.20 → ssc_codegen-0.8.22}/ssc_codegen/converters/go_goquery.py

@@ -1263,3 +1263,5 @@ def pre_list_str_rm_prefix_and_suffix(
 
 # TODO impl ExprHasAttr, ExprListHasAttr
 # TODO: impl Filter Expr
+# TODO: impl ExprListUnique
+# TODO: inpt ExprStringMapReplace, ExprListStringMapReplace

{ssc_codegen-0.8.20 → ssc_codegen-0.8.22}/ssc_codegen/converters/js_pure.py

@@ -101,6 +101,9 @@ from ssc_codegen.ast_ import (
     FilterStrLenLe,
     FilterStrLenGt,
     FilterStrLenGe,
+    ExprListUnique,
+    ExprStringMapReplace,
+    ExprListStringMapReplace,
 )
 from ssc_codegen.converters.base import BaseCodeConverter
 from ssc_codegen.converters.helpers import (
@@ -376,14 +379,14 @@ def pre_str_split(node: ExprStringSplit) -> str:
 def pre_str_replace(node: ExprStringReplace) -> str:
     prv, nxt = prev_next_var(node)
     old, new = node.unpack_args()
-    return f"let {nxt} = {prv}.replace({old!r}, {new!r});"
+    return f"let {nxt} = {prv}.replaceAll({old!r}, {new!r});"
 
 
 @CONVERTER(ExprListStringReplace.kind)
 def pre_list_str_replace(node: ExprListStringReplace) -> str:
     prv, nxt = prev_next_var(node)
     old, new = node.unpack_args()
-    return f"let {nxt} = {prv}.map(e => e.replace({old!r}, {new!r}));"
+    return f"let {nxt} = {prv}.map(e => e.replaceAll({old!r}, {new!r}));"
 
 
 @CONVERTER(ExprStringRegex.kind)
@@ -914,3 +917,26 @@ def pre_filter_str_len_ge(node: FilterStrLenGe) -> str:
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" && {expr}"
     return expr
+
+
+@CONVERTER(ExprListUnique.kind)
+def pre_list_unique(node: ExprListUnique) -> str:
+    prv, nxt = prev_next_var(node)
+    # save order guaranteed
+    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#description
+    return f"let {nxt} = [...new Set({prv})]; "
+
+
+@CONVERTER(ExprStringMapReplace.kind)
+def pre_str_map_repl(node: ExprStringMapReplace) -> str:
+    old_arr, new_arr = node.unpack_args()
+    prv, nxt = prev_next_var(node)
+    # py list<str> literal syntax equal js Array<string> literak
+    return f"let {nxt} = {old_arr}.reduce((s, v, i) => s.replaceAll(v, {new_arr}[i] ?? ''), {prv});"
+
+
+@CONVERTER(ExprListStringMapReplace.kind)
+def pre_list_str_map_repl(node: ExprListStringMapReplace) -> str:
+    old_arr, new_arr = node.unpack_args()
+    prv, nxt = prev_next_var(node)
+    return f"let {nxt} = {prv}.map(s => {old_arr}.reduce((s, v, i) => s.replaceAll(v, {new_arr}[i] ?? ''), s));"

{ssc_codegen-0.8.20 → ssc_codegen-0.8.22}/ssc_codegen/converters/py_base.py

@@ -103,6 +103,9 @@ from ssc_codegen.ast_ import (
     FilterStrLenLe,
     FilterStrLenGt,
     FilterStrLenGe,
+    ExprListUnique,
+    ExprStringMapReplace,
+    ExprListStringMapReplace,
 )
 from ssc_codegen.converters.base import (
     BaseCodeConverter,
@@ -175,6 +178,7 @@ import sys
 import json
 from typing import List, Dict, TypedDict, Union, Optional
 from contextlib import suppress
+from functools import reduce
 
 if sys.version_info >= (3, 10):
     from types import NoneType
@@ -271,6 +275,9 @@ class BasePyCodeConverter(BaseCodeConverter):
             FilterStrLenLe.kind: pre_filter_str_len_le,
             FilterStrLenGe.kind: pre_filter_str_len_ge,
             FilterStrLenGt.kind: pre_filter_str_len_gt,
+            ExprListUnique.kind: pre_list_unique,
+            ExprStringMapReplace.kind: pre_str_map_replace,
+            ExprListStringMapReplace.kind: pre_list_str_map_replace,
         }
 
         self.post_definitions = {
@@ -1069,3 +1076,36 @@ def pre_filter_str_len_ge(node: FilterStrLenGe) -> str:
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" and {expr}"
     return expr
+
+
+def pre_list_unique(node: ExprListUnique) -> str:
+    indent = (
+        INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY
+    )
+    prv, nxt = prev_next_var(node)
+    # use `dict.fromkeys()` instead `set()` for guarantees insertion order (py 3.7+) reason
+    return f"{indent}{nxt} = list(dict.fromkeys({prv}))"
+
+
+def pre_str_map_replace(node: ExprStringMapReplace) -> str:
+    indent = (
+        INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY
+    )
+    old_arr, new_arr = node.unpack_args()
+    replacements = dict(zip(old_arr, new_arr))
+
+    prv, nxt = prev_next_var(node)
+    expr = f"reduce(lambda acc, kv: acc.replace(kv[0], kv[1]), {replacements}.items(), {prv})"
+    return f"{indent}{nxt} = {expr}"
+
+
+def pre_list_str_map_replace(node: ExprListStringMapReplace) -> str:
+    indent = (
+        INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY
+    )
+    old_arr, new_arr = node.unpack_args()
+    replacements = dict(zip(old_arr, new_arr))
+
+    prv, nxt = prev_next_var(node)
+    expr = f"[reduce(lambda acc, kv: acc.replace(kv[0], kv[1]), {replacements}.items(), i) for i in {prv}]"
+    return f"{indent}{nxt} = {expr}"

{ssc_codegen-0.8.20 → ssc_codegen-0.8.22}/ssc_codegen/document.py

@@ -75,6 +75,9 @@ from ssc_codegen.ast_ import (
     FilterStrLenLe,
     FilterStrLenGt,
     FilterStrLenGe,
+    ExprListUnique,
+    ExprListStringMapReplace,
+    ExprStringMapReplace,
 )
 from ssc_codegen.document_utlis import (
     analyze_re_expression,
@@ -487,8 +490,47 @@ class ArrayDocument(BaseDocument):
         self._add(ExprFilter(body=expr.stack))
         return self
 
+    def unique(self) -> Self:
+        """Remove duplicates from array-like object
+
+        - accept LIST_STRING, return LIST_STRING
+        """
+        self._add(ExprListUnique())
+        return self
+
 
 class StringDocument(BaseDocument):
+    def repl_map(self, replace_table: dict[str, str]) -> Self:
+        old_args = tuple(replace_table.keys())
+        new_args = tuple(replace_table.values())
+
+        match self.stack_last_ret:
+            case VariableType.LIST_STRING:
+                self._add(
+                    ExprListStringMapReplace(
+                        kwargs={"old": old_args, "new": new_args}
+                    )
+                )
+            case VariableType.STRING:
+                self._add(
+                    ExprStringMapReplace(
+                        kwargs={"old": old_args, "new": new_args}
+                    )
+                )
+            case _:
+                LOGGER.warning(
+                    "repl_map(%s): Expected type(s) %s got %s",
+                    replace_table,
+                    (VariableType.LIST_STRING.name, VariableType.STRING.name),
+                    self.stack_last_ret.name,
+                )
+                self._add(
+                    ExprStringMapReplace(
+                        kwargs={"old": old_args, "new": new_args}
+                    )
+                )
+        return self
+
     def rm_prefix(self, substr: str) -> Self:
         """remove prefix from string by substr
 

{ssc_codegen-0.8.20 → ssc_codegen-0.8.22}/ssc_codegen/tokens.py

@@ -131,6 +131,7 @@ class TokenType(IntEnum):
     EXPR_STRING_RM_PREFIX = auto()
     EXPR_STRING_RM_SUFFIX = auto()
     EXPR_STRING_RM_PREFIX_AND_SUFFIX = auto()
+    EXPR_STRING_MAP_REPLACE = auto()
 
     # LIST_STRING
     EXPR_LIST_REGEX_SUB = auto()
@@ -142,10 +143,13 @@ class TokenType(IntEnum):
     EXPR_LIST_STRING_RM_PREFIX = auto()
     EXPR_LIST_STRING_RM_SUFFIX = auto()
     EXPR_LIST_STRING_RM_PREFIX_AND_SUFFIX = auto()
+    EXPR_LIST_STRING_MAP_REPLACE = auto()
+
     # ARRAY
     EXPR_LIST_ANY_INDEX = auto()
     EXPR_LIST_JOIN = auto()
     EXPR_LIST_LEN = auto()
+    EXPR_LIST_UNIQUE = auto()
 
     # ASSERT
     IS_EQUAL = auto()