mapres 3.dev14__py3-none-any.whl → 3.dev16__py3-none-any.whl

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/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,25 +32,47 @@ 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):
         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(".")
+        parts = name.split('.')
 
         # 1. ctx first
         val = self._lookup_hierarchical(self.ctx, parts)
@@ -57,7 +82,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,12 +92,17 @@ 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):
         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)
@@ -88,7 +118,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 +128,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 +147,75 @@ 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)
+
+    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/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/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/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.dist-info → mapres-3.dev16.dist-info}/METADATA

@@ -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.dev16.dist-info/RECORD

@@ -0,0 +1,18 @@
+mapres/__init__.py,sha256=t23ofM-wzpPByYi1rEQonxyU1yyza4ZzwwHDZUa5QqA,1010
+mapres/ast.py,sha256=6PcMkwtNHYD8xEkdyzDgn_mRTj1ZaWSyuHZK3BtXiuo,427
+mapres/cache.py,sha256=hbvsoc6Qw3RhWAEfOOpKHtC7i9EomoUgWzyd4dnH71w,333
+mapres/datamap.py,sha256=v9DAIYaS-vkBU1BKmshGYnquZa2JPwcct661zaEFocs,5256
+mapres/evaluator.py,sha256=ElKliQ4z0vSTFHtbTxSafRBVrPpksjqFjq5spKKEFwI,6962
+mapres/exceptions.py,sha256=D2XKnrMkZDyUXQt2PmaKbj08FObWU00yXKGHwNpjvww,222
+mapres/layers.py,sha256=sFc1eUOBg2BoB2cBXIleq8RMYcg5GZpUoCnGh-uKN6U,1380
+mapres/parser.py,sha256=8XLCzYosvh81bN-Jddc1AM4w0X7bsHnBzmA8sq5_72w,4018
+mapres/resolver.py,sha256=kQexTdBnPy70Azh_U6--hwUtnIJjoKcuaJ2KlBaG3Rg,3889
+mapres/tokenizer.py,sha256=js0S1s8MkltdQoH5V1cLjdY0fFqZoGqmtP_OhEJEM6M,6539
+mapres/maps/__init__.py,sha256=lIRRfem1Fw4iynuwUQ7BY5qrC4fbJKxqLivao2_Dtm4,239
+mapres/maps/color.py,sha256=noRTGFNo9xLl5YEhX0tttV6i_oDAiptXmRVnkr5EzwM,1348
+mapres/maps/time.py,sha256=TyncycYoIGVZWps32qWlFy2a2hTayvZWVHu9uh2nid8,2050
+mapres-3.dev16.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+mapres-3.dev16.dist-info/METADATA,sha256=KHiZBTclH89lWV6Kr85_SIuH3igO8i6fm6tarBaD0lE,1476
+mapres-3.dev16.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mapres-3.dev16.dist-info/top_level.txt,sha256=5LMVQqJdtyjxfzv7wJBOZ-360m0Yc79w_-Y7s3n6cTw,7
+mapres-3.dev16.dist-info/RECORD,,

mapres-3.dev14.dist-info/RECORD

@@ -1,18 +0,0 @@
-mapres/__init__.py,sha256=t23ofM-wzpPByYi1rEQonxyU1yyza4ZzwwHDZUa5QqA,1010
-mapres/ast.py,sha256=6PcMkwtNHYD8xEkdyzDgn_mRTj1ZaWSyuHZK3BtXiuo,427
-mapres/cache.py,sha256=hbvsoc6Qw3RhWAEfOOpKHtC7i9EomoUgWzyd4dnH71w,333
-mapres/datamap.py,sha256=0kfxBSAaIXwT8srkcurPbXBbbpmc_HbAzL-iJ45pKNc,4439
-mapres/evaluator.py,sha256=YZ4SUTMM1XhcxH1Skm2J4QSP6_P79TfuQn33cCekRsI,3348
-mapres/exceptions.py,sha256=jirHKK5yCffSCWWkgZY_gTSIOaFCmXOe5NJJf60HeeQ,130
-mapres/layers.py,sha256=sFc1eUOBg2BoB2cBXIleq8RMYcg5GZpUoCnGh-uKN6U,1380
-mapres/parser.py,sha256=8XLCzYosvh81bN-Jddc1AM4w0X7bsHnBzmA8sq5_72w,4018
-mapres/resolver.py,sha256=7N2M-6_6NCiBBxHCNFOjKoU0E3Ntgb8o_3gA00HsKU4,3247
-mapres/tokenizer.py,sha256=WvLHVb3x2QA70oyrC2Gd_oNOXj9VIMVGuVS-Ew11RW0,5344
-mapres/maps/__init__.py,sha256=lIRRfem1Fw4iynuwUQ7BY5qrC4fbJKxqLivao2_Dtm4,239
-mapres/maps/color.py,sha256=noRTGFNo9xLl5YEhX0tttV6i_oDAiptXmRVnkr5EzwM,1348
-mapres/maps/time.py,sha256=TyncycYoIGVZWps32qWlFy2a2hTayvZWVHu9uh2nid8,2050
-mapres-3.dev14.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-mapres-3.dev14.dist-info/METADATA,sha256=ks3M9DeKQwoDUXQue1vG-pQ5notahc_u0cDV8eYIZaM,1476
-mapres-3.dev14.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-mapres-3.dev14.dist-info/top_level.txt,sha256=5LMVQqJdtyjxfzv7wJBOZ-360m0Yc79w_-Y7s3n6cTw,7
-mapres-3.dev14.dist-info/RECORD,,