omlish 0.0.0.dev116__py3-none-any.whl → 0.0.0.dev118__py3-none-any.whl

omlish/specs/jmespath/lexer.py

@@ -249,14 +249,14 @@ class Lexer:
         }
 
     def _peek_may_be_valid_unquoted_identifier(self) -> bool:
-        if (self._position == self._length - 1):
+        if self._position == self._length - 1:
             return False
         else:
             nxt = self._chars[self._position + 1]
             return nxt in self.START_IDENTIFIER
 
     def _peek_is_next_digit(self) -> bool:
-        if (self._position == self._length - 1):
+        if self._position == self._length - 1:
             return False
         else:
             nxt = self._chars[self._position + 1]

omlish/specs/jmespath/parser.py

@@ -20,14 +20,48 @@ A few notes on the implementation.
   interestingly enough, creating a token list first is actually faster than consuming from the token iterator one token
   at a time.
 """
+import dataclasses as dc
 import random
 import typing as ta
 
 from ... import check
-from . import ast
-from . import exceptions
-from . import lexer
-from . import visitor
+from .ast import AndExpression
+from .ast import Arithmetic
+from .ast import ArithmeticUnary
+from .ast import Assign
+from .ast import Comparator
+from .ast import CurrentNode
+from .ast import Expref
+from .ast import Field
+from .ast import FilterProjection
+from .ast import Flatten
+from .ast import FunctionExpression
+from .ast import Identity
+from .ast import Index
+from .ast import IndexExpression
+from .ast import KeyValPair
+from .ast import LetExpression
+from .ast import Literal
+from .ast import MultiSelectDict
+from .ast import MultiSelectList
+from .ast import Node
+from .ast import NotExpression
+from .ast import OrExpression
+from .ast import Pipe
+from .ast import Projection
+from .ast import RootNode
+from .ast import Slice
+from .ast import Subexpression
+from .ast import ValueProjection
+from .ast import VariableRef
+from .exceptions import IncompleteExpressionError
+from .exceptions import LexerError
+from .exceptions import ParseError
+from .lexer import Lexer
+from .lexer import Token
+from .visitor import GraphvizVisitor
+from .visitor import Options
+from .visitor import TreeInterpreter
 
 
 class Parser:
@@ -83,12 +117,12 @@ class Parser:
     def __init__(self, lookahead: int = 2) -> None:
         super().__init__()
 
-        self._tokenizer: ta.Iterable[lexer.Token] | None = None
-        self._tokens: list[lexer.Token | None] = [None] * lookahead
+        self._tokenizer: ta.Iterable[Token] | None = None
+        self._tokens: list[Token | None] = [None] * lookahead
         self._buffer_size = lookahead
         self._index = 0
 
-    def parse(self, expression: str, options: visitor.Options | None = None) -> 'ParsedResult':
+    def parse(self, expression: str, options: Options | None = None) -> 'ParsedResult':
         cached = self._CACHE.get(expression)
         if cached is not None:
             return cached
@@ -101,24 +135,24 @@ class Parser:
 
         return parsed_result
 
-    def _do_parse(self, expression: str, options: visitor.Options | None = None) -> 'ParsedResult':
+    def _do_parse(self, expression: str, options: Options | None = None) -> 'ParsedResult':
         try:
             return self._parse(expression, options)
 
-        except exceptions.LexerError as e:
+        except LexerError as e:
             e.expression = expression
             raise
 
-        except exceptions.IncompleteExpressionError as e:
+        except IncompleteExpressionError as e:
             e.set_expression(expression)
             raise
 
-        except exceptions.ParseError as e:
+        except ParseError as e:
             e.expression = expression
             raise
 
-    def _parse(self, expression: str, options: visitor.Options | None = None) -> 'ParsedResult':
-        self._tokenizer = lexer.Lexer().tokenize(expression, options)
+    def _parse(self, expression: str, options: Options | None = None) -> 'ParsedResult':
+        self._tokenizer = Lexer().tokenize(expression, options)
         self._tokens = list(self._tokenizer)
         self._index = 0
 
@@ -126,7 +160,7 @@ class Parser:
 
         if self._current_token() != 'eof':
             t = check.not_none(self._lookahead_token(0))
-            raise exceptions.ParseError(
+            raise ParseError(
                 t['start'],
                 t['value'],
                 t['type'],
@@ -135,7 +169,7 @@ class Parser:
 
         return ParsedResult(expression, parsed)
 
-    def _expression(self, binding_power: int = 0) -> ast.Node:
+    def _expression(self, binding_power: int = 0) -> Node:
         left_token = check.not_none(self._lookahead_token(0))
 
         self._advance()
@@ -166,19 +200,19 @@ class Parser:
 
         return left
 
-    def _token_nud_literal(self, token: lexer.Token) -> ast.Node:
-        return ast.literal(token['value'])
+    def _token_nud_literal(self, token: Token) -> Node:
+        return Literal(token['value'])
 
-    def _token_nud_variable(self, token: lexer.Token) -> ast.Node:
-        return ast.variable_ref(token['value'][1:])
+    def _token_nud_variable(self, token: Token) -> Node:
+        return VariableRef(token['value'][1:])
 
-    def _token_nud_unquoted_identifier(self, token: lexer.Token) -> ast.Node:
+    def _token_nud_unquoted_identifier(self, token: Token) -> Node:
         if token['value'] == 'let' and self._current_token() == 'variable':
             return self._parse_let_expression()
         else:
-            return ast.field(token['value'])
+            return Field(token['value'])
 
-    def _parse_let_expression(self) -> ast.Node:
+    def _parse_let_expression(self) -> Node:
         bindings = []
         while True:
             var_token = check.not_none(self._lookahead_token(0))
@@ -187,28 +221,28 @@ class Parser:
             self._advance()
             self._match('assign')
             assign_expr = self._expression()
-            bindings.append(ast.assign(varname, assign_expr))
+            bindings.append(Assign(varname, assign_expr))
             if self._is_in_keyword(check.not_none(self._lookahead_token(0))):
                 self._advance()
                 break
             else:
                 self._match('comma')
         expr = self._expression()
-        return ast.let_expression(bindings, expr)
+        return LetExpression(bindings, expr)
 
-    def _is_in_keyword(self, token: lexer.Token) -> bool:
+    def _is_in_keyword(self, token: Token) -> bool:
         return (
             token['type'] == 'unquoted_identifier' and
             token['value'] == 'in'
         )
 
-    def _token_nud_quoted_identifier(self, token: lexer.Token) -> ast.Node:
-        field = ast.field(token['value'])
+    def _token_nud_quoted_identifier(self, token: Token) -> Node:
+        field = Field(token['value'])
 
         # You can't have a quoted identifier as a function name.
         if self._current_token() == 'lparen':
             t = check.not_none(self._lookahead_token(0))
-            raise exceptions.ParseError(
+            raise ParseError(
                 0,
                 t['value'],
                 t['type'],
@@ -217,73 +251,74 @@ class Parser:
 
         return field
 
-    def _token_nud_star(self, token: lexer.Token) -> ast.Node:
-        left = ast.identity()
+    def _token_nud_star(self, token: Token) -> Node:
+        left = Identity()
+        right: Node
         if self._current_token() == 'rbracket':
-            right = ast.identity()
+            right = Identity()
         else:
             right = self._parse_projection_rhs(self.BINDING_POWER['star'])
-        return ast.value_projection(left, right)
+        return ValueProjection(left, right)
 
-    def _token_nud_filter(self, token: lexer.Token) -> ast.Node:
-        return self._token_led_filter(ast.identity())
+    def _token_nud_filter(self, token: Token) -> Node:
+        return self._token_led_filter(Identity())
 
-    def _token_nud_lbrace(self, token: lexer.Token) -> ast.Node:
+    def _token_nud_lbrace(self, token: Token) -> Node:
         return self._parse_multi_select_hash()
 
-    def _token_nud_lparen(self, token: lexer.Token) -> ast.Node:
+    def _token_nud_lparen(self, token: Token) -> Node:
         expression = self._expression()
         self._match('rparen')
         return expression
 
-    def _token_nud_minus(self, token: lexer.Token) -> ast.Node:
+    def _token_nud_minus(self, token: Token) -> Node:
         return self._parse_arithmetic_unary(token)
 
-    def _token_nud_plus(self, token: lexer.Token) -> ast.Node:
+    def _token_nud_plus(self, token: Token) -> Node:
         return self._parse_arithmetic_unary(token)
 
-    def _token_nud_flatten(self, token: lexer.Token) -> ast.Node:
-        left = ast.flatten(ast.identity())
+    def _token_nud_flatten(self, token: Token) -> Node:
+        left = Flatten(Identity())
         right = self._parse_projection_rhs(
             self.BINDING_POWER['flatten'])
-        return ast.projection(left, right)
+        return Projection(left, right)
 
-    def _token_nud_not(self, token: lexer.Token) -> ast.Node:
+    def _token_nud_not(self, token: Token) -> Node:
         expr = self._expression(self.BINDING_POWER['not'])
-        return ast.not_expression(expr)
+        return NotExpression(expr)
 
-    def _token_nud_lbracket(self, token: lexer.Token) -> ast.Node:
+    def _token_nud_lbracket(self, token: Token) -> Node:
         if self._current_token() in ['number', 'colon']:
             right = self._parse_index_expression()
             # We could optimize this and remove the identity() node. We don't really need an index_expression node, we
             # can just use emit an index node here if we're not dealing with a slice.
-            return self._project_if_slice(ast.identity(), right)
+            return self._project_if_slice(Identity(), right)
 
         elif self._current_token() == 'star' and self._lookahead(1) == 'rbracket':
             self._advance()
             self._advance()
             right = self._parse_projection_rhs(self.BINDING_POWER['star'])
-            return ast.projection(ast.identity(), right)
+            return Projection(Identity(), right)
 
         else:
             return self._parse_multi_select_list()
 
-    def _parse_index_expression(self) -> ast.Node:
+    def _parse_index_expression(self) -> Node:
         # We're here:
         # [<current>
         #  ^
         #  | current token
-        if (self._lookahead(0) == 'colon' or self._lookahead(1) == 'colon'):
+        if self._lookahead(0) == 'colon' or self._lookahead(1) == 'colon':
             return self._parse_slice_expression()
 
         else:
             # Parse the syntax [number]
-            node = ast.index(check.not_none(self._lookahead_token(0))['value'])
+            node = Index(check.not_none(self._lookahead_token(0))['value'])
             self._advance()
             self._match('rbracket')
             return node
 
-    def _parse_slice_expression(self) -> ast.Node:
+    def _parse_slice_expression(self) -> Node:
         # [start:end:step]
         # Where start, end, and step are optional. The last colon is optional as well.
         parts = [None, None, None]
@@ -306,60 +341,59 @@ class Parser:
             current_token = self._current_token()
 
         self._match('rbracket')
-        return ast.slice(*parts)
+        return Slice(*parts)
 
-    def _token_nud_current(self, token: lexer.Token) -> ast.Node:
-        return ast.current_node()
+    def _token_nud_current(self, token: Token) -> Node:
+        return CurrentNode()
 
-    def _token_nud_root(self, token: lexer.Token) -> ast.Node:
-        return ast.root_node()
+    def _token_nud_root(self, token: Token) -> Node:
+        return RootNode()
 
-    def _token_nud_expref(self, token: lexer.Token) -> ast.Node:
+    def _token_nud_expref(self, token: Token) -> Node:
         expression = self._expression(self.BINDING_POWER['expref'])
-        return ast.expref(expression)
+        return Expref(expression)
 
-    def _token_led_dot(self, left: ast.Node) -> ast.Node:
+    def _token_led_dot(self, left: Node) -> Node:
         if self._current_token() != 'star':
             right = self._parse_dot_rhs(self.BINDING_POWER['dot'])
-            if left['type'] == 'subexpression':
-                left['children'].append(right)
-                return left
+            if isinstance(left, Subexpression):
+                return dc.replace(left, children_nodes=[*left.children_nodes, right])
 
             else:
-                return ast.subexpression([left, right])
+                return Subexpression([left, right])
 
         else:
             # We're creating a projection.
             self._advance()
             right = self._parse_projection_rhs(self.BINDING_POWER['dot'])
-            return ast.value_projection(left, right)
+            return ValueProjection(left, right)
 
-    def _token_led_pipe(self, left: ast.Node) -> ast.Node:
+    def _token_led_pipe(self, left: Node) -> Node:
         right = self._expression(self.BINDING_POWER['pipe'])
-        return ast.pipe(left, right)
+        return Pipe(left, right)
 
-    def _token_led_or(self, left: ast.Node) -> ast.Node:
+    def _token_led_or(self, left: Node) -> Node:
         right = self._expression(self.BINDING_POWER['or'])
-        return ast.or_expression(left, right)
+        return OrExpression(left, right)
 
-    def _token_led_and(self, left: ast.Node) -> ast.Node:
+    def _token_led_and(self, left: Node) -> Node:
         right = self._expression(self.BINDING_POWER['and'])
-        return ast.and_expression(left, right)
+        return AndExpression(left, right)
 
-    def _token_led_lparen(self, left: ast.Node) -> ast.Node:
-        if left['type'] != 'field':
+    def _token_led_lparen(self, left: Node) -> Node:
+        if not isinstance(left, Field):
             #  0 - first func arg or closing paren.
             # -1 - '(' token
             # -2 - invalid function "name".
             prev_t = check.not_none(self._lookahead_token(-2))
-            raise exceptions.ParseError(
+            raise ParseError(
                 prev_t['start'],
                 prev_t['value'],
                 prev_t['type'],
                 f"Invalid function name '{prev_t['value']}'",
             )
 
-        name = left['value']
+        name = left.name
         args = []
         while self._current_token() != 'rparen':
             expression = self._expression()
@@ -368,72 +402,72 @@ class Parser:
             args.append(expression)
         self._match('rparen')
 
-        function_node = ast.function_expression(name, args)
+        function_node = FunctionExpression(name, args)
         return function_node
 
-    def _token_led_filter(self, left: ast.Node) -> ast.Node:
+    def _token_led_filter(self, left: Node) -> Node:
         # Filters are projections.
         condition = self._expression(0)
         self._match('rbracket')
+        right: Node
         if self._current_token() == 'flatten':
-            right = ast.identity()
+            right = Identity()
         else:
             right = self._parse_projection_rhs(self.BINDING_POWER['filter'])
-        return ast.filter_projection(left, right, condition)
+        return FilterProjection(left, right, condition)
 
-    def _token_led_eq(self, left: ast.Node) -> ast.Node:
+    def _token_led_eq(self, left: Node) -> Node:
         return self._parse_comparator(left, 'eq')
 
-    def _token_led_ne(self, left: ast.Node) -> ast.Node:
+    def _token_led_ne(self, left: Node) -> Node:
         return self._parse_comparator(left, 'ne')
 
-    def _token_led_gt(self, left: ast.Node) -> ast.Node:
+    def _token_led_gt(self, left: Node) -> Node:
         return self._parse_comparator(left, 'gt')
 
-    def _token_led_gte(self, left: ast.Node) -> ast.Node:
+    def _token_led_gte(self, left: Node) -> Node:
         return self._parse_comparator(left, 'gte')
 
-    def _token_led_lt(self, left: ast.Node) -> ast.Node:
+    def _token_led_lt(self, left: Node) -> Node:
         return self._parse_comparator(left, 'lt')
 
-    def _token_led_lte(self, left: ast.Node) -> ast.Node:
+    def _token_led_lte(self, left: Node) -> Node:
         return self._parse_comparator(left, 'lte')
 
-    def _token_led_div(self, left: ast.Node) -> ast.Node:
+    def _token_led_div(self, left: Node) -> Node:
         return self._parse_arithmetic(left, 'div')
 
-    def _token_led_divide(self, left: ast.Node) -> ast.Node:
+    def _token_led_divide(self, left: Node) -> Node:
         return self._parse_arithmetic(left, 'divide')
 
-    def _token_led_minus(self, left: ast.Node) -> ast.Node:
+    def _token_led_minus(self, left: Node) -> Node:
         return self._parse_arithmetic(left, 'minus')
 
-    def _token_led_modulo(self, left: ast.Node) -> ast.Node:
+    def _token_led_modulo(self, left: Node) -> Node:
         return self._parse_arithmetic(left, 'modulo')
 
-    def _token_led_multiply(self, left: ast.Node) -> ast.Node:
+    def _token_led_multiply(self, left: Node) -> Node:
         return self._parse_arithmetic(left, 'multiply')
 
-    def _token_led_plus(self, left: ast.Node) -> ast.Node:
+    def _token_led_plus(self, left: Node) -> Node:
         return self._parse_arithmetic(left, 'plus')
 
-    def _token_led_star(self, left: ast.Node) -> ast.Node:
+    def _token_led_star(self, left: Node) -> Node:
         return self._parse_arithmetic(left, 'multiply')
 
-    def _token_led_flatten(self, left: ast.Node) -> ast.Node:
-        left = ast.flatten(left)
+    def _token_led_flatten(self, left: Node) -> Node:
+        left = Flatten(left)
         right = self._parse_projection_rhs(self.BINDING_POWER['flatten'])
-        return ast.projection(left, right)
+        return Projection(left, right)
 
-    def _token_led_lbracket(self, left: ast.Node) -> ast.Node:
+    def _token_led_lbracket(self, left: Node) -> Node:
         token = check.not_none(self._lookahead_token(0))
         if token['type'] in ['number', 'colon']:
             right = self._parse_index_expression()
-            if left['type'] == 'index_expression':
+            if isinstance(left, IndexExpression):
                 # Optimization: if the left node is an index expr, we can avoid creating another node and instead just
                 # add the right node as a child of the left.
-                left['children'].append(right)
-                return left
+                return dc.replace(left, nodes=[*left.nodes, right])
 
             else:
                 return self._project_if_slice(left, right)
@@ -443,32 +477,32 @@ class Parser:
             self._match('star')
             self._match('rbracket')
             right = self._parse_projection_rhs(self.BINDING_POWER['star'])
-            return ast.projection(left, right)
+            return Projection(left, right)
 
-    def _project_if_slice(self, left: ast.Node, right: ast.Node) -> ast.Node:
-        index_expr = ast.index_expression([left, right])
-        if right['type'] == 'slice':
-            return ast.projection(
+    def _project_if_slice(self, left: Node, right: Node) -> Node:
+        index_expr = IndexExpression([left, right])
+        if isinstance(right, Slice):
+            return Projection(
                 index_expr,
                 self._parse_projection_rhs(self.BINDING_POWER['star']),
             )
         else:
             return index_expr
 
-    def _parse_comparator(self, left: ast.Node, comparator: str) -> ast.Node:
+    def _parse_comparator(self, left: Node, comparator: str) -> Node:
         right = self._expression(self.BINDING_POWER[comparator])
-        return ast.comparator(comparator, left, right)
+        return Comparator(comparator, left, right)
 
-    def _parse_arithmetic_unary(self, token: lexer.Token) -> ast.Node:
+    def _parse_arithmetic_unary(self, token: Token) -> Node:
         expression = self._expression(self.BINDING_POWER[token['type']])
-        return ast.arithmetic_unary(token['type'], expression)
+        return ArithmeticUnary(token['type'], expression)
 
-    def _parse_arithmetic(self, left: ast.Node, operator: str) -> ast.Node:
+    def _parse_arithmetic(self, left: Node, operator: str) -> Node:
         right = self._expression(self.BINDING_POWER[operator])
-        return ast.arithmetic(operator, left, right)
+        return Arithmetic(operator, left, right)
 
-    def _parse_multi_select_list(self) -> ast.Node:
-        expressions: list[ast.Node] = []
+    def _parse_multi_select_list(self) -> Node:
+        expressions: list[Node] = []
         while True:
             expression = self._expression()
             expressions.append(expression)
@@ -477,10 +511,10 @@ class Parser:
             else:
                 self._match('comma')
         self._match('rbracket')
-        return ast.multi_select_list(expressions)
+        return MultiSelectList(expressions)
 
-    def _parse_multi_select_hash(self) -> ast.Node:
-        pairs = []
+    def _parse_multi_select_hash(self) -> Node:
+        pairs: list[KeyValPair] = []
         while True:
             key_token = check.not_none(self._lookahead_token(0))
 
@@ -491,7 +525,7 @@ class Parser:
             self._match('colon')
             value = self._expression(0)
 
-            node = ast.key_val_pair(key_name=key_name, node=value)
+            node = KeyValPair(key_name=key_name, node=value)
 
             pairs.append(node)
             if self._current_token() == 'comma':
@@ -501,13 +535,15 @@ class Parser:
                 self._match('rbrace')
                 break
 
-        return ast.multi_select_dict(nodes=pairs)
+        return MultiSelectDict(nodes=pairs)
+
+    def _parse_projection_rhs(self, binding_power: int) -> Node:
+        right: Node
 
-    def _parse_projection_rhs(self, binding_power: int) -> ast.Node:
         # Parse the right hand side of the projection.
         if self.BINDING_POWER[self._current_token()] < self._PROJECTION_STOP:
             # BP of 10 are all the tokens that stop a projection.
-            right = ast.identity()
+            right = Identity()
 
         elif self._current_token() == 'lbracket':
             right = self._expression(binding_power)
@@ -524,7 +560,7 @@ class Parser:
 
         return right
 
-    def _parse_dot_rhs(self, binding_power: int) -> ast.Node:
+    def _parse_dot_rhs(self, binding_power: int) -> Node:
         # From the grammar:
         # expression '.' ( identifier /
         #                  multi-select-list /
@@ -553,9 +589,9 @@ class Parser:
             self._raise_parse_error_for_token(t, msg)
             raise RuntimeError  # noqa
 
-    def _error_nud_token(self, token: lexer.Token) -> ta.NoReturn:
+    def _error_nud_token(self, token: Token) -> ta.NoReturn:
         if token['type'] == 'eof':
-            raise exceptions.IncompleteExpressionError(
+            raise IncompleteExpressionError(
                 token['start'],
                 token['value'],
                 token['type'],
@@ -563,7 +599,7 @@ class Parser:
 
         self._raise_parse_error_for_token(token, 'invalid token')
 
-    def _error_led_token(self, token: lexer.Token) -> ta.NoReturn:
+    def _error_led_token(self, token: Token) -> ta.NoReturn:
         self._raise_parse_error_for_token(token, 'invalid token')
 
     def _match(self, token_type: str | None = None) -> None:
@@ -588,14 +624,14 @@ class Parser:
     def _lookahead(self, number: int) -> str:
         return check.not_none(self._tokens[self._index + number])['type']
 
-    def _lookahead_token(self, number: int) -> lexer.Token | None:
+    def _lookahead_token(self, number: int) -> Token | None:
         return self._tokens[self._index + number]
 
-    def _raise_parse_error_for_token(self, token: lexer.Token, reason: str) -> ta.NoReturn:
+    def _raise_parse_error_for_token(self, token: Token, reason: str) -> ta.NoReturn:
         lex_position = token['start']
         actual_value = token['value']
         actual_type = token['type']
-        raise exceptions.ParseError(
+        raise ParseError(
             lex_position,
             actual_value,
             actual_type,
@@ -607,14 +643,14 @@ class Parser:
         actual_value = token['value']
         actual_type = token['type']
         if actual_type == 'eof':
-            raise exceptions.IncompleteExpressionError(
+            raise IncompleteExpressionError(
                 lex_position,
                 actual_value,
                 actual_type,
             )
 
         message = f'Expecting: {expected_type}, got: {actual_type}'
-        raise exceptions.ParseError(
+        raise ParseError(
             lex_position,
             actual_value,
             actual_type,
@@ -627,21 +663,21 @@ class Parser:
             self._CACHE.pop(key, None)
 
     @classmethod
-    def purge(cls):
+    def purge(cls) -> None:
         """Clear the expression compilation cache."""
 
         cls._CACHE.clear()
 
 
 class ParsedResult:
-    def __init__(self, expression: str, parsed: ast.Node) -> None:
+    def __init__(self, expression: str, parsed: Node) -> None:
         super().__init__()
 
         self.expression = expression
         self.parsed = parsed
 
-    def search(self, value: ta.Any, options: visitor.Options | None = None) -> ta.Any:
-        evaluator = visitor.TreeInterpreter(options)
+    def search(self, value: ta.Any, options: Options | None = None) -> ta.Any:
+        evaluator = TreeInterpreter(options)
         return evaluator.evaluate(self.parsed, value)
 
     def _render_dot_file(self) -> str:
@@ -653,7 +689,7 @@ class ParsedResult:
         the public supported API.  Use at your own risk.
         """
 
-        renderer = visitor.GraphvizVisitor()
+        renderer = GraphvizVisitor()
         contents = renderer.visit(self.parsed)
         return contents
 
@@ -661,9 +697,9 @@ class ParsedResult:
         return repr(self.parsed)
 
 
-def compile(expression: str, options: visitor.Options | None = None) -> ParsedResult:  # noqa
+def compile(expression: str, options: Options | None = None) -> ParsedResult:  # noqa
     return Parser().parse(expression, options=options)
 
 
-def search(expression: str, data: ta.Any, options: visitor.Options | None = None) -> ta.Any:
+def search(expression: str, data: ta.Any, options: Options | None = None) -> ta.Any:
     return compile(expression, options).search(data, options=options)