mapres 3.dev14__tar.gz → 3.dev16__tar.gz

{mapres-3.dev14/src/mapres.egg-info → mapres-3.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapres
-Version: 3.dev14
+Version: 3.dev16
 Summary: A powerfull mapping utility
 Author: iFamished
 License: MIT

{mapres-3.dev14 → mapres-3.dev16}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mapres"
-version = "3-dev.14"
+version = "3-dev.16"
 description = "A powerfull mapping utility"
 readme = "README.md"
 requires-python = ">=3.9"

{mapres-3.dev14 → mapres-3.dev16}/src/mapres/datamap.py

@@ -35,7 +35,10 @@ class DataMap:
         - "callable": map exposes callable methods for nested calls
     '''
     __syntax__: str = None
-    __mode__: str | None = None  # "dynamic", "config", "callable", or None
+    __mode__: str | None = None # "dynamic", "config", "callable", or None
+    __recursive__: bool = False
+    __missing_key__: str = 'error'  # 'error', 'silent', 'placeholder'
+    __ignore_delimiters__: bool = False
 
     def as_map(self):
         '''
@@ -47,8 +50,9 @@ class DataMap:
         '''
         result = {}
 
+        # dataclass fields
         for f in fields(self):
-            if not f.init or f.name in ('__syntax__', '__mode__'):
+            if not f.init or f.name.startswith('__'):
                 continue
 
             val = getattr(self, f.name)
@@ -63,24 +67,58 @@ class DataMap:
 
             result[f.name] = val
 
+        # nested classes > nested dicts
+        for name, obj in self.__class__.__dict__.items():
+            if name.startswith('__'):
+                continue
+            if isinstance(obj, type):
+                result[name] = self._class_to_dict(obj)
+
         return result
 
+    def _class_to_dict(self, cls):
+        out = {}
+
+        if is_dataclass(cls):
+            dummy = cls()
+            for f in fields(dummy):
+                if not f.init:
+                    continue
+                out[f.name] = getattr(dummy, f.name)
+
+        for name, obj in cls.__dict__.items():
+            if name.startswith('__'):
+                continue
+            if isinstance(obj, type):
+                out[name] = self._class_to_dict(obj)
+
+        return out
+
+
+def datamap(_cls=None, *, syntax=None, mode=None, recursive=None,
+            missing_key=None, ignore_delimiters=None):
 
-# main decorator factory
-def datamap(_cls=None, *, syntax=None, mode=None):
-    '''@datamap decorator'''
     def wrap(cls):
         cls.__syntax__ = syntax
         cls.__mode__ = mode
+        cls.__recursive__ = recursive
+        cls.__missing_key__ = missing_key or 'error'
+        cls.__ignore_delimiters__ = ignore_delimiters or False
+
         namespace = dict(cls.__dict__)
         namespace['__dict__'] = {}
         rules_obj = namespace.get('rules', None)
+
         cls = type(cls.__name__, (DataMap,), namespace)
+
         if rules_obj is not None:
             setattr(cls, 'rules', rules_obj)
+
         return dataclass(frozen=False)(cls)
-    if _cls is not None:
+
+    if _cls is not None and isinstance(_cls, type):
         return wrap(_cls)
+
     return wrap
 
 
@@ -98,30 +136,23 @@ class _SyntaxFactory:
         self._syntax = syntax_name
 
     def __call__(self, _cls=None, **kwargs):
-        # Case 1: bare decorator: @datamap.angles
         if _cls is not None and isinstance(_cls, type):
             return datamap(_cls, syntax=self._syntax)
-
-        # Case 2: decorator with args: @datamap.angles(mode='config')
         return datamap(syntax=self._syntax, **kwargs)
 
     @property
     def config(self):
-        # Case 3: @datamap.angles.config
         return datamap(syntax=self._syntax, mode='config')
 
     @property
     def dynamic(self):
-        # @datamap.angles.dynamic
         return datamap(syntax=self._syntax, mode='dynamic')
 
     @property
     def callable(self):
-        # @datamap.angles.callable
         return datamap(syntax=self._syntax, mode='callable')
 
 
-# build syntax shortcuts
 datamap.braces        = _SyntaxFactory(syntax.braces)
 datamap.dollars       = _SyntaxFactory(syntax.dollars)
 datamap.angles        = _SyntaxFactory(syntax.angles)
@@ -132,7 +163,6 @@ datamap.at_tags       = _SyntaxFactory(syntax.at_tags)
 datamap.hash_tags     = _SyntaxFactory(syntax.hash_tags)
 datamap.paren_dollars = _SyntaxFactory(syntax.paren_dollars)
 
-# global mode shortcuts
 datamap.config   = datamap(mode='config')
 datamap.dynamic  = datamap(mode='dynamic')
 datamap.callable = datamap(mode='callable')

mapres-3.dev16/src/mapres/evaluator.py

@@ -0,0 +1,221 @@
+from .ast import TemplateNode, TextNode, IdentNode, CallNode
+from .tokenizer import Tokenizer
+from .parser import Parser
+from .exceptions import MapResError, MissingKeyError
+
+
+class EvaluationError(MapResError):
+    pass
+
+
+class Evaluator:
+    def __init__(self, layerstack, ctx=None):
+        self.layerstack = layerstack
+        self.ctx = ctx or {}
+        self._seen = set()  # cycle detection
+
+    # public api
+    def evaluate(self, node):
+        return self._eval(node)
+
+    # internal dispatch
+    def _eval(self, node):
+        if isinstance(node, TemplateNode):
+            return self._eval_template(node)
+
+        if isinstance(node, TextNode):
+            return node.text
+
+        if isinstance(node, IdentNode):
+            return self._eval_ident(node)
+
+        if isinstance(node, CallNode):
+            return self._eval_call(node)
+
+        raise EvaluationError(f'Unknown AST node: {node}')
+
+    # template
+    def _eval_template(self, node: TemplateNode):
+        parts = []
+        for child in node.children:
+            parts.append(self._eval(child))
+        out = ''.join(parts)
+
+        # recursion over full template output
+        if self._has_recursive_maps():
+            seen = set()
+            depth = 0
+            max_depth = self._get_max_depth()
+
+            while depth < max_depth:
+                new_out = self._re_resolve(out)
+                if new_out == out:
+                    break
+                if new_out in seen:
+                    raise EvaluationError('Cycle detected in template recursion')
+                seen.add(new_out)
+                out = new_out
+                depth += 1
+
+        return out
+
+    # identifier
+    def _eval_ident(self, node: IdentNode):
+        name = node.name
+
+        # ignore_delimiters: treat token as literal for this syntax
+        if self._syntax_ignores_delimiters(node.syntax):
+            return self._literal_from_syntax(name, node.syntax)
+
+        # cycle detection
+        if name in self._seen:
+            raise EvaluationError(f"Cycle detected in identifier '{name}'")
+        self._seen.add(name)
+
+        parts = name.split('.')
+
+        # 1. ctx first
+        val = self._lookup_hierarchical(self.ctx, parts)
+        if val is not None:
+            self._seen.remove(name)
+            return str(val)
+
+        # 2. syntax-bound maps
+        for m in self.layerstack.all_maps():
+            if getattr(m, '__syntax__', None) not in (None, node.syntax):
+                continue
+
+            d = self._map_to_dict(m)
+            val = self._lookup_hierarchical(d, parts)
+            if val is not None:
+                self._seen.remove(name)
+                return str(val)
+
+        self._seen.remove(name)
+        raise MissingKeyError(name)
+
+    # call (nested token)
+    def _eval_call(self, node: CallNode):
+        outer = node.name
+
+        # ignore_delimiters: treat call token as literal
+        if self._syntax_ignores_delimiters(node.syntax):
+            arg_text = self._eval(node.arg)
+            return self._literal_from_syntax(outer, node.syntax, is_call=True, arg_text=arg_text)
+
+        if outer in self._seen:
+            raise EvaluationError(f"Cycle detected in call '{outer}'")
+        self._seen.add(outer)
+
+        arg_value = self._eval(node.arg)
+        parts = [outer, arg_value]
+
+        # ctx first
+        val = self._lookup_hierarchical(self.ctx, parts)
+        if val is not None:
+            self._seen.remove(outer)
+            return str(val)
+
+        # syntax-bound maps
+        for m in self.layerstack.all_maps():
+            if getattr(m, '__syntax__', None) not in (None, node.syntax):
+                continue
+
+            d = self._map_to_dict(m)
+            val = self._lookup_hierarchical(d, parts)
+            if val is not None:
+                self._seen.remove(outer)
+                return str(val)
+
+        self._seen.remove(outer)
+        raise MissingKeyError(f'{outer}({arg_value})')
+
+    # helpers
+    def _map_to_dict(self, m):
+        if hasattr(m, 'as_map'):
+            return m.as_map()
+        if isinstance(m, dict):
+            return m
+        raise EvaluationError(f'Invalid map object: {m}')
+
+    def _lookup_hierarchical(self, root, parts):
+        cur = root
+        for p in parts:
+            if not isinstance(cur, dict):
+                return None
+            if p not in cur:
+                return None
+            cur = cur[p]
+        return cur
+
+    def _has_recursive_maps(self):
+        for m in self.layerstack.all_maps():
+            if getattr(m, '__recursive__', False):
+                return True
+        return False
+
+    def _get_max_depth(self):
+        depths = [
+            getattr(m, '__max_depth__', 10)
+            for m in self.layerstack.all_maps()
+            if getattr(m, '__recursive__', False)
+        ]
+        return max(depths) if depths else 0
+
+    def _re_resolve(self, text: str) -> str:
+        tokens = Tokenizer(text).tokenize()
+        ast = Parser(tokens).parse()
+        return self.evaluate(ast)
+
+    def _syntax_ignores_delimiters(self, syntax_name: str) -> bool:
+        for m in self.layerstack.all_maps():
+            if getattr(m, '__syntax__', None) == syntax_name:
+                if getattr(m, '__ignore_delimiters__', False):
+                    return True
+        return False
+
+    def _literal_from_syntax(self, name: str, syntax_name: str, is_call: bool = False, arg_text: str | None = None) -> str:
+        if not is_call:
+            if syntax_name == 'colons':
+                return f':{name}:'
+            if syntax_name == 'braces':
+                return f'{{{{{name}}}}}'
+            if syntax_name == 'dollars':
+                return f'${{{name}}}'
+            if syntax_name == 'angles':
+                return f'<{name}>'
+            if syntax_name == 'pipes':
+                return f'|{name}|'
+            if syntax_name == 'percents':
+                return f'%{name}%'
+            if syntax_name == 'paren_dollars':
+                return f'$({name})'
+            if syntax_name == 'at_tags':
+                return f'@{name}@'
+            if syntax_name == 'hash_tags':
+                return f'#{name}#'
+            return name
+
+        # call literal: syntax-specific wrapping of name(arg_text)
+        arg = arg_text or ''
+        inner = f'{name}({arg})'
+
+        if syntax_name == 'colons':
+            return f':{inner}:'
+        if syntax_name == 'braces':
+            return f'{{{{{inner}}}}}'
+        if syntax_name == 'dollars':
+            return f'${{{inner}}}'
+        if syntax_name == 'angles':
+            return f'<{inner}>'
+        if syntax_name == 'pipes':
+            return f'|{inner}|'
+        if syntax_name == 'percents':
+            return f'%{inner}%'
+        if syntax_name == 'paren_dollars':
+            return f'$({inner})'
+        if syntax_name == 'at_tags':
+            return f'@{inner}@'
+        if syntax_name == 'hash_tags':
+            return f'#{inner}#'
+        return inner

{mapres-3.dev14 → mapres-3.dev16}/src/mapres/exceptions.py

@@ -2,7 +2,9 @@ class MapResError(Exception):
     pass
 
 class MissingKeyError(MapResError):
-    pass
+    def __init__(self, key):
+        super().__init__(f'Missing key {key!r}')
+        self.key = key
 
 class MapSyntaxError(MapResError):
     pass

{mapres-3.dev14 → mapres-3.dev16}/src/mapres/resolver.py

@@ -3,7 +3,7 @@ from .parser import Parser
 from .evaluator import Evaluator
 from .layers import LayerStack
 from .cache import LRUCache
-from .exceptions import MapResError
+from .exceptions import MapResError, MissingKeyError
 
 
 class MapResolver:
@@ -65,8 +65,18 @@ class MapResolver:
 
             return result
 
+        except MissingKeyError as exc:
+            mode = self._resolve_missing_key_mode()
+            if mode == 'error':
+                raise MapResError(f'Resolver error: {exc}') from exc
+            if mode == 'silent':
+                return text
+            if mode == 'placeholder':
+                return f'<missing:{exc.key}>'
+            raise MapResError(f'Resolver error: {exc}') from exc
+
         except Exception as exc:
-            raise MapResError(f"Resolver error: {exc}") from exc
+            raise MapResError(f'Resolver error: {exc}') from exc
 
     # ---------------------------------------
     # LAYERSTACK BUILDING
@@ -92,6 +102,13 @@ class MapResolver:
 
         return self.layers
 
+    def _resolve_missing_key_mode(self):
+        for m in self.layers.all_maps():
+            mode = getattr(m, '__missing_key__', None)
+            if mode is not None:
+                return mode
+        return 'error'
+
 
 # ---------------------------------------
 # SIMPLE GLOBAL USAGE

{mapres-3.dev14 → mapres-3.dev16}/src/mapres/tokenizer.py

@@ -28,8 +28,8 @@ class Token:
 
     def __repr__(self):
         if self.value is not None:
-            return f"Token({self.type}, {self.value!r}, pos={self.pos})"
-        return f"Token({self.type}, pos={self.pos})"
+            return f'Token({self.type}, {self.value!r}, pos={self.pos})'
+        return f'Token({self.type}, pos={self.pos})'
 
 
 class Tokenizer:
@@ -38,10 +38,15 @@ class Tokenizer:
         self.i = 0
         self.n = len(text)
         self.tokens = []
+
+        # toggle states
         self.in_pipe = False
         self.in_percent = False
         self.in_colon = False
 
+        # mixed states
+        self.in_dollar = False
+
     def peek(self, k=0):
         idx = self.i + k
         if idx >= self.n:
@@ -68,6 +73,7 @@ class Tokenizer:
         while self.i < self.n:
             ch = self.peek()
 
+            # escapes
             if self.match(r'\:'):
                 buf.append(':'); self.advance(2); continue
             if self.match(r'\<'):
@@ -89,43 +95,57 @@ class Tokenizer:
             if self.match(r'\)'):
                 buf.append(')'); self.advance(2); continue
 
-            if self.match("{{"):
+            # --- paired delimiters ---
+
+            # braces {{ }}
+            if self.match('{{'):
                 flush_text()
                 self.emit(TokenType.BRACE_OPEN)
                 self.advance(2)
                 continue
 
-            if self.match("}}"):
+            if self.match('}}'):
                 flush_text()
                 self.emit(TokenType.BRACE_CLOSE)
                 self.advance(2)
                 continue
 
-            if self.match("${"):
+            # angles < >
+            if self.match('<'):
                 flush_text()
-                self.emit(TokenType.DOLLAR_OPEN)
-                self.advance(2)
+                self.emit(TokenType.ANGLE_OPEN)
+                self.advance()
                 continue
 
-            if self.match("}"):
+            if self.match('>'):
                 flush_text()
-                self.emit(TokenType.DOLLAR_CLOSE)
+                self.emit(TokenType.ANGLE_CLOSE)
                 self.advance()
                 continue
 
-            if self.match("<"):
+            # --- mixed delimiters (dollars) ---
+
+            if self.match('${'):
                 flush_text()
-                self.emit(TokenType.ANGLE_OPEN)
-                self.advance()
+                self.emit(TokenType.DOLLAR_OPEN)
+                self.in_dollar = True
+                self.advance(2)
                 continue
 
-            if self.match(">"):
+            if ch == '}':
                 flush_text()
-                self.emit(TokenType.ANGLE_CLOSE)
+                if self.in_dollar:
+                    self.emit(TokenType.DOLLAR_CLOSE)
+                    self.in_dollar = False
+                else:
+                    buf.append('}')
                 self.advance()
                 continue
 
-            if self.match("|"):
+            # --- toggle delimiters ---
+
+            # pipes |...|
+            if self.match('|'):
                 flush_text()
                 if not self.in_pipe:
                     self.emit(TokenType.PIPE_OPEN)
@@ -136,7 +156,8 @@ class Tokenizer:
                 self.advance()
                 continue
 
-            if self.match("%"):
+            # percents %...%
+            if self.match('%'):
                 flush_text()
                 if not self.in_percent:
                     self.emit(TokenType.PERCENT_OPEN)
@@ -147,7 +168,8 @@ class Tokenizer:
                 self.advance()
                 continue
 
-            if self.match(":"):
+            # colons :...:
+            if self.match(':'):
                 flush_text()
                 if not self.in_colon:
                     self.emit(TokenType.COLON_OPEN)
@@ -158,27 +180,51 @@ class Tokenizer:
                 self.advance()
                 continue
 
-            if ch == "(":
+            # --- parens ---
+
+            if ch == '(':
                 flush_text()
                 self.emit(TokenType.LPAREN)
                 self.advance()
                 continue
 
-            if ch == ")":
+            if ch == ')':
                 flush_text()
                 self.emit(TokenType.RPAREN)
                 self.advance()
                 continue
 
-            if ch.isalpha():
+            # --- IDENT (your rules) ---
+
+            if ch.isalnum():
                 flush_text()
                 start = self.i
-                while self.peek().isalnum() or self.peek() in "._":
-                    self.advance()
+
+                # first char: [a-zA-Z0-9]
+                self.advance()
+
+                # middle chars: [a-zA-Z0-9._]*
+                while True:
+                    nxt = self.peek()
+                    if not nxt:
+                        break
+                    if nxt.isalnum() or nxt in '._':
+                        self.advance()
+                    else:
+                        break
+
                 ident = self.text[start:self.i]
-                self.emit(TokenType.IDENT, ident)
+
+                # enforce: no leading/trailing '_', no '-'
+                if ident.startswith('_') or ident.endswith('_') or '-' in ident:
+                    # treat as TEXT instead
+                    buf.append(ident)
+                else:
+                    self.emit(TokenType.IDENT, ident)
                 continue
 
+            # --- fallback: TEXT ---
+
             buf.append(ch)
             self.advance()
 

{mapres-3.dev14 → mapres-3.dev16/src/mapres.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapres
-Version: 3.dev14
+Version: 3.dev16
 Summary: A powerfull mapping utility
 Author: iFamished
 License: MIT

mapres-3.dev14/src/mapres/evaluator.py

@@ -1,119 +0,0 @@
-from .ast import TemplateNode, TextNode, IdentNode, CallNode
-
-
-class EvaluationError(Exception):
-    pass
-
-
-class Evaluator:
-    def __init__(self, layerstack, ctx=None):
-        self.layerstack = layerstack
-        self.ctx = ctx or {}
-        self._seen = set()  # cycle detection
-
-    # public api
-    def evaluate(self, node):
-        return self._eval(node)
-
-    # internal dispatch
-    def _eval(self, node):
-        if isinstance(node, TemplateNode):
-            return self._eval_template(node)
-
-        if isinstance(node, TextNode):
-            return node.text
-
-        if isinstance(node, IdentNode):
-            return self._eval_ident(node)
-
-        if isinstance(node, CallNode):
-            return self._eval_call(node)
-
-        raise EvaluationError(f"Unknown AST node: {node}")
-
-    # template
-    def _eval_template(self, node: TemplateNode):
-        parts = []
-        for child in node.children:
-            parts.append(self._eval(child))
-        return "".join(parts)
-
-    # identifier
-    def _eval_ident(self, node: IdentNode):
-        name = node.name
-
-        # cycle detection
-        if name in self._seen:
-            raise EvaluationError(f"Cycle detected in identifier '{name}'")
-        self._seen.add(name)
-
-        parts = name.split(".")
-
-        # 1. ctx first
-        val = self._lookup_hierarchical(self.ctx, parts)
-        if val is not None:
-            self._seen.remove(name)
-            return str(val)
-
-        # 2. syntax-bound maps
-        for m in self.layerstack.all_maps():
-            if getattr(m, "__syntax__", None) not in (None, node.syntax):
-                continue
-
-            d = self._map_to_dict(m)
-            val = self._lookup_hierarchical(d, parts)
-            if val is not None:
-                self._seen.remove(name)
-                return str(val)
-
-        self._seen.remove(name)
-        raise EvaluationError(f"Missing key '{name}'")
-
-    # call (nested token)
-    def _eval_call(self, node: CallNode):
-        outer = node.name
-
-        if outer in self._seen:
-            raise EvaluationError(f"Cycle detected in call '{outer}'")
-        self._seen.add(outer)
-
-        arg_value = self._eval(node.arg)
-        parts = [outer, arg_value]
-
-        # ctx first
-        val = self._lookup_hierarchical(self.ctx, parts)
-        if val is not None:
-            self._seen.remove(outer)
-            return str(val)
-
-        # syntax-bound maps
-        for m in self.layerstack.all_maps():
-            if getattr(m, "__syntax__", None) not in (None, node.syntax):
-                continue
-
-            d = self._map_to_dict(m)
-            val = self._lookup_hierarchical(d, parts)
-            if val is not None:
-                self._seen.remove(outer)
-                return str(val)
-
-        self._seen.remove(outer)
-        raise EvaluationError(f"Missing nested key '{outer}({arg_value})'")
-
-    # helpers
-    def _map_to_dict(self, m):
-        if hasattr(m, "as_map"):
-            return m.as_map()
-        if isinstance(m, dict):
-            return m
-        raise EvaluationError(f"Invalid map object: {m}")
-
-    def _lookup_hierarchical(self, root, parts):
-        cur = root
-        for p in parts:
-            if not isinstance(cur, dict):
-                return None
-            if p not in cur:
-                return None
-            cur = cur[p]
-        return cur