mapres 3a1__tar.gz → 3a2__tar.gz

{mapres-3a1/src/mapres.egg-info → mapres-3a2}/PKG-INFO

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

{mapres-3a1 → mapres-3a2}/pyproject.toml

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

{mapres-3a1 → mapres-3a2}/src/mapres/datamap.py

@@ -35,7 +35,7 @@ class DataMap:
     '''
     __syntax__: str = None
     __mode__: str | None = None  # 'dynamic', 'config', 'callable', or None
-    __missing_key__: str = 'error'  # 'error', 'silent', 'placeholder'
+    __missing_key__: str = 'error'  # 'error', 'silent', 'placeholder', or 'raw'
     __recursive__: bool = False
     __max_depth__: int = 10
 

{mapres-3a1 → mapres-3a2}/src/mapres/evaluator.py

@@ -9,10 +9,20 @@ class EvaluationError(MapResError):
 
 
 class Evaluator:
-    def __init__(self, layerstack, ctx=None):
+    def __init__(self, layerstack, ctx=None, missing_key_mode: str = 'error'):
+        '''
+        layerstack: LayerStack instance
+        ctx:        dict used as highest-priority map
+        missing_key_mode:
+            - 'error'       → raise MissingKeyError
+            - 'silent'      → return raw token unchanged
+            - 'placeholder' → return <missing:key>
+            - 'raw'         → return raw token unchanged (alias of 'silent' at token level)
+        '''
         self.layerstack = layerstack
         self.ctx = ctx or {}
         self._seen = set()  # cycle detection
+        self.missing_key_mode = missing_key_mode
 
     # public api
     def evaluate(self, node):
@@ -33,14 +43,13 @@ class Evaluator:
             return self._eval_call(node)
 
         raise EvaluationError(f'Unknown AST node: {node}')
-    
+
     # re-resolve
     def _re_resolve(self, text: str) -> str:
         tokens = Tokenizer(text).tokenize()
         ast = Parser(tokens).parse()
         return self.evaluate(ast)
 
-
     # template
     def _eval_template(self, node: TemplateNode):
         parts = []
@@ -48,34 +57,26 @@ class Evaluator:
             parts.append(self._eval(child))
         out = ''.join(parts)
 
-        # ---------------------------------------
-        # PER-MAP RECURSION (syntax-scoped)
-        # ---------------------------------------
-        # Find all maps in the layerstack that have recursive=True
+        # per-map recursion (syntax-scoped)
         recursive_maps = [
             m for m in self.layerstack.all_maps()
             if getattr(m, '__recursive__', False) is True
         ]
 
-        # If no maps are recursive, return the first-pass output
         if not recursive_maps:
             return out
 
-        # Determine max recursion depth across all recursive maps
         max_depth = max(getattr(m, '__max_depth__', 10) for m in recursive_maps)
 
         seen = set()
         depth = 0
 
         while depth < max_depth:
-            # Re-tokenize and re-evaluate the ENTIRE output string
             new_out = self._re_resolve(out)
 
-            # If stable, stop recursion
             if new_out == out:
                 break
 
-            # Cycle detection
             if new_out in seen:
                 raise EvaluationError('Cycle detected in recursive map resolution')
 
@@ -91,7 +92,7 @@ class Evaluator:
 
         # cycle detection
         if name in self._seen:
-            raise EvaluationError(f"Cycle detected in identifier '{name}'")
+            raise EvaluationError(f'Cycle detected in identifier \'{name}\'')
         self._seen.add(name)
 
         parts = name.split('.')
@@ -114,14 +115,14 @@ class Evaluator:
                 return str(val)
 
         self._seen.remove(name)
-        raise MissingKeyError(name)
+        return self._handle_missing_ident(node)
 
     # 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}'")
+            raise EvaluationError(f'Cycle detected in call \'{outer}\'')
         self._seen.add(outer)
 
         arg_value = self._eval(node.arg)
@@ -145,7 +146,7 @@ class Evaluator:
                 return str(val)
 
         self._seen.remove(outer)
-        raise MissingKeyError(f'{outer}({arg_value})')
+        return self._handle_missing_call(node, arg_value)
 
     # helpers
     def _map_to_dict(self, m):
@@ -164,3 +165,48 @@ class Evaluator:
                 return None
             cur = cur[p]
         return cur
+
+    # missing-key handling (token-level)
+    def _delims_for_syntax(self, syntax_name: str):
+        table = {
+            'angles': ('<', '>'),
+            'braces': ('{{', '}}'),
+            'dollars': ('${', '}'),
+            'percents': ('%', '%'),
+            'pipes': ('|', '|'),
+            'colons': (':', ':'),
+        }
+        return table.get(syntax_name, ('<', '>'))
+
+    def _handle_missing_ident(self, node: IdentNode):
+        name = node.name
+        open_, close_ = self._delims_for_syntax(node.syntax)
+        raw_token = f'{open_}{name}{close_}'
+
+        mode = self.missing_key_mode or 'error'
+
+        if mode in ('silent', 'raw'):
+            # token-level fallback: leave the unresolved token as-is
+            return raw_token
+
+        if mode == 'placeholder':
+            return f'<missing:{name}>'
+
+        # default: error
+        raise MissingKeyError(name, token=raw_token)
+
+    def _handle_missing_call(self, node: CallNode, arg_value: str):
+        outer = node.name
+        open_, close_ = self._delims_for_syntax(node.syntax)
+        raw_token = f'{open_}{outer}({arg_value}){close_}'
+        key_repr = f'{outer}({arg_value})'
+
+        mode = self.missing_key_mode or 'error'
+
+        if mode in ('silent', 'raw'):
+            return raw_token
+
+        if mode == 'placeholder':
+            return f'<missing:{key_repr}>'
+
+        raise MissingKeyError(key_repr, token=raw_token)

mapres-3a2/src/mapres/exceptions.py

@@ -0,0 +1,8 @@
+class MapResError(Exception):
+    pass
+
+class MissingKeyError(MapResError):
+    def __init__(self, key: str, token: str | None = None):
+        super().__init__(f"Missing key {key!r}")
+        self.key = key
+        self.token = token or key

{mapres-3a1 → mapres-3a2}/src/mapres/resolver.py

@@ -3,12 +3,12 @@ from .parser import Parser
 from .evaluator import Evaluator
 from .layers import LayerStack
 from .cache import LRUCache
-from .exceptions import MapResError, MissingKeyError
+from .exceptions import MapResError
 
 
 class MapResolver:
-    """
-    New AST-based resolver for mapres.
+    '''
+    AST-based resolver for mapres.
 
     Pipeline:
         tokenize → parse → evaluate → return string
@@ -19,37 +19,44 @@ class MapResolver:
         - multiple map layers
         - ctx fallback
         - caching (optional)
-    """
+        - per-map missing-key modes via __missing_key__
+    '''
 
-    def __init__(self, layers=None, cache=False, cache_size=1024):
+    def __init__(self, layers=None, cache: bool = False, cache_size: int = 1024):
         self.layers = layers or LayerStack()
         self.cache_enabled = cache
         self.cache = LRUCache(cache_size) if cache else None
 
-    # ---------------------------------------
-    # PUBLIC API
-    # ---------------------------------------
+    # public api
     def res(self, text: str, *, extra_maps=None, override_maps=None, **ctx) -> str:
-        """
+        '''
         Resolve a template string using:
             - tokenizer
             - parser
             - evaluator
             - layerstack
             - ctx
-        """
+
+        Missing-key behavior is controlled by:
+            - datamap.__missing_key__ on any map in the layerstack
+              ('error', 'silent', 'placeholder', 'raw')
+        '''
 
         try:
             # caching
+            cache_key = None
             if self.cache_enabled:
-                key = (text, tuple(sorted(ctx.items())))
-                cached = self.cache.get(key)
+                cache_key = (text, tuple(sorted(ctx.items())))
+                cached = self.cache.get(cache_key)
                 if cached is not None:
                     return cached
 
             # build working layerstack
             layerstack = self._build_layerstack(extra_maps, override_maps)
 
+            # determine missing-key mode
+            missing_mode = self._resolve_missing_key_mode(layerstack)
+
             # tokenize
             tokens = Tokenizer(text).tokenize()
 
@@ -57,38 +64,32 @@ class MapResolver:
             ast = Parser(tokens).parse()
 
             # evaluate
-            result = Evaluator(layerstack, ctx).evaluate(ast)
+            evaluator = Evaluator(layerstack, ctx, missing_key_mode=missing_mode)
+            result = evaluator.evaluate(ast)
 
             # store cache
-            if self.cache_enabled:
-                self.cache.set(key, result)
+            if self.cache_enabled and cache_key is not None:
+                self.cache.set(cache_key, result)
 
             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 MapResError as exc:
+            # propagate MapResError as-is
+            raise
 
         except Exception as exc:
+            # wrap any other exception
             raise MapResError(f'Resolver error: {exc}') from exc
 
-    # ---------------------------------------
-    # LAYERSTACK BUILDING
-    # ---------------------------------------
+    # layerstack building
     def _build_layerstack(self, extra_maps, override_maps):
-        """
+        '''
         Build a temporary layerstack for this resolution call.
         Supports:
             - override maps (priority 0)
             - extra maps (priority 999)
             - normal layers (existing priorities)
-        """
+        '''
 
         if override_maps is not None:
             temp = LayerStack()
@@ -102,18 +103,21 @@ class MapResolver:
 
         return self.layers
 
-    def _resolve_missing_key_mode(self):
-        for m in self.layers.all_maps():
+    def _resolve_missing_key_mode(self, layerstack: LayerStack) -> str:
+        '''
+        Determine missing-key mode from maps in the given layerstack.
+
+        First map that defines __missing_key__ wins.
+        Defaults to 'error' if none are set.
+        '''
+        for m in layerstack.all_maps():
             mode = getattr(m, '__missing_key__', None)
             if mode is not None:
                 return mode
         return 'error'
 
 
-# ---------------------------------------
-# SIMPLE GLOBAL USAGE
-# ---------------------------------------
-
+# simple global usage
 _DEFAULT_RESOLVER = MapResolver()
 
 def setGlobalMaps(*maps, priority=0):
@@ -146,11 +150,11 @@ def setGlobalMaps(*maps, priority=0):
 
 
 def res(text: str, **ctx) -> str:
-    '''Simple global resolution'''
+    '''Simple global resolution.'''
     return _DEFAULT_RESOLVER.res(text, **ctx)
 
 def rprint(text: str, sep, end, file, flush, **ctx) -> None:
-    '''Simple global resolution and print'''
+    '''Simple global resolution and print.'''
     print(res(text, **ctx), sep=sep, end=end, file=file, flush=flush)
 
 res.setGlobalMaps = setGlobalMaps

{mapres-3a1 → mapres-3a2/src/mapres.egg-info}/PKG-INFO

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

mapres-3a1/src/mapres/exceptions.py

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