stark-engine 4.3.0__tar.gz → 4.4.0__tar.gz

{stark_engine-4.3.0 → stark_engine-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stark-engine
-Version: 4.3.0
+Version: 4.4.0
 Summary: S.T.A.R.K - Speech and Text Algorithmic Recognition Kit. Modern framework for creating powerfull voice assistants.
 License: CC BY-NC-SA 4.0
 License-File: LICENSE.md
@@ -19,7 +19,8 @@ Provides-Extra: silero
 Provides-Extra: sound
 Provides-Extra: spacy
 Provides-Extra: vosk
-Requires-Dist: asyncer (>=0.0.2,<0.0.3)
+Requires-Dist: anyio (>=4.0.0,<5.0.0)
+Requires-Dist: asyncer (>=0.0.8,<1.0.0)
 Requires-Dist: google-cloud-texttospeech (>=2.14.1,<3.0.0) ; extra == "gcloud" or extra == "all"
 Requires-Dist: numpy (>=2.3.3,<3.0.0) ; extra == "silero" or extra == "all"
 Requires-Dist: pydantic (>=2.0.0,<3.0.0)

{stark_engine-4.3.0 → stark_engine-4.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "stark-engine"
-version = "4.3.0"
+version = "4.4.0"
 description = "S.T.A.R.K - Speech and Text Algorithmic Recognition Kit. Modern framework for creating powerfull voice assistants."
 authors = ["MarkParker5 <mark@parker-programs.com>"]
 license = "CC BY-NC-SA 4.0"
@@ -39,7 +39,8 @@ keywords = [
 [tool.poetry.dependencies]
 python = ">=3.12,<3.15"
 pydantic = "^2.0.0"
-asyncer = "^0.0.2"
+asyncer = ">=0.0.8,<1.0.0"
+anyio = ">=4.0.0,<5.0.0"
 numpy = "^2.3.3"
 
 # Optional dependencies
@@ -85,6 +86,7 @@ coverage = "^7.11.0"
 faker = "^37.11.0"
 pympler = "^1.1"
 psutil = "^7.1.1"
+trio = "^0.33.0"
 
 [build-system]
 requires = ["poetry-core"]

{stark_engine-4.3.0 → stark_engine-4.4.0}/stark/core/command.py

@@ -29,12 +29,11 @@ import asyncer
 from pydantic import BaseModel, Field
 
 from ..general.classproperty import classproperty
+from ..general.localisation import LanguageCode, LocalizableString
 from .patterns import Pattern
 
 ResponseOptions = (
-    Optional["Response"]
-    | Generator[Optional["Response"], None, None]
-    | AsyncGenerator[Optional["Response"], None]
+    Optional["Response"] | Generator[Optional["Response"], None, None] | AsyncGenerator[Optional["Response"], None]
 )
 AwaitResponse = Awaitable[ResponseOptions]
 AsyncCommandRunner = Callable[..., AwaitResponse]
@@ -44,16 +43,21 @@ CommandRunner = TypeVar("CommandRunner", bound=SyncCommandRunner | AsyncCommandR
 
 class Command(Generic[CommandRunner]):
     name: str
-    pattern: Pattern
+    patterns: dict[str, Pattern]
     _runner: CommandRunner
 
-    def __init__(self, name: str, pattern: Pattern, runner: CommandRunner):
-        assert isinstance(pattern, Pattern)
+    def __init__(self, name: str, patterns: dict[str, Pattern], runner: CommandRunner):
+        assert patterns and all(isinstance(p, Pattern) for p in patterns.values())
         self.name = name
-        self.pattern = pattern
+        self.patterns = patterns
         self._runner = runner
         update_wrapper(self, runner)
 
+    def get_pattern(self, language_code: LanguageCode) -> Pattern:
+        if language_code in self.patterns:
+            return self.patterns[language_code]
+        return self.patterns["base"]
+
     def run(
         self,
         parameters_dict: dict[str, Any] | None = None,
@@ -74,9 +78,7 @@ class Command(Generic[CommandRunner]):
 
         runner: AsyncCommandRunner
 
-        if inspect.iscoroutinefunction(self._runner) or inspect.isasyncgen(
-            self._runner
-        ):
+        if inspect.iscoroutinefunction(self._runner) or inspect.isasyncgen(self._runner):
             # async functions (coroutines) and async generators are remain as is
             runner = cast(AsyncCommandRunner, self._runner)
         else:
@@ -84,21 +86,12 @@ class Command(Generic[CommandRunner]):
             # async generators are not supported yet by asyncer.asyncify (https://github.com/tiangolo/asyncer/discussions/86)
             runner = asyncer.asyncify(cast(SyncCommandRunner, self._runner))
 
-        if any(
-            p.kind == p.VAR_KEYWORD
-            for p in inspect.signature(self._runner).parameters.values()
-        ):
+        if any(p.kind == p.VAR_KEYWORD for p in inspect.signature(self._runner).parameters.values()):
             # if command runner accepts **kwargs, pass all parameters
             coroutine = runner(**parameters)
         else:
             # otherwise pass only parameters that are in command runner signature to prevent TypeError: got an unexpected keyword argument
-            coroutine = runner(
-                **{
-                    k: v
-                    for k, v in parameters.items()
-                    if k in self._runner.__code__.co_varnames
-                }
-            )
+            coroutine = runner(**{k: v for k, v in parameters.items() if k in self._runner.__code__.co_varnames})
 
         @wraps(runner)
         async def coroutine_wrapper() -> ResponseOptions:
@@ -139,8 +132,8 @@ class ResponseStatus(Enum):
 
 
 class Response(BaseModel):
-    voice: str = ""
-    text: str = ""
+    voice: str | LocalizableString = ""
+    text: str | LocalizableString = ""
     status: ResponseStatus = ResponseStatus.success
     needs_user_input: bool = False
     commands: list[Command] = []

{stark_engine-4.3.0 → stark_engine-4.4.0}/stark/core/commands_context.py

@@ -15,6 +15,7 @@ from stark.core.commands_context_processor import (
 )
 from stark.core.parsing import PatternParser
 from stark.core.types.object import Object
+from stark.general.localisation import LocaleString, Localizer
 
 from ..general.dependencies import DependencyManager, default_dependency_manager
 from .command import (
@@ -57,11 +58,12 @@ class CommandsContext:
         commands_manager: CommandsManager,
         dependency_manager: DependencyManager = default_dependency_manager,
         processors: list[Any] | None = None,
+        localizer: Localizer | None = None,
     ):
         assert isinstance(task_group, TaskGroup), task_group
         assert isinstance(commands_manager, CommandsManager)
         assert isinstance(dependency_manager, DependencyManager)
-        self.pattern_parser = PatternParser()
+        self.pattern_parser = PatternParser(localizer=localizer)
         self.commands_manager = commands_manager
         self.context_queue = [self.root_context]
         self._response_queue = []
@@ -88,7 +90,9 @@ class CommandsContext:
     def root_context(self):
         return CommandsContextLayer(self.commands_manager.commands, {})
 
-    async def process_string(self, string: str):
+    async def process_string(self, string: str | LocaleString):
+        string = LocaleString(string) if not isinstance(string, LocaleString) else string
+
         if not self.context_queue:
             self.context_queue.append(self.root_context)
 
@@ -100,7 +104,9 @@ class CommandsContext:
 
         for processor in self.processors:
             logger.debug(f"Processing context {processor=} with {string=} {recognized_entities=} {self.context_queue=}")
-            search_results, context_pops = await processor.process_string(string, self, recognized_entities)
+            search_results, context_pops = await processor.process_string(
+                string, self, recognized_entities
+            )
             if search_results:
                 # Pop contexts as directed by processor
                 for _ in range(context_pops):

{stark_engine-4.3.0 → stark_engine-4.4.0}/stark/core/commands_context_processor.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING
 from stark.core.command import Command
 from stark.core.parsing import RecognizedEntity
 from stark.core.types.object import Object
+from stark.general.localisation import LocaleString
 
 from .commands_manager import SearchResult
 
@@ -42,7 +43,10 @@ class CommandsContextProcessor(ABC):
     """
 
     async def process_string(
-        self, string: str, context: CommandsContext, recognized_entities: list[RecognizedEntity]
+        self,
+        string: LocaleString,
+        context: CommandsContext,
+        recognized_entities: list[RecognizedEntity],
     ) -> tuple[list[SearchResult], int]:
         """
         Processes the entire context queue.
@@ -72,7 +76,7 @@ class CommandsContextProcessor(ABC):
 
     async def process_context_layer(
         self,
-        string: str,
+        string: LocaleString,
         context: CommandsContext,
         context_layer: CommandsContextLayer,
         recognized_entities: list[RecognizedEntity],

{stark_engine-4.3.0 → stark_engine-4.4.0}/stark/core/commands_manager.py

@@ -31,9 +31,14 @@ class CommandsManager:
                 return command
         return None
 
-    def new(self, pattern_str: str, hidden: bool = False):
+    def new(self, pattern_str: str | dict[str, str], hidden: bool = False):
         def creator(runner: CommandRunner) -> Command:
-            pattern = Pattern(pattern_str)
+            if isinstance(pattern_str, dict):
+                patterns = {lang: Pattern(p) for lang, p in pattern_str.items()}
+                if 'base' not in patterns:
+                    patterns['base'] = next(iter(patterns.values()))
+            else:
+                patterns = {'base': Pattern(pattern_str)}
 
             # take the main type from Optionals
             annotations = dict()
@@ -60,7 +65,7 @@ class CommandsManager:
 
             # create command
 
-            cmd = Command(f"{self.name}.{runner.__name__}", pattern, runner)
+            cmd = Command(f"{self.name}.{runner.__name__}", patterns, runner)
 
             if not hidden:
                 self.commands.append(cmd)

stark_engine-4.4.0/stark/core/health_check.py

@@ -0,0 +1,70 @@
+import warnings
+
+from stark.core.command import Command
+from stark.core.parsing import PatternParser, _LOCALIZER_KEY_REGEX
+
+
+def health_check(pattern_parser: PatternParser, commands: list[Command]) -> None:
+    # TODO: update schema and validation; handle optional parameters; handle short form where type is defined in object
+
+    # 1. Registered types: pattern parameters and annotations match; all used types are registered
+    for reg_type in pattern_parser.parameter_types_by_name.values():
+        for lang, type_pattern in reg_type.type.patterns.items():
+            pattern_params = set(type_pattern.parameters.keys())
+            class_params = set(reg_type.type.__annotations__.keys())
+            assert pattern_params <= class_params, (
+                f"Pattern parameters {pattern_params} do not match class annotations {class_params} for {reg_type.type.__name__} (language '{lang}')"
+            )
+            # 2. Registered types: All referenced parameter types are registered
+            for param_name in pattern_params:
+                assert type_pattern.parameters[param_name].type_name in pattern_parser.parameter_types_by_name, (
+                    f"Unknown parameter type '{param_name}' in pattern '{type_pattern}' of type '{reg_type.type.__name__}' (language '{lang}'). Known types: {sorted(pattern_parser.parameter_types_by_name.keys())}"
+                )
+
+    # 3. No duplicate parameter types registered
+    type_names = list(pattern_parser.parameter_types_by_name.keys())
+    if len(type_names) != len(set(type_names)):
+        duplicates = {name for name in type_names if type_names.count(name) > 1}
+        assert not duplicates, f"Duplicate parameter type names found: {sorted(duplicates)}"
+
+    # 4. Commands: validate @key references and parameter types
+    for command in commands:
+        for lang, cmd_pattern in command.patterns.items():
+            if pattern_parser.localizer and pattern_parser._has_localizer_keys(cmd_pattern):
+                for key in _LOCALIZER_KEY_REGEX.findall(cmd_pattern._origin):
+                    pattern_parser.localizer.verify_key_exists(key)
+        for param in command.get_pattern("base").parameters.values():
+            assert param.type_name in pattern_parser.parameter_types_by_name, (
+                f"Unknown parameter type '{param.type_name}' in pattern '{command.get_pattern("base")}' of command '{command.name}'. Known types: {sorted(pattern_parser.parameter_types_by_name.keys())}"
+            )
+
+    # 5. Commands: all pattern params are expected by the runner func
+    for command in commands:
+        pattern_params = set(command.get_pattern("base").parameters.keys())
+        runner_params = set(command._runner.__annotations__.keys())
+        assert pattern_params <= runner_params, f"Command '{command.name}' function missing parameters: {pattern_params - runner_params}"
+
+    # 6. Pattern syntax validity (TODO)
+    # for command in commands:
+    #     assert command.get_pattern("base").is_valid(), f"Invalid pattern syntax: {command.get_pattern("base").origin}"
+
+    # 7. Try compiling all patterns to catch syntax errors early
+    for reg_type in pattern_parser.parameter_types_by_name.values():
+        for lang, p in reg_type.type.patterns.items():
+            try:
+                pattern_parser._compile_pattern(p, language_code=lang)
+            except Exception as e:
+                warnings.warn(f"Failed to compile pattern '{p}' of type '{reg_type.type.__name__}' (language '{lang}'): {e}")
+    for command in commands:
+        for lang, p in command.patterns.items():
+            try:
+                pattern_parser._compile_pattern(p, language_code=lang)
+            except Exception as e:
+                warnings.warn(f"Failed to compile pattern '{p}' of command '{command.name}' (language '{lang}'): {e}")
+
+    # 8. No unused types
+    used_types = {param.type_name for command in commands for param in command.get_pattern("base").parameters.values()}
+    for type_name in pattern_parser.parameter_types_by_name:
+        # assert type_name in used_types, f"Registered type {type_name} is not used in any pattern"
+        if type_name not in used_types:
+            warnings.warn(f"Registered type {type_name} is not used in any pattern")

{stark_engine-4.3.0 → stark_engine-4.4.0}/stark/core/parsing.py

@@ -11,6 +11,7 @@ from stark.core.types import Object
 from stark.core.types.string import String
 from stark.core.types.word import Word
 from stark.general.cache import alru_cache
+from stark.general.localisation import LanguageCode, LocaleString, Localizer
 
 type ObjectType = type[Object]
 
@@ -19,6 +20,8 @@ import logging
 
 logger = logging.getLogger(__name__)
 
+_LOCALIZER_KEY_REGEX = re.compile(r"@(?P<key>[A-Za-z_][A-Za-z0-9_]*)")
+
 
 class ParseError(Exception):
     pass
@@ -62,7 +65,13 @@ class RecognizedEntity:
 
 
 class ObjectParser(ABC):
-    async def did_parse(self, obj: Object, from_string: str) -> str:
+    localizer: Localizer | None = None
+
+    @property
+    def patterns(self) -> dict[str, Pattern] | None:
+        return None
+
+    async def did_parse(self, obj: Object, from_string: LocaleString) -> str:
         """
         This method is called after parsing from string and setting parameters found in pattern.
         You will very rarely, if ever, need to call this method directly.
@@ -80,9 +89,11 @@ class ObjectParser(ABC):
 
 class PatternParser:
     parameter_types_by_name: dict[str, RegisteredParameterType] = {}
+    localizer: Localizer | None
 
-    def __init__(self):
+    def __init__(self, localizer: Localizer | None = None):
         self.parameter_types_by_name = {}
+        self.localizer = localizer
         self.register_parameter_type(Word)
         self.register_parameter_type(String)
 
@@ -92,35 +103,70 @@ class PatternParser:
         parser: ObjectParser | None = None,
         # TODO: consider adding lang parameter
     ):
-        assert issubclass(object_type, Object), f'Can`t add parameter type "{object_type.__name__}": it is not a subclass of Object'
+        assert issubclass(object_type, Object), (
+            f'Can`t add parameter type "{object_type.__name__}": it is not a subclass of Object'
+        )
         exists_type = self.parameter_types_by_name.get(object_type.__name__)
-        assert exists_type is None, f"Duplicate parameter type: can`t add parameter type '{object_type.__name__}' because it already exists"
+        assert exists_type is None, (
+            f"Duplicate parameter type: can`t add parameter type '{object_type.__name__}' because it already exists"
+        )
+        resolved_parser = parser or ObjectParser()
+        resolved_parser.localizer = self.localizer
         self.parameter_types_by_name[object_type.__name__] = RegisteredParameterType(
-            name=object_type.__name__, type=object_type, parser=parser or ObjectParser()
+            name=object_type.__name__, type=object_type, parser=resolved_parser
         )
+        self._validate_localizer_keys(object_type)
+
+    def _validate_localizer_keys(self, object_type: ObjectType):
+        for pattern in object_type.patterns.values():
+            keys = _LOCALIZER_KEY_REGEX.findall(pattern._origin)
+            if not keys:
+                continue
+            if not self.localizer:
+                raise ValueError(
+                    f"Pattern '{pattern._origin}' of type '{object_type.__name__}' contains @key references but no Localizer is configured on PatternParser"
+                )
+            for key in keys:
+                self.localizer.verify_key_exists(key)
+
+    @staticmethod
+    def _has_localizer_keys(pattern: Pattern) -> bool:
+        return bool(_LOCALIZER_KEY_REGEX.search(pattern._origin))
 
-    async def parse_object_name(self, class_name: str, from_string: str) -> ParseResult:
+    async def parse_object_name(self, class_name: str, from_string: str | LocaleString) -> ParseResult:
         return await self.parse_object(self.parameter_types_by_name[class_name].type, from_string)
 
-    async def parse_object(self, object_type: ObjectType, from_string: str) -> ParseResult:
+    async def parse_object(self, object_type: ObjectType, from_string: str | LocaleString) -> ParseResult:
         async for obj in self.parse_objects(object_type, from_string):
             return obj  # take the first successful parsed result, usually the only one
         else:
             raise ParseError(f"Failed to parse object of type {object_type.__name__} from string '{from_string}'")
 
-    async def parse_objects(self, object_type: ObjectType, from_string: str) -> AsyncGenerator[ParseResult]:
-        object_matches = await self.match(object_type.pattern, from_string)
+    def _resolve_pattern(self, object_type: ObjectType, language_code: LanguageCode) -> Pattern:
+        parser = self.parameter_types_by_name[object_type.__name__].parser
+        patterns = parser.patterns or object_type.patterns
+        if language_code in patterns:
+            return patterns[language_code]
+        return patterns["base"]
+
+    async def parse_objects(
+        self, object_type: ObjectType, from_string: str | LocaleString
+    ) -> AsyncGenerator[ParseResult]:
+        from_string = from_string if isinstance(from_string, LocaleString) else LocaleString(from_string)
+        language_code = from_string.language_code
+        pattern = self._resolve_pattern(object_type, language_code)
+        object_matches = await self.match(pattern, from_string)
 
         for object_pattern_match in object_matches:
-            string = object_pattern_match.substring
+            string = from_string._with(object_pattern_match.substring)  # TODO: review _with usage
 
             parser: ObjectParser = self.parameter_types_by_name[object_type.__name__].parser
             obj = object_type(string)  # temp/default value, may be overridden by did_parse
 
             matched_subparams = object_pattern_match.parameters
-            assert matched_subparams.keys() <= {p.name for p in object_type.pattern.parameters.values() if not p.optional}
+            assert matched_subparams.keys() <= {p.name for p in pattern.parameters.values() if not p.optional}
 
-            for name in object_type.pattern.parameters:
+            for name in pattern.parameters:
                 value = matched_subparams[name]
                 setattr(obj, name, value)
 
@@ -141,14 +187,22 @@ class PatternParser:
             yield ParseResult(obj, substring)
 
     @alru_cache(maxsize=256, ttl=60 * 10)  # TODO: env vars + disable option
-    async def _did_parse(self, obj: Object, parser: ObjectParser, string: str) -> str:
+    async def _did_parse(self, obj: Object, parser: ObjectParser, string: LocaleString) -> str:
         substring = await parser.did_parse(obj, string)
+        substring = string._with(substring) if not isinstance(substring, LocaleString) else substring
         substring = await obj.did_parse(substring)
         return substring
 
-    async def match(self, pattern: Pattern, string: str, recognized_entities: list[RecognizedEntity] | None = None) -> list[MatchResult]:
+    async def match(
+        self,
+        pattern: Pattern,
+        string: str | LocaleString,
+        recognized_entities: list[RecognizedEntity] | None = None,
+    ) -> list[MatchResult]:
+        string = string if isinstance(string, LocaleString) else LocaleString(string)
+        language_code = string.language_code
         recognized_entities = recognized_entities or []
-        compiled = self._compile_pattern(pattern)
+        compiled = self._compile_pattern(pattern, language_code=language_code)
         logger.debug(f'Starting looking for "{pattern=}" "{compiled=}" in "{string}"')
 
         matches = []
@@ -159,7 +213,9 @@ class PatternParser:
 
             new_match = None
             command_substr = string[match.start() : match.end()]
-            new_match, parsed_parameters = await self._parse_parameters_for_match(pattern, command_substr, recognized_entities)
+            new_match, parsed_parameters = await self._parse_parameters_for_match(
+                pattern, command_substr, recognized_entities, language_code
+            )
             assert new_match is not None, "new_match should not be None"
             new_match = new_match or match
 
@@ -186,7 +242,10 @@ class PatternParser:
                     substring=command_str,
                     start=start,
                     end=end,
-                    parameters={name: (parameter.parsed_obj if parameter else None) for name, parameter in all_parameters.items()},
+                    parameters={
+                        name: (parameter.parsed_obj if parameter else None)
+                        for name, parameter in all_parameters.items()
+                    },
                 )
             )
             logger.debug(f"Match result: {matches[-1]}")
@@ -198,7 +257,11 @@ class PatternParser:
         return sorted(re.finditer(compiled, string), key=lambda match: match.start())
 
     async def _parse_parameters_for_match(
-        self, pattern: Pattern, string: str, recognized_entities: list[RecognizedEntity]
+        self,
+        pattern: Pattern,
+        string: LocaleString,
+        recognized_entities: list[RecognizedEntity],
+        language_code: LanguageCode,
     ) -> tuple[re.Match | None, dict[str, ParameterMatch]]:
         parsed_parameters: dict[str, ParameterMatch] = {}
         logger.debug(f'Captured candidate "{string}"')
@@ -214,7 +277,7 @@ class PatternParser:
             prefill = {name: parameter.parsed_substr for name, parameter in parsed_parameters.items()}
 
             # re-run regex only in the current command_str
-            compiled = self._compile_pattern(pattern, prefill=prefill)
+            compiled = self._compile_pattern(pattern, prefill=prefill, language_code=language_code)
             new_matches = list(re.finditer(compiled, string))
 
             logger.debug(f'Re capturing parameters {string} prefill={prefill} compiled="{compiled}"')
@@ -269,7 +332,10 @@ class PatternParser:
                 ),
             )
             parameter_match = await self._parse_single_parameter(
-                pattern, parameter_name, match_str_groups[parameter_name].strip(), recognized_entities
+                pattern,
+                parameter_name,
+                string._with(match_str_groups[parameter_name].strip()),
+                recognized_entities,
             )
             if parameter_match is not None:
                 parsed_parameters[parameter_name] = parameter_match
@@ -277,7 +343,11 @@ class PatternParser:
         return new_match, parsed_parameters
 
     async def _parse_single_parameter(
-        self, pattern: Pattern, parameter_name: str, raw_param_substr: str, recognized_entities: list[RecognizedEntity]
+        self,
+        pattern: Pattern,
+        parameter_name: str,
+        raw_param_substr: LocaleString,
+        recognized_entities: list[RecognizedEntity],
     ) -> ParameterMatch | None:
         param = pattern.group_name_to_param[parameter_name]
         parameter_reg_type = self.parameter_types_by_name[param.type_name]
@@ -287,7 +357,7 @@ class PatternParser:
         # check recognized entities, update substring if found match
         for entity in recognized_entities:
             if entity.substring in raw_param_substr and entity.type is parameter_reg_type.type:
-                raw_param_substr = entity.substring
+                raw_param_substr = raw_param_substr._with(entity.substring)
                 logger.debug(f"Adjusting for recognized entity: '{entity.substring}'")
 
         # parse the object
@@ -321,11 +391,27 @@ class PatternParser:
         pattern: Pattern,
         group_prefix: str = "",
         prefill: dict[str, str] | None = None,
+        language_code: LanguageCode = "base",
     ) -> str:  # transform Pattern to classic regex with named groups
         prefill = prefill or {}
 
         pattern_str: str = pattern._origin
 
+        if self._has_localizer_keys(pattern):
+            if not self.localizer:
+                raise ValueError(
+                    f"Pattern '{pattern._origin}' contains @key references but no Localizer is configured on PatternParser"
+                )
+
+            def _resolve_key(m: re.Match) -> str:
+                key = m.group("key")
+                resolved = self.localizer.get_recognizable(key, language_code)
+                if resolved is None:
+                    raise KeyError(f"Localizer key '@{key}' not found for language '{language_code}'")
+                return resolved
+
+            pattern_str = _LOCALIZER_KEY_REGEX.sub(_resolve_key, pattern_str)
+
         #   transform core expressions to regex
 
         for rule in rules_list:
@@ -341,17 +427,24 @@ class PatternParser:
         for parameter in pattern.parameters.values():
             parameter_type = self.parameter_types_by_name[parameter.type_name].type
 
-            arg_declaration = f"\\${parameter.name}\\:{parameter_type.__name__}"  # NOTE: special chars escaped for regex
+            arg_declaration = (
+                f"\\${parameter.name}\\:{parameter_type.__name__}"  # NOTE: special chars escaped for regex
+            )
             if parameter.name in prefill:
                 arg_pattern = prefill[parameter.name]  # TODO: review wether re.escape is needed
             else:  # replace pattern annotation with compiled regex
                 parameter.group_name = ((group_prefix + "_") if group_prefix else "") + parameter.name
-                arg_pattern = self._compile_pattern(parameter_type.pattern, group_prefix=parameter.group_name).replace("\\", r"\\")
+                param_pattern = self._resolve_pattern(parameter_type, language_code)
+                arg_pattern = self._compile_pattern(
+                    param_pattern, group_prefix=parameter.group_name, language_code=language_code
+                ).replace("\\", r"\\")
 
                 if parameter_type.greedy and arg_pattern[-1] in {"*", "+", "}", "?"}:
                     # compensate greedy did_parse with non-greedy regex, so it won't consume next params during initial regex
                     arg_pattern += "?"
-                    if pattern_str.endswith(f"${parameter.name}:{parameter_type.__name__}"):  # NOTE: regex chars are NOT escaped
+                    if pattern_str.endswith(
+                        f"${parameter.name}:{parameter_type.__name__}"
+                    ):  # NOTE: regex chars are NOT escaped
                         # compensate the last non_greedy regex to allow consuming till the end of the string
                         # middle greedy params are limited/stretched by neighbor params
                         arg_pattern += "$"

{stark_engine-4.3.0 → stark_engine-4.4.0}/stark/core/patterns/pattern.py

@@ -27,7 +27,6 @@ class PatternParameter:
 
 class Pattern:
     parameters: dict[str, PatternParameter]
-    # compiled: str
 
     _origin: str
     _parameter_regex: re.Pattern

{stark_engine-4.3.0 → stark_engine-4.4.0}/stark/core/processors/search_processor.py

@@ -5,6 +5,7 @@ from typing import override
 from asyncer import SoonValue, create_task_group
 
 from stark.core.parsing import MatchResult, PatternParser, RecognizedEntity
+from stark.general.localisation import LocaleString
 
 from ..command import Command
 from ..commands_context import CommandsContext, CommandsContextLayer
@@ -15,11 +16,13 @@ from ..commands_manager import SearchResult
 class SearchProcessor(CommandsContextProcessor):
     async def search(
         self,
-        string: str,
+        string: str | LocaleString,
         pattern_parser: PatternParser,
         commands: list[Command],
         recognized_entities: list[RecognizedEntity],
     ) -> list[SearchResult]:
+        string = string if isinstance(string, LocaleString) else LocaleString(string)
+        language_code = string.language_code
         results: list[SearchResult] = []
         futures: list[tuple[Command, SoonValue[list[MatchResult]]]] = []
 
@@ -29,7 +32,9 @@ class SearchProcessor(CommandsContextProcessor):
                 futures.append(
                     (
                         command,
-                        group.soonify(pattern_parser.match)(command.pattern, string, recognized_entities),
+                        group.soonify(pattern_parser.match)(
+                            command.get_pattern(language_code), string, recognized_entities
+                        ),
                     )
                 )
 
@@ -46,19 +51,28 @@ class SearchProcessor(CommandsContextProcessor):
 
         # copy to prevent affecting iteration by removing items; slice makes copy automatically
         for prev, current in zip(results.copy(), results[1:]):  # TODO: concurrent; optimize using cache
-            if prev.match_result.start == current.match_result.start or prev.match_result.end > current.match_result.start:
+            if (
+                prev.match_result.start == current.match_result.start
+                or prev.match_result.end > current.match_result.start
+            ):
                 # constrain prev end to current start
                 prev_cut = await pattern_parser.match(
-                    prev.command.pattern, string[prev.match_result.start : current.match_result.start], recognized_entities
+                    prev.command.get_pattern(language_code),
+                    string[prev.match_result.start : current.match_result.start],
+                    recognized_entities,
                 )
                 # constrain current start to prev end
                 current_cut = await pattern_parser.match(
-                    current.command.pattern, string[prev.match_result.end : current.match_result.end], recognized_entities
+                    current.command.get_pattern(language_code),
+                    string[prev.match_result.end : current.match_result.end],
+                    recognized_entities,
                 )
 
                 # less index = more priority to save full match
                 priority1, priority2 = (prev, current) if prev.index < current.index else (current, prev)
-                priority1_cut, priority2_cut = (prev_cut, current_cut) if prev.index < current.index else (current_cut, prev_cut)
+                priority1_cut, priority2_cut = (
+                    (prev_cut, current_cut) if prev.index < current.index else (current_cut, prev_cut)
+                )
 
                 if new_matches := priority2_cut:  # if can cut less priority
                     priority2.match_result = new_matches[0]
@@ -74,7 +88,7 @@ class SearchProcessor(CommandsContextProcessor):
     @override
     async def process_context_layer(
         self,
-        string: str,
+        string: LocaleString,
         context: CommandsContext,
         context_layer: CommandsContextLayer,
         recognized_entities: list[RecognizedEntity],