mapres 3.dev14__tar.gz → 3.dev15__tar.gz

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

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

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

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

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

@@ -35,7 +35,9 @@ 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'
 
     def as_map(self):
         '''
@@ -47,8 +49,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 in ('__syntax__', '__mode__', '__recursive__', '__missing_key__'):
                 continue
 
             val = getattr(self, f.name)
@@ -63,15 +66,44 @@ 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 = {}
+
+        # dataclass fields on nested class
+        if is_dataclass(cls):
+            dummy = cls()  # assumes no required __init__ args
+            for f in fields(dummy):
+                if not f.init:
+                    continue
+                out[f.name] = getattr(dummy, f.name)
+
+        # nested classes inside nested class
+        for name, obj in cls.__dict__.items():
+            if name.startswith('__'):
+                continue
+            if isinstance(obj, type):
+                out[name] = self._class_to_dict(obj)
+
+        return out
+
 
 # main decorator factory
-def datamap(_cls=None, *, syntax=None, mode=None):
+def datamap(_cls=None, *, syntax=None, mode=None, recursive=None, missing_key=None):
     '''@datamap decorator'''
     def wrap(cls):
         cls.__syntax__ = syntax
         cls.__mode__ = mode
+        cls.__recursive__ = recursive
+        cls.__missing_key__ = missing_key or 'error'
         namespace = dict(cls.__dict__)
         namespace['__dict__'] = {}
         rules_obj = namespace.get('rules', None)

{mapres-3.dev14 → mapres-3.dev15}/src/mapres/evaluator.py

@@ -1,7 +1,10 @@
 from .ast import TemplateNode, TextNode, IdentNode, CallNode
+from .tokenizer import Tokenizer
+from .parser import Parser
+from .exceptions import MapResError, MissingKeyError
 
 
-class EvaluationError(Exception):
+class EvaluationError(MapResError):
     pass
 
 
@@ -29,14 +32,32 @@ class Evaluator:
         if isinstance(node, CallNode):
             return self._eval_call(node)
 
-        raise EvaluationError(f"Unknown AST node: {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)
+        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):
@@ -47,7 +68,7 @@ class Evaluator:
             raise EvaluationError(f"Cycle detected in identifier '{name}'")
         self._seen.add(name)
 
-        parts = name.split(".")
+        parts = name.split('.')
 
         # 1. ctx first
         val = self._lookup_hierarchical(self.ctx, parts)
@@ -57,7 +78,7 @@ class Evaluator:
 
         # 2. syntax-bound maps
         for m in self.layerstack.all_maps():
-            if getattr(m, "__syntax__", None) not in (None, node.syntax):
+            if getattr(m, '__syntax__', None) not in (None, node.syntax):
                 continue
 
             d = self._map_to_dict(m)
@@ -67,7 +88,7 @@ class Evaluator:
                 return str(val)
 
         self._seen.remove(name)
-        raise EvaluationError(f"Missing key '{name}'")
+        raise MissingKeyError(name)
 
     # call (nested token)
     def _eval_call(self, node: CallNode):
@@ -88,7 +109,7 @@ class Evaluator:
 
         # syntax-bound maps
         for m in self.layerstack.all_maps():
-            if getattr(m, "__syntax__", None) not in (None, node.syntax):
+            if getattr(m, '__syntax__', None) not in (None, node.syntax):
                 continue
 
             d = self._map_to_dict(m)
@@ -98,15 +119,15 @@ class Evaluator:
                 return str(val)
 
         self._seen.remove(outer)
-        raise EvaluationError(f"Missing nested key '{outer}({arg_value})'")
+        raise MissingKeyError(f'{outer}({arg_value})')
 
     # helpers
     def _map_to_dict(self, m):
-        if hasattr(m, "as_map"):
+        if hasattr(m, 'as_map'):
             return m.as_map()
         if isinstance(m, dict):
             return m
-        raise EvaluationError(f"Invalid map object: {m}")
+        raise EvaluationError(f'Invalid map object: {m}')
 
     def _lookup_hierarchical(self, root, parts):
         cur = root
@@ -117,3 +138,22 @@ class Evaluator:
                 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)

{mapres-3.dev14 → mapres-3.dev15}/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.dev15}/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.dev15}/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.dev15/src/mapres.egg-info}/PKG-INFO

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