ssc_codegen 0.8.17__tar.gz → 0.8.18__tar.gz

{ssc_codegen-0.8.17 → ssc_codegen-0.8.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.8.17
+Version: 0.8.18
 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
@@ -19,6 +19,7 @@ Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Text Processing :: Markup :: HTML
 Classifier: Topic :: Utilities
 Requires-Python: >=3.10
+Requires-Dist: bs4>=0.0.2
 Requires-Dist: colorama>=0.4.6; sys_platform == 'win32'
 Requires-Dist: cssselect>=1.2.0
 Requires-Dist: httpx>=0.28.1

{ssc_codegen-0.8.17 → ssc_codegen-0.8.18}/pyproject.toml

@@ -1,10 +1,11 @@
 [project]
 name = "ssc_codegen"
-version = "0.8.17"
+version = "0.8.18"
 description = "Python-dsl code converter to html parser for web scraping "
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
+    "bs4>=0.0.2",
     "colorama>=0.4.6 ; sys_platform == 'win32'",
     "cssselect>=1.2.0",
     "httpx>=0.28.1",

{ssc_codegen-0.8.17 → ssc_codegen-0.8.18}/ssc_codegen/__init__.py

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

{ssc_codegen-0.8.17 → ssc_codegen-0.8.18}/ssc_codegen/ast_/__init__.py

@@ -20,8 +20,10 @@ from .nodes_core import (ExprReturn,
                          TypeDef,
                          TypeDefField,
                          ExprCallStructMethod)
-from .nodes_filter import Filter, FilterOr, FilterAnd, FilterNot, FilterNotEqual, FilterEqual, FilterStrIn, \
-    FilterStrStarts, FilterStrEnds, FilterStrRe, ExprFilter
+from .nodes_filter import FilterOr, FilterAnd, FilterNot, FilterNotEqual, FilterEqual, FilterStrIn, \
+    FilterStrStarts, FilterStrEnds, FilterStrRe, ExprFilter, FilterStrLenEq, FilterStrLenNe, FilterStrLenLt, \
+    FilterStrLenLe, FilterStrLenGt, FilterStrLenGe
+
 from .nodes_selectors import ExprCss, ExprCssAll, ExprXpathAll, ExprXpath, ExprGetHtmlText, ExprGetHtmlRaw, \
     ExprGetHtmlAttr, ExprGetHtmlAttrAll, ExprGetHtmlRawAll, ExprGetHtmlTextAll
 from .nodes_string import ExprStringTrim, ExprStringRegex, ExprStringSplit, ExprStringReplace, ExprStringLeftTrim, \

{ssc_codegen-0.8.17 → ssc_codegen-0.8.18}/ssc_codegen/ast_/nodes_filter.py

@@ -7,11 +7,6 @@ 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 Filter(BaseAstNode):
-    kind: ClassVar[TokenType] = TokenType.FILTER
-    accept_type: VariableType = VariableType.STRING
-    ret_type: VariableType = VariableType.STRING
 
 
 @dataclass(kw_only=True)
@@ -38,8 +33,8 @@ class FilterNot(BaseAstNode[T_EMPTY_KWARGS, tuple]):
     # TODO: typing body accept Filter-like nodes
 
 
-KW_STR_IN = TypedDict("KW_STR_IN", {"substr": str})
-ARGS_STR_IN = tuple[str]
+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, ...]}
@@ -83,9 +78,55 @@ class FilterStrRe(BaseAstNode[KW_STR_RE, ARGS_STR_RE]):
     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", {"value": str})
-ARGS_STR_EQ_OR_NE = tuple[str]
+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)
@@ -97,7 +138,7 @@ class FilterEqual(BaseAstNode[KW_STR_EQ_OR_NE, ARGS_STR_EQ_OR_NE]):
 
 @dataclass(kw_only=True)
 class FilterNotEqual(BaseAstNode[KW_STR_EQ_OR_NE, ARGS_STR_EQ_OR_NE]):
-    kind: ClassVar[TokenType] = TokenType.FILTER_EQ
+    kind: ClassVar[TokenType] = TokenType.FILTER_NE
     accept_type: VariableType = VariableType.STRING
     ret_type: VariableType = VariableType.STRING
 

{ssc_codegen-0.8.17 → ssc_codegen-0.8.18}/ssc_codegen/converters/js_pure.py

@@ -95,6 +95,12 @@ from ssc_codegen.ast_ import (
     FilterAnd,
     FilterOr,
     ExprFilter,
+    FilterStrLenEq,
+    FilterStrLenNe,
+    FilterStrLenLt,
+    FilterStrLenLe,
+    FilterStrLenGt,
+    FilterStrLenGe,
 )
 from ssc_codegen.converters.base import BaseCodeConverter
 from ssc_codegen.converters.helpers import (
@@ -774,8 +780,14 @@ def post_filter_not(_node: FilterNot) -> str:
 
 @CONVERTER(FilterStrIn.kind)
 def pre_filter_in(node: FilterStrIn) -> str:
-    substr, *_ = node.unpack_args()
-    expr = f"i.includes({substr!r})"
+    values, *_ = node.unpack_args()
+    if len(values) == 1:
+        expr = f"i.includes({values[0]!r})"
+    else:
+        # to js array
+        val_arr = str(values)
+        val_arr = "[" + val_arr[1:-1] + "]"
+        expr = f"{val_arr}.some(e => i.includes(e))"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" && {expr}"
     return expr
@@ -783,11 +795,14 @@ def pre_filter_in(node: FilterStrIn) -> str:
 
 @CONVERTER(FilterStrStarts.kind)
 def pre_filter_starts_with(node: FilterStrStarts) -> str:
-    start_, *_ = node.unpack_args()
-    if len(start_) == 1:
-        expr = f"i.startsWith({start_[0]!r})"
+    values, *_ = node.unpack_args()
+    if len(values) == 1:
+        expr = f"i.startsWith({values[0]!r})"
     else:
-        expr = "(" + " || ".join(f"i.startsWith({s!r})" for s in start_) + ")"
+        # to js array
+        val_arr = str(values)
+        val_arr = "[" + val_arr[1:-1] + "]"
+        expr = f"{val_arr}.some(e => i.startsWith(e))"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" && {expr}"
     return expr
@@ -795,11 +810,14 @@ def pre_filter_starts_with(node: FilterStrStarts) -> str:
 
 @CONVERTER(FilterStrEnds.kind)
 def pre_filter_ends_with(node: FilterStrEnds) -> str:
-    suffix_, *_ = node.unpack_args()
-    if len(suffix_) == 1:
-        expr = f"i.endsWith({suffix_[0]!r})"
+    values, *_ = node.unpack_args()
+    if len(values) == 1:
+        expr = f"i.endsWith({values[0]!r})"
     else:
-        expr = "(" + " || ".join(f"i.endsWith({s!r})" for s in suffix_) + ")"
+        # to js array
+        val_arr = str(values)
+        val_arr = "[" + val_arr[1:-1] + "]"
+        expr = f"{val_arr}.some(e => i.endsWith(e))"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" && {expr}"
     return expr
@@ -818,8 +836,13 @@ def pre_filter_re(node: FilterStrRe) -> str:
 
 @CONVERTER(FilterEqual.kind)
 def pre_filter_eq(node: FilterEqual) -> str:
-    value, *_ = node.unpack_args()
-    expr = f"i === {value!r}"
+    values, *_ = node.unpack_args()
+    if len(values) == 1:
+        expr = f"i === {values[0]!r}"
+    else:
+        val_arr = str(values)
+        val_arr = "[" + val_arr[1:-1] + "]"
+        expr = f"{val_arr}.every(e => i === e)"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" && {expr}"
     return expr
@@ -827,8 +850,67 @@ def pre_filter_eq(node: FilterEqual) -> str:
 
 @CONVERTER(FilterNotEqual.kind)
 def pre_filter_ne(node: FilterNotEqual) -> str:
-    value, *_ = node.unpack_args()
-    expr = f"i !== {value!r}"
+    values, *_ = node.unpack_args()
+    if len(values) == 1:
+        expr = f"i !== {values[0]!r}"
+    else:
+        val_arr = str(values)
+        val_arr = "[" + val_arr[1:-1] + "]"
+        expr = f"{val_arr}.every(e => i !== e)"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" && {expr}"
+    return expr
+
+
+@CONVERTER(FilterStrLenEq.kind)
+def pre_filter_str_len_eq(node: FilterStrLenEq) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"i.length == {length}"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" && {expr}"
+    return expr
+
+
+@CONVERTER(FilterStrLenNe.kind)
+def pre_filter_str_len_ne(node: FilterStrLenNe) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"i.length != {length}"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" && {expr}"
+    return expr
+
+
+@CONVERTER(FilterStrLenLt.kind)
+def pre_filter_str_len_lt(node: FilterStrLenLt) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"i.length < {length}"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" && {expr}"
+    return expr
+
+
+@CONVERTER(FilterStrLenLe.kind)
+def pre_filter_str_len_le(node: FilterStrLenLe) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"i.length <= {length}"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" && {expr}"
+    return expr
+
+
+@CONVERTER(FilterStrLenGt.kind)
+def pre_filter_str_len_gt(node: FilterStrLenGt) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"i.length > {length}"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" && {expr}"
+    return expr
+
+
+@CONVERTER(FilterStrLenGe.kind)
+def pre_filter_str_len_ge(node: FilterStrLenGe) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"i.length >= {length}"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" && {expr}"
     return expr

{ssc_codegen-0.8.17 → ssc_codegen-0.8.18}/ssc_codegen/converters/py_base.py

@@ -97,6 +97,12 @@ from ssc_codegen.ast_ import (
     FilterStrRe,
     FilterEqual,
     FilterNotEqual,
+    FilterStrLenEq,
+    FilterStrLenNe,
+    FilterStrLenLt,
+    FilterStrLenLe,
+    FilterStrLenGt,
+    FilterStrLenGe,
 )
 from ssc_codegen.converters.base import (
     BaseCodeConverter,
@@ -259,6 +265,12 @@ class BasePyCodeConverter(BaseCodeConverter):
             FilterStrRe.kind: pre_filter_re,
             FilterEqual.kind: pre_filter_eq,
             FilterNotEqual.kind: pre_filter_ne,
+            FilterStrLenEq.kind: pre_filter_str_len_eq,
+            FilterStrLenNe.kind: pre_filter_str_len_ne,
+            FilterStrLenLt.kind: pre_filter_str_len_lt,
+            FilterStrLenLe.kind: pre_filter_str_len_le,
+            FilterStrLenGe.kind: pre_filter_str_len_ge,
+            FilterStrLenGt.kind: pre_filter_str_len_gt,
         }
 
         self.post_definitions = {
@@ -947,8 +959,12 @@ def post_filter_not(_node: FilterNot) -> str:
 
 
 def pre_filter_in(node: FilterStrIn) -> str:
-    substr, *_ = node.unpack_args()
-    expr = f"{substr!r} in i"
+    values, *_ = node.unpack_args()
+
+    if len(values) == 1:
+        expr = f"{values[0]!r} in i"
+    else:
+        expr = f"any(s in i for s in {values})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" and {expr}"
     return expr
@@ -956,6 +972,7 @@ def pre_filter_in(node: FilterStrIn) -> str:
 
 def pre_filter_starts_with(node: FilterStrStarts) -> str:
     start_, *_ = node.unpack_args()
+    # build-in python startswith accept tuple[str, ...]
     expr = f"i.startswith({start_})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" and {expr}"
@@ -964,6 +981,7 @@ def pre_filter_starts_with(node: FilterStrStarts) -> str:
 
 def pre_filter_ends_with(node: FilterStrEnds) -> str:
     suffix_, *_ = node.unpack_args()
+    # build-in python endswith accept tuple[str, ...]
     expr = f"i.endswith({suffix_})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" and {expr}"
@@ -982,18 +1000,72 @@ def pre_filter_re(node: FilterStrRe) -> str:
 
 
 def pre_filter_eq(node: FilterEqual) -> str:
-    value, *_ = node.unpack_args()
+    values, *_ = node.unpack_args()
     # currently support only str
-    expr = f"i == {value!r}"
+    if len(values) == 1:
+        expr = f"i == {values[0]!r}"
+    else:
+        expr = f"all(s == i for s in {values})"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" and {expr}"
     return expr
 
 
 def pre_filter_ne(node: FilterNotEqual) -> str:
-    value, *_ = node.unpack_args()
+    values, *_ = node.unpack_args()
     # currently support only str
-    expr = f"i != {value!r}"
+    if len(values) == 1:
+        expr = f"i != {values[0]!r}"
+    else:
+        expr = f"all(s != i for s in {values})"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" and {expr}"
+    return expr
+
+
+def pre_filter_str_len_eq(node: FilterStrLenEq) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"len(i) == {length}"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" and {expr}"
+    return expr
+
+
+def pre_filter_str_len_ne(node: FilterStrLenNe) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"len(i) != {length}"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" and {expr}"
+    return expr
+
+
+def pre_filter_str_len_lt(node: FilterStrLenLt) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"len(i) < {length}"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" and {expr}"
+    return expr
+
+
+def pre_filter_str_len_le(node: FilterStrLenLe) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"len(i) <= {length}"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" and {expr}"
+    return expr
+
+
+def pre_filter_str_len_gt(node: FilterStrLenGt) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"len(i) > {length}"
+    if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
+        return f" and {expr}"
+    return expr
+
+
+def pre_filter_str_len_ge(node: FilterStrLenGe) -> str:
+    length, *_ = node.unpack_args()
+    expr = f"len(i) >= {length}"
     if not is_first_node_cond(node) and is_prev_node_atomic_cond(node):
         return f" and {expr}"
     return expr

{ssc_codegen-0.8.17 → ssc_codegen-0.8.18}/ssc_codegen/document.py

@@ -1,7 +1,7 @@
 """high-level AST builder interface"""
 
 import logging
-from typing import Type, Pattern
+from typing import Type, Pattern, Sequence
 
 from cssselect import SelectorSyntaxError
 from typing_extensions import Self, assert_never
@@ -69,18 +69,24 @@ from ssc_codegen.ast_ import (
     FilterAnd,
     FilterOr,
     FilterNot,
+    FilterStrLenEq,
+    FilterStrLenNe,
+    FilterStrLenLt,
+    FilterStrLenLe,
+    FilterStrLenGt,
+    FilterStrLenGe,
 )
 from ssc_codegen.document_utlis import (
     analyze_re_expression,
     unverbosify_regex,
     is_ignore_case_regex,
 )
+from ssc_codegen.json_struct import Json
 from ssc_codegen.pseudo_selectors import (
     parse_pseudo_xpath_query,
     parse_pseudo_css_query,
     PseudoAction,
 )
-from ssc_codegen.json_struct import Json
 from ssc_codegen.schema import BaseSchema
 from ssc_codegen.selector_utils import validate_css_query, validate_xpath_query
 from ssc_codegen.tokens import VariableType
@@ -1263,29 +1269,80 @@ class JsonDocument(BaseDocument):
 
 
 class DocumentFilter(BaseDocument):
-    def eq(self, value: str) -> Self:
-        self._add(FilterEqual(kwargs={"value": value}))
+    def eq(self, *values: str) -> Self:
+        """check if value equal
+
+        multiple values converts to logical AND
+
+        pseudocode example:
+
+            F().eq("foo") -> value == "foo"
+
+            F().eq("bar", "foo") -> (value == "bar" && value == "foo")
+        """
+        self._add(FilterEqual(kwargs={"values": values}))
         return self
 
-    def ne(self, value: str) -> Self:
-        self._add(FilterNotEqual(kwargs={"value": value}))
+    def ne(self, *values: str) -> Self:
+        """check if value not equal
+
+        multiple values converts to logical AND
+
+        pseudocode example:
+
+            F().eq("foo") -> value == "foo"
+
+            F().eq("bar", "foo") -> (value != "bar" && value != "foo")
+        """
+        self._add(FilterNotEqual(kwargs={"values": values}))
         return self
 
     def starts(self, *values: str) -> Self:
+        """check if value starts by substring
+
+        multiple values converts to logical OR
+
+        pseudocode example:
+
+            F().eq("foo") -> value == "foo"
+
+            F().eq("foo", "bar") -> (value.starts_with("bar") || value.starts_with("foo"))
+        """
         self._add(FilterStrStarts(kwargs={"substr": values}))
         return self
 
     def ends(self, *values: str) -> Self:
+        """check if value starts by substring
+
+        multiple values converts to logical OR
+
+        pseudocode example:
+
+            F().eq("foo") -> value == "foo"
+
+            F().eq("foo", "bar") -> (value.ends_with("bar") || value.ends_with("foo"))
+        """
         self._add(FilterStrEnds(kwargs={"substr": values}))
         return self
 
-    def contains(self, value: str) -> Self:
-        self._add(FilterStrIn(kwargs={"substr": value}))
+    def contains(self, *values: str) -> Self:
+        """check if value contains by substring
+
+        multiple values converts to logical OR
+
+        pseudocode example:
+
+            F().eq("foo") -> value == "foo"
+
+            F().eq("foo", "bar") -> (value.include("bar") || value.include("foo"))
+        """
+        self._add(FilterStrIn(kwargs={"substr": values}))
         return self
 
     def re(
         self, pattern: str | Pattern[str], ignore_case: bool = False
     ) -> Self:
+        """check if pattern matched result in value"""
         if not isinstance(pattern, str):
             ignore_case = is_ignore_case_regex(pattern)
 
@@ -1316,22 +1373,74 @@ class DocumentFilter(BaseDocument):
         self._add(FilterOr(body=tmp_stack))
         return self
 
+    def len_eq(self, value: int) -> Self:
+        self._add(FilterStrLenEq(kwargs={"length": value}))
+        return self
+
+    def len_ne(self, value: int) -> Self:
+        self._add(FilterStrLenNe(kwargs={"length": value}))
+        return self
+
+    def len_lt(self, value: int) -> Self:
+        self._add(FilterStrLenLt(kwargs={"length": value}))
+        return self
+
+    def len_le(self, value: int) -> Self:
+        self._add(FilterStrLenLe(kwargs={"length": value}))
+        return self
+
+    def len_gt(self, value: int) -> Self:
+        self._add(FilterStrLenGt(kwargs={"length": value}))
+        return self
+
+    def len_ge(self, value: int) -> Self:
+        self._add(FilterStrLenGe(kwargs={"length": value}))
+        return self
+
     def not_(self, filter_expr: "DocumentFilter") -> Self:
         tmp_stack = filter_expr.stack.copy()
         self._add(FilterNot(body=tmp_stack))
         return self
 
     def __or__(self, other: "DocumentFilter") -> "DocumentFilter":
+        """syntax suger F().or_(...)"""
+
         return self.or_(other)
 
     def __and__(self, other: "DocumentFilter") -> "DocumentFilter":
+        """syntax sugar F().and_(...)"""
         return self.and_(other)
 
     def __invert__(self) -> "DocumentFilter":
+        """syntax sugar F().not_(...)"""
         return DocumentFilter().not_(self)
 
-    def __eq__(self, other: str) -> Self:
-        return self.eq(other)
+    def __eq__(self, other: int | str | Sequence[str]) -> Self:
+        """syntax sugar F().eq(...)"""
+        if isinstance(other, int):
+            return self.len_eq(other)
+
+        if isinstance(other, str):
+            other = (other,)
+        return self.eq(*other)
+
+    def __ne__(self, other: int | str | Sequence[str]) -> Self:
+        """syntax sugar F().ne(...)"""
+        if isinstance(other, int):
+            return self.len_ne(other)
+
+        if isinstance(other, str):
+            other = (other,)
+        return self.eq(*other)
+
+    def __lt__(self, other: int) -> Self:
+        return self.len_lt(other)
+
+    def __le__(self, other: int) -> Self:
+        return self.len_le(other)
+
+    def __gt__(self, other: int) -> Self:
+        return self.len_gt(other)
 
-    def __ne__(self, other: str) -> Self:
-        return self.ne(other)
+    def __ge__(self, other: int) -> Self:
+        return self.len_ge(other)

{ssc_codegen-0.8.17 → ssc_codegen-0.8.18}/ssc_codegen/tokens.py

@@ -177,15 +177,22 @@ class TokenType(IntEnum):
     # FILTER
     EXPR_FILTER = auto()
 
-    FILTER = auto()  # TODO: REMOVE?
     FILTER_OR = auto()
     FILTER_AND = auto()
     FILTER_NOT = auto()
-    # FILTER EXPR
+    # FILTER EXPR (STR)
     FILTER_STR_IN = auto()
     FILTER_STR_STARTS = auto()
     FILTER_STR_ENDS = auto()
     FILTER_STR_RE = auto()
+
+    FILTER_STR_LEN_EQ = auto()
+    FILTER_STR_LEN_NE = auto()
+    FILTER_STR_LEN_LT = auto()
+    FILTER_STR_LEN_LE = auto()
+    FILTER_STR_LEN_GT = auto()
+    FILTER_STR_LEN_GE = auto()
+
     FILTER_EQ = auto()
     FILTER_NE = auto()