mapres 3.dev15__tar.gz → 3.dev17__tar.gz

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

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

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

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

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

@@ -38,6 +38,7 @@ class DataMap:
     __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):
         '''
@@ -51,7 +52,7 @@ class DataMap:
 
         # dataclass fields
         for f in fields(self):
-            if not f.init or f.name in ('__syntax__', '__mode__', '__recursive__', '__missing_key__'):
+            if not f.init or f.name.startswith('__'):
                 continue
 
             val = getattr(self, f.name)
@@ -78,15 +79,13 @@ class DataMap:
     def _class_to_dict(self, cls):
         out = {}
 
-        # dataclass fields on nested class
         if is_dataclass(cls):
-            dummy = cls()  # assumes no required __init__ args
+            dummy = cls()
             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
@@ -96,23 +95,30 @@ class DataMap:
         return out
 
 
-# main decorator factory
-def datamap(_cls=None, *, syntax=None, mode=None, recursive=None, missing_key=None):
-    '''@datamap decorator'''
+def datamap(_cls=None, *, syntax=None, mode=None, recursive=None,
+            missing_key=None, ignore_delimiters=None):
+
     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
 
 
@@ -130,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)
@@ -164,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.dev15 → mapres-3.dev17}/src/mapres/evaluator.py

@@ -63,6 +63,10 @@ class Evaluator:
     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}'")
@@ -94,6 +98,11 @@ class Evaluator:
     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)
@@ -141,7 +150,7 @@ class Evaluator:
 
     def _has_recursive_maps(self):
         for m in self.layerstack.all_maps():
-            if getattr(m, '__recursive__', False):
+            if getattr(m, '__recursive__', False) is True:
                 return True
         return False
 
@@ -149,7 +158,7 @@ class Evaluator:
         depths = [
             getattr(m, '__max_depth__', 10)
             for m in self.layerstack.all_maps()
-            if getattr(m, '__recursive__', False)
+            if getattr(m, '__recursive__', False) is True
         ]
         return max(depths) if depths else 0
 
@@ -157,3 +166,56 @@ class Evaluator:
         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.dev15 → mapres-3.dev17/src/mapres.egg-info}/PKG-INFO

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