mapres 2.4.dev6__py3-none-any.whl → 3.dev1__py3-none-any.whl

mapres/__init__.py

@@ -7,7 +7,7 @@ try:
 except PackageNotFoundError:
     __version__ = '0.0.0'
 
-from .resolver import MapResolver, res, setGlobalMaps
+from .resolver import MapResolver, res, setGlobalMaps, setDefaultPasses
 from .datamap import DataMap, datamap, syntax
 from .layers import Layer, LayerStack
 
@@ -38,6 +38,7 @@ __all__ = [
     'Layer',
     'LayerStack',
     'setGlobalMaps',
+    'setDefaultPasses',
 
     # maps
     'ColorMap',

mapres/ast.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class Node:
+    pass
+
+
+@dataclass
+class TextNode(Node):
+    text: str
+
+
+@dataclass
+class IdentNode(Node):
+    name: str  # supports dots: server.status.online
+
+
+@dataclass
+class CallNode(Node):
+    name: str          # outer identifier
+    arg: Node          # single argument (Template fragment)
+    syntax: str        # which delimiter type produced it (colon/brace/etc)

mapres/datamap.py

@@ -1,64 +1,129 @@
 import re
 from dataclasses import dataclass, fields, is_dataclass
 
+# syntax identifiers
 class syntax:
-    braces   = r'\{([^{}]+)\}'
-    dollars  = r'\$\{([^{}]+)\}'
-    angles   = r'<([^<>]+)>'
-    percents = r'%([^%]+)%'
+    braces         = 'braces'           # {{value}}
+    dollars        = 'dollars'          # ${value}
+    angles         = 'angles'           # <value>
+    percents       = 'percents'         # %value%
+    pipes          = 'pipes'            # |value|
+    colons         = 'colons'           # :value:
+    at_tags        = 'at_tags'          # @value@
+    hash_tags      = 'hash_tags'        # #value#
+    paren_dollars  = 'paren_dollars'    # $(value)
 
 
+# base datamap class
 @dataclass
 class DataMap:
-    '''Core datamap class. Contains logic used to make datamaps'''
-    __syntax__: str = syntax.braces
-    __mode__: str | None = None
+    '''
+    Core datamap class for mapres 3.
+
+    Responsibilities:
+        - hold fields
+        - optionally evaluate dynamic providers
+        - return a dict via as_map()
+
+    Syntax metadata (__syntax__) determines which delimiters
+    this map responds to (angle, brace, colon, percent, pipe, etc).
+    '''
+    __syntax__: str = None
+    __mode__: str | None = None  # "dynamic", "config", or None
 
     def as_map(self):
+        '''
+        Convert datamap fields into a dictionary.
+        If mode='dynamic', evaluate provider functions.
+        '''
         result = {}
+
         for f in fields(self):
             if not f.init or f.name in ('__syntax__', '__mode__'):
                 continue
+
             val = getattr(self, f.name)
+
+            # dynamic provider support
             if self.__mode__ == 'dynamic':
                 providers = getattr(self, 'providers', None)
                 if isinstance(providers, dict) and f.name in providers:
                     val = providers[f.name]
                 if callable(val):
                     val = val()
+
             result[f.name] = val
+
         return result
 
-    @classmethod
-    def get_syntax(cls):
-        return getattr(cls, '__syntax__', syntax.braces)
 
+# main decorator factory
+def datamap(_cls=None, *, syntax=None, mode=None):
+    '''
+    @datamap decorator.
 
-# decorator
-def datamap(
-    _cls = None,
-    *,
-    syntax: str = syntax.braces,
-    mode: bool | str | None = None,
-):
-    '''@datamap decorator with optional values'''
+    Supports:
+        @datamap
+        @datamap(mode='dynamic')
+        @datamap(syntax='angle')
+        @datamap(syntax='angle', mode='config')
+    '''
     def wrap(cls):
         cls.__syntax__ = syntax
         cls.__mode__ = mode
         namespace = dict(cls.__dict__)
         namespace['__dict__'] = {}
-        # preserve any rules class defined in the original namespace by attaching it to the generated class
         rules_obj = namespace.get('rules', None)
         cls = type(cls.__name__, (DataMap,), namespace)
-        # attach rules (if present) to the new class so validators can read them via the datamap class
         if rules_obj is not None:
             setattr(cls, 'rules', rules_obj)
         return dataclass(frozen=False)(cls)
-    return wrap if _cls is None else wrap(_cls)
+    if _cls is not None:
+        return wrap(_cls)
+    return wrap
+
+
+# syntax-bound decorator factories
+class _SyntaxFactory:
+    '''
+    Allows:
+        @datamap.angles
+        @datamap.angles(mode='config')
+        @datamap.angles.config
+    '''
+    def __init__(self, syntax_name):
+        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):
+        return datamap(syntax=self._syntax, mode='dynamic')
+
+
+
+# build syntax shortcuts
+datamap.braces      = _SyntaxFactory(syntax.braces)
 
+datamap.dollars     = _SyntaxFactory(syntax.dollars)
+datamap.angles      = _SyntaxFactory(syntax.angles)
+datamap.percents    = _SyntaxFactory(syntax.percents)
+datamap.pipes   = _SyntaxFactory(syntax.pipes)
+datamap.colons      = _SyntaxFactory(syntax.colons)
+datamap.at_tags     = _SyntaxFactory(syntax.at_tags)
+datamap.hash_tags   = _SyntaxFactory(syntax.hash_tags)
+datamap.paren_dollars = _SyntaxFactory(syntax.paren_dollars)
 
-# decorator shortcuts
-datamap.braces = datamap(syntax=syntax.braces)
-datamap.angles = datamap(syntax=syntax.angles)
-datamap.dollars = datamap(syntax=syntax.dollars)
-datamap.percents = datamap(syntax=syntax.percents)
+# global mode shortcut
+datamap.config = datamap(mode='config')

mapres/evaluator.py

@@ -0,0 +1,131 @@
+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

mapres/layers.py

@@ -1,7 +1,12 @@
+# layers.py
+
 class Layer:
-    '''Holds a map with a priority'''
-    def __init__(self, name, maps=None, priority=0):
-        self.name = name
+    """
+    A single layer containing one or more maps.
+    Priority determines resolution order.
+    Lower priority = earlier lookup.
+    """
+    def __init__(self, maps=None, priority=0):
         self.maps = maps or []
         self.priority = priority
 
@@ -13,31 +18,39 @@ class Layer:
 
 
 class LayerStack:
-    '''Manages ordered layers'''
-    def __init__(self, layers=None):
-        self.layers = {}
-        if layers:
-            for layer in layers:
-                self.layers[layer.name] = layer
-
-    def add_layer(self, layer):
-        self.layers[layer.name] = layer
-
-    def remove_layer(self, name):
-        if name in self.layers:
-            del self.layers[name]
-
-    def get_layer(self, name):
-        return self.layers.get(name)
-
-    def clone(self):
-        return LayerStack(list(self.layers.values()))
+    """
+    A simple ordered list of layers.
+    No names, no dicts, no complexity.
+    Just priority-sorted layers.
+    """
+    def __init__(self):
+        self.layers = []  # list of Layer objects
+
+    def add_layer(self, maps, priority=0):
+        """
+        Add a new layer containing one or more maps.
+        maps: datamap instance, datamap class, or dict
+        priority: lower = earlier lookup
+        """
+        layer = Layer(
+            maps=[maps] if not isinstance(maps, list) else maps,
+            priority=priority
+        )
+        self.layers.append(layer)
+        self.layers.sort(key=lambda l: l.priority)
 
     def all_maps(self):
-        ordered = sorted(self.layers.values(), key=lambda l: l.priority)
-        for layer in ordered:
+        """
+        Yield all maps in priority order.
+        """
+        for layer in self.layers:
             for m in layer:
                 yield m
 
-    def __iter__(self):
-        return self.all_maps()
+    def clone(self):
+        """
+        Return a shallow copy of the layerstack.
+        """
+        new = LayerStack()
+        new.layers = list(self.layers)
+        return new

mapres/maps/color.py

@@ -1,6 +1,6 @@
-from mapres.datamap import datamap, syntax
+from mapres.datamap import datamap
 
-@datamap(syntax=syntax.angles) # produces <>
+@datamap.angles
 class ColorMap:
     black: str = '\033[30m'
     dark_blue: str = '\033[34m'
@@ -22,13 +22,8 @@ class ColorMap:
     bold: str = '\033[1m'
     italic: str = '\033[3m'
 
-    def as_dict(self):
-        return {f'<{k}>': getattr(self, k) for k in self.__dataclass_fields__}
-
-# ASCII color map
 ascii_colors = ColorMap()
 
-# Minecraft color map
 mc_colors = ColorMap(
     black='§0',
     dark_blue='§1',
@@ -51,7 +46,6 @@ mc_colors = ColorMap(
     italic='§o'
 )
 
-# Color strip map
 strip_colors = ColorMap(
     black='',
     dark_blue='',
@@ -72,4 +66,4 @@ strip_colors = ColorMap(
     reset='',
     bold='',
     italic=''
-)
+)

mapres/maps/time.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timezone
 from zoneinfo import ZoneInfo
-from mapres.datamap import datamap, syntax
+from mapres.datamap import datamap
 
 
 def safe_zoneinfo(tz: str):
@@ -10,7 +10,7 @@ def safe_zoneinfo(tz: str):
         return timezone.utc
 
 
-@datamap(syntax=syntax.percents, mode='dynamic')
+@datamap.percents.dynamic
 class TimeMap:
     _default_tz = safe_zoneinfo("America/Chicago")
 

mapres/parser.py

@@ -0,0 +1,105 @@
+from tokenizer import TokenType, Token
+from ast import TemplateNode, TextNode, IdentNode, CallNode
+
+
+class ParserError(Exception):
+    pass
+
+
+class Parser:
+    def __init__(self, tokens: list[Token]):
+        self.tokens = tokens
+        self.i = 0
+        self.n = len(tokens)
+
+    def peek(self, k=0) -> Token | None:
+        idx = self.i + k
+        return self.tokens[idx] if idx < self.n else None
+
+    def advance(self, k=1):
+        self.i += k
+
+    def expect(self, type_: TokenType):
+        tok = self.peek()
+        if tok is None or tok.type != type_:
+            raise ParserError(f"Expected {type_}, got {tok}")
+        self.advance()
+        return tok
+
+    def parse(self) -> TemplateNode:
+        children = []
+        while self.peek() is not None:
+            tok = self.peek()
+            if tok.type is TokenType.TEXT:
+                children.append(TextNode(tok.value))
+                self.advance()
+            else:
+                children.append(self.parse_token())
+        return TemplateNode(children)
+
+    def parse_token(self) -> Node:
+        tok = self.peek()
+
+        if tok.type is TokenType.COLON_OPEN:
+            return self.parse_colon_token()
+
+        if tok.type is TokenType.BRACE_OPEN:
+            return self.parse_brace_token()
+
+        if tok.type is TokenType.DOLLAR_OPEN:
+            return self.parse_dollar_token()
+
+        if tok.type is TokenType.ANGLE_OPEN:
+            return self.parse_angle_token()
+
+        if tok.type is TokenType.PIPE_OPEN:
+            return self.parse_pipe_token()
+
+        if tok.type is TokenType.PERCENT_OPEN:
+            return self.parse_percent_token()
+
+        raise ParserError(f"Unexpected token {tok}")
+
+    # --- core pattern: IDENT or IDENT(arg) ---
+
+    def _parse_ident_or_call(self, closing_type, syntax_name: str) -> Node:
+        ident_tok = self.expect(TokenType.IDENT)
+        name = ident_tok.value
+
+        # single-argument nested form: IDENT LPAREN Template RPAREN
+        if self.peek() and self.peek().type is TokenType.LPAREN:
+            self.advance()  # consume '('
+            arg = self.parse()  # nested Template
+            self.expect(TokenType.RPAREN)
+            self.expect(closing_type)
+            return CallNode(name=name, arg=arg, syntax=syntax_name)
+
+        # simple identifier: IDENT
+        self.expect(closing_type)
+        return IdentNode(name=name)
+
+    # --- syntax-bound token handlers ---
+
+    def parse_colon_token(self) -> Node:
+        self.expect(TokenType.COLON_OPEN)
+        return self._parse_ident_or_call(TokenType.COLON_CLOSE, "colons")
+
+    def parse_brace_token(self) -> Node:
+        self.expect(TokenType.BRACE_OPEN)
+        return self._parse_ident_or_call(TokenType.BRACE_CLOSE, "braces")
+
+    def parse_dollar_token(self) -> Node:
+        self.expect(TokenType.DOLLAR_OPEN)
+        return self._parse_ident_or_call(TokenType.DOLLAR_CLOSE, "dollars")
+
+    def parse_angle_token(self) -> Node:
+        self.expect(TokenType.ANGLE_OPEN)
+        return self._parse_ident_or_call(TokenType.ANGLE_CLOSE, "angles")
+
+    def parse_pipe_token(self) -> Node:
+        self.expect(TokenType.PIPE_OPEN)
+        return self._parse_ident_or_call(TokenType.PIPE_CLOSE, "pipes")
+
+    def parse_percent_token(self) -> Node:
+        self.expect(TokenType.PERCENT_OPEN)
+        return self._parse_ident_or_call(TokenType.PERCENT_CLOSE, "percents")

mapres/resolver.py

@@ -1,174 +1,45 @@
-import re
-from .datamap import DataMap, syntax
+from .tokenizer import Tokenizer
+from .parser import Parser
+from .evaluator import Evaluator
+from .layers import LayerStack
 from .cache import LRUCache
-from .layers import Layer, LayerStack
-from .exceptions import MapResError, MissingKeyError, MapSyntaxError
+from .exceptions import MapResError
 
 
 class MapResolver:
-    '''
-    Core resolution engine for mapres.
-
-    Handles:
-    - pipeline stages
-    - syntax providers
-    - layered maps
-    - context substitution
-    - multi-pass resolution (controlled by `passes`)
-    - optional caching
-    '''
-    def __init__(
-        self,
-        layers: list | None = None,
-        syntax: list | None = None,
-        pipeline: list | None = None,
-        cache: bool = False,
-        cache_size: int = 1024,
-        passes_default: int = 5
-    ):
+    """
+    New AST-based resolver for mapres.
+
+    Pipeline:
+        tokenize → parse → evaluate → return string
+
+    Supports:
+        - hierarchical identifiers
+        - nested tokens (single argument)
+        - multiple map layers
+        - ctx fallback
+        - caching (optional)
+    """
+
+    def __init__(self, layers=None, cache=False, cache_size=1024):
         self.layers = layers or LayerStack()
-        self.syntax = syntax or []
-        self.pipeline = pipeline or []
         self.cache_enabled = cache
         self.cache = LRUCache(cache_size) if cache else None
 
-        # unified recursion control
-        self.passes_default = passes_default
+    # ---------------------------------------
+    # 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
+        """
 
-    # pipeline
-    def _apply_pipeline(self, text: str, ctx: dict) -> str:
         try:
-            for stage in self.pipeline:
-                text = stage(text, ctx, self)
-            return text
-        except Exception as exc:
-            raise MapResError(f'Pipeline stage failed: {exc}') from exc
-
-    # syntax providers
-    def _apply_syntax(self, text: str, ctx: dict) -> str:
-        for provider in self.syntax:
-            pattern = provider.pattern
-            d = provider.get_map(ctx, self)
-
-            def repl(match: re.Match) -> str:
-                k = match.group(1)
-                if k not in d:
-                    raise MissingKeyError(f'Missing key "{k}" in syntax provider {provider}')
-                return str(d[k])
-
-            try:
-                text = re.sub(pattern, repl, text)
-            except re.error as exc:
-                raise MapSyntaxError(
-                    f'Regex error in syntax provider {provider}: {exc}'
-                ) from exc
-
-        return text
-
-    # layered maps
-    def _apply_maps(self, text: str, ctx: dict, layerstack: LayerStack):
-        syntax_patterns = []
-
-        for m in layerstack:
-            if isinstance(m, type) and hasattr(m, 'as_map'):
-                m = m()
-            if hasattr(m, 'as_map'):
-                syntax_patterns.append(m.get_syntax())
-            elif isinstance(m, dict):
-                pattern = ctx.get('syntax')
-                if pattern:
-                    syntax_patterns.append(pattern)
-
-        syntax_patterns = list(dict.fromkeys(syntax_patterns))
-
-        for pattern in syntax_patterns:
-            def repl(match: re.Match):
-                k = match.group(1)
-
-                for m in layerstack:
-                    layer = m
-                    if isinstance(layer, type) and hasattr(layer, 'as_map'):
-                        layer = layer()
-                    if hasattr(layer, 'as_map'):
-                        d = layer.as_map()
-                    elif isinstance(layer, dict):
-                        d = layer
-                    else:
-                        continue
-
-                    if k in d:
-                        return str(d[k])
-
-                if k in ctx:
-                    return str(ctx[k])
-
-                raise MissingKeyError(f'Missing key "{k}" in any layer or context')
-
-            try:
-                text = re.sub(pattern, repl, text)
-            except re.error as exc:
-                raise MapSyntaxError(f'Regex error in syntax pattern {pattern}: {exc}') from exc
-
-        return text
-
-    # context
-    def _apply_ctx(self, text: str, ctx: dict) -> str:
-        if not ctx:
-            return text
-
-        pattern = syntax.braces
-        d = ctx
-
-        def repl(match: re.Match) -> str:
-            k = match.group(1)
-            if k not in d:
-                raise MissingKeyError(f'Missing ctx key "{k}"')
-            return str(d[k])
-
-        try:
-            return re.sub(pattern, repl, text)
-        except re.error as exc:
-            raise MapSyntaxError(f'Regex error in ctx syntax: {exc}') from exc
-
-    # one pass
-    def _resolve_once(self, text: str, ctx: dict, layerstack: LayerStack) -> str:
-        text = self._apply_pipeline(text, ctx)
-        text = self._apply_syntax(text, ctx)
-        text = self._apply_maps(text, ctx, layerstack)
-        text = self._apply_ctx(text, ctx)
-        return text
-
-    # public api
-    def res(
-        self,
-        text: str,
-        *,
-        passes: int | None = None,
-        extra_maps: dict | None = None,
-        override_maps: dict | None = None,
-        **ctx
-    ) -> str:
-        '''
-        Resolve a string using maps, syntax providers, pipeline, and context.
-        '''
-        try:
-            # determine number of passes
-            depth = passes if passes is not None else self.passes_default
-
-            if depth <= 0:
-                raise MapResError("passes must be >= 1")
-
-            # override maps
-            if override_maps is not None:
-                temp = LayerStack([Layer('override', override_maps, priority=0)])
-                return self._resolve_once(text, ctx, temp)
-
-            # extra maps
-            if extra_maps:
-                temp = self.layers.clone()
-                temp.add_layer(Layer('extra', extra_maps, priority=999))
-                return self._resolve_once(text, ctx, temp)
-
             # caching
             if self.cache_enabled:
                 key = (text, tuple(sorted(ctx.items())))
@@ -176,44 +47,67 @@ class MapResolver:
                 if cached is not None:
                     return cached
 
-            # multi-pass resolution
-            current = text
-            for _ in range(depth):
-                new = self._resolve_once(current, ctx, self.layers)
-                if new == current:
-                    break
-                current = new
+            # build working layerstack
+            layerstack = self._build_layerstack(extra_maps, override_maps)
+
+            # tokenize
+            tokens = Tokenizer(text).tokenize()
 
-            result = current
+            # parse
+            ast = Parser(tokens).parse()
 
+            # evaluate
+            result = Evaluator(layerstack, ctx).evaluate(ast)
+
+            # store cache
             if self.cache_enabled:
                 self.cache.set(key, result)
 
             return result
 
-        except MapResError:
-            raise
         except Exception as exc:
-            raise MapResError(f'Unhandled resolver error: {exc}') from exc
+            raise MapResError(f"Resolver error: {exc}") from exc
+
+    # ---------------------------------------
+    # 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()
+            temp.add_layer(override_maps, priority=0)
+            return temp
 
-# global resolver
-_DEFAULT = MapResolver()
+        if extra_maps is not None:
+            temp = self.layers.clone()
+            temp.add_layer(extra_maps, priority=999)
+            return temp
 
-def res(text: str, passes=None, **ctx) -> str:
-    '''
-    Resolve using the global default resolver.
-    '''
-    return _DEFAULT.res(text, passes=passes, **ctx)
+        return self.layers
 
-def setGlobalMaps(maps, *, name=None, priority=0):
+
+# ---------------------------------------
+# SIMPLE GLOBAL USAGE
+# ---------------------------------------
+
+_DEFAULT_RESOLVER = MapResolver()
+
+def setGlobalMaps(maps, *, priority=0):
     """
-    Register a global map or datamap class into the default resolver.
+    Register a global map or datamap instance/class/dict.
+    Lower priority = earlier lookup.
+    """
+    _DEFAULT_RESOLVER.layers.add_layer(maps, priority=priority)
 
-    maps: datamap class OR dict
-    name: optional layer name (default = class name or 'global')
-    priority: layer priority (lower = earlier)
+def res(text: str, **ctx) -> str:
+    """
+    Simple global resolution.
     """
-    layer_name = name or getattr(maps, "__name__", "global")
-    layer = Layer(layer_name, maps=[maps], priority=priority)
-    _DEFAULT.layers.add_layer(layer)
+    return _DEFAULT_RESOLVER.res(text, **ctx)

mapres/tokenizer.py

@@ -0,0 +1,217 @@
+from enum import Enum, auto
+
+
+class TokenType(Enum):
+    TEXT = auto()
+    IDENT = auto()
+
+    COLON_OPEN = auto()
+    COLON_CLOSE = auto()
+
+    BRACE_OPEN = auto()
+    BRACE_CLOSE = auto()
+
+    DOLLAR_OPEN = auto()
+    DOLLAR_CLOSE = auto()
+
+    ANGLE_OPEN = auto()
+    ANGLE_CLOSE = auto()
+
+    PIPE_OPEN = auto()
+    PIPE_CLOSE = auto()
+
+    PERCENT_OPEN = auto()
+    PERCENT_CLOSE = auto()
+
+    LPAREN = auto()
+    RPAREN = auto()
+
+
+class Token:
+    def __init__(self, type_, value=None, pos=0):
+        self.type = type_
+        self.value = value
+        self.pos = pos
+
+    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})"
+
+
+class Tokenizer:
+    def __init__(self, text):
+        self.text = text
+        self.i = 0
+        self.n = len(text)
+        self.tokens = []
+
+    def peek(self, k=0):
+        idx = self.i + k
+        if idx >= self.n:
+            return ''
+        return self.text[idx]
+
+    def advance(self, k=1):
+        self.i += k
+
+    def match(self, s):
+        return self.text.startswith(s, self.i)
+
+    def emit(self, type_, value=None):
+        self.tokens.append(Token(type_, value, self.i))
+
+    def tokenize(self):
+        buf = []
+
+        def flush_text():
+            if buf:
+                self.emit(TokenType.TEXT, ''.join(buf))
+                buf.clear()
+
+        while self.i < self.n:
+            ch = self.peek()
+
+            # ------------------------------------
+            # ESCAPING: \X → literal X
+            # ------------------------------------
+            if self.match(r'\:'):
+                buf.append(':'); self.advance(2); continue
+            if self.match(r'\<'):
+                buf.append('<'); self.advance(2); continue
+            if self.match(r'\>'):
+                buf.append('>'); self.advance(2); continue
+            if self.match(r'\%'):
+                buf.append('%'); self.advance(2); continue
+            if self.match(r'\$'):
+                buf.append('$'); self.advance(2); continue
+            if self.match(r'\{'):
+                buf.append('{'); self.advance(2); continue
+            if self.match(r'\}'):
+                buf.append('}'); self.advance(2); continue
+            if self.match(r'\|'):
+                buf.append('|'); self.advance(2); continue
+            if self.match(r'\('):
+                buf.append('('); self.advance(2); continue
+            if self.match(r'\)'):
+                buf.append(')'); self.advance(2); continue
+
+            # ------------------------------------
+            # DOUBLE BRACES {{value}}
+            # ------------------------------------
+            if self.match("{{"):
+                flush_text()
+                self.emit(TokenType.BRACE_OPEN)
+                self.advance(2)
+                continue
+
+            if self.match("}}"):
+                flush_text()
+                self.emit(TokenType.BRACE_CLOSE)
+                self.advance(2)
+                continue
+
+            # ------------------------------------
+            # DOLLARS ${value}
+            # ------------------------------------
+            if self.match("${"):
+                flush_text()
+                self.emit(TokenType.DOLLAR_OPEN)
+                self.advance(2)
+                continue
+
+            if self.match("}"):
+                flush_text()
+                self.emit(TokenType.DOLLAR_CLOSE)
+                self.advance()
+                continue
+
+            # ------------------------------------
+            # ANGLES <value>
+            # ------------------------------------
+            if self.match("<"):
+                flush_text()
+                self.emit(TokenType.ANGLE_OPEN)
+                self.advance()
+                continue
+
+            if self.match(">"):
+                flush_text()
+                self.emit(TokenType.ANGLE_CLOSE)
+                self.advance()
+                continue
+
+            # ------------------------------------
+            # PIPES |value|
+            # ------------------------------------
+            if self.match("|"):
+                flush_text()
+                # explicit open/close detection:
+                # |IDENT| → PIPE_OPEN IDENT PIPE_CLOSE
+                # parser enforces structure
+                if self.tokens and self.tokens[-1].type == TokenType.PIPE_OPEN:
+                    self.emit(TokenType.PIPE_CLOSE)
+                else:
+                    self.emit(TokenType.PIPE_OPEN)
+                self.advance()
+                continue
+
+            # ------------------------------------
+            # PERCENTS %value%
+            # ------------------------------------
+            if self.match("%"):
+                flush_text()
+                if self.tokens and self.tokens[-1].type == TokenType.PERCENT_OPEN:
+                    self.emit(TokenType.PERCENT_CLOSE)
+                else:
+                    self.emit(TokenType.PERCENT_OPEN)
+                self.advance()
+                continue
+
+            # ------------------------------------
+            # COLONS :value:
+            # ------------------------------------
+            if self.match(":"):
+                flush_text()
+                if self.tokens and self.tokens[-1].type == TokenType.COLON_OPEN:
+                    self.emit(TokenType.COLON_CLOSE)
+                else:
+                    self.emit(TokenType.COLON_OPEN)
+                self.advance()
+                continue
+
+            # ------------------------------------
+            # PARENTHESES
+            # ------------------------------------
+            if ch == "(":
+                flush_text()
+                self.emit(TokenType.LPAREN)
+                self.advance()
+                continue
+
+            if ch == ")":
+                flush_text()
+                self.emit(TokenType.RPAREN)
+                self.advance()
+                continue
+
+            # ------------------------------------
+            # IDENTIFIERS (with dots)
+            # ------------------------------------
+            if ch.isalpha():
+                flush_text()
+                start = self.i
+                while self.peek().isalnum() or self.peek() in "._":
+                    self.advance()
+                ident = self.text[start:self.i]
+                self.emit(TokenType.IDENT, ident)
+                continue
+
+            # ------------------------------------
+            # DEFAULT: TEXT
+            # ------------------------------------
+            buf.append(ch)
+            self.advance()
+
+        flush_text()
+        return self.tokens

{mapres-2.4.dev6.dist-info → mapres-3.dev1.dist-info}/METADATA

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

mapres-3.dev1.dist-info/RECORD

@@ -0,0 +1,18 @@
+mapres/__init__.py,sha256=ZcaJBlKcdCJciTG5khBQscYfgy26cpVRhyDOhvfBVwY,1052
+mapres/ast.py,sha256=LyeKF1bho8eF8cFdshHT-4Ffzm_yv9x_HNpyjM4lJT8,454
+mapres/cache.py,sha256=hbvsoc6Qw3RhWAEfOOpKHtC7i9EomoUgWzyd4dnH71w,333
+mapres/datamap.py,sha256=HAflZFD9eh2VRkR9_2aDtXxY3r_A5ZUnpxNJ_VqmFBE,3837
+mapres/evaluator.py,sha256=8HhGJ5IdpUvL04-23_oo8cP_tHmFGSdAgaYbpF6S_-M,3779
+mapres/exceptions.py,sha256=jirHKK5yCffSCWWkgZY_gTSIOaFCmXOe5NJJf60HeeQ,130
+mapres/layers.py,sha256=N7QTM_1pAefFwlVFBzLsOjCVMu0N76umIozXnVVSTjk,1393
+mapres/parser.py,sha256=lmLIHj9TxltWumNE12uHWT66jkLUoNQ19w5iEXemLXw,3377
+mapres/resolver.py,sha256=LOAnuNc1RW97eBXughkEPK90MntMSYa7yC8s1EJPVvA,3134
+mapres/tokenizer.py,sha256=vQDy9Fw1rIDLcqs3jlcbZ0VI6mcK0U5h3SJ_jqpH45g,6627
+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.dev1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+mapres-3.dev1.dist-info/METADATA,sha256=zmWvo9Kx8zKBU_E1YVcNKnvUDwwqpJYhDkaQSQCUOw8,1475
+mapres-3.dev1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mapres-3.dev1.dist-info/top_level.txt,sha256=5LMVQqJdtyjxfzv7wJBOZ-360m0Yc79w_-Y7s3n6cTw,7
+mapres-3.dev1.dist-info/RECORD,,

mapres-2.4.dev6.dist-info/RECORD

@@ -1,14 +0,0 @@
-mapres/__init__.py,sha256=t23ofM-wzpPByYi1rEQonxyU1yyza4ZzwwHDZUa5QqA,1010
-mapres/cache.py,sha256=hbvsoc6Qw3RhWAEfOOpKHtC7i9EomoUgWzyd4dnH71w,333
-mapres/datamap.py,sha256=Y1Xlib5-b6KPeH7QynOItE1bk89ITiy14L9NuqpUf5A,2043
-mapres/exceptions.py,sha256=jirHKK5yCffSCWWkgZY_gTSIOaFCmXOe5NJJf60HeeQ,130
-mapres/layers.py,sha256=BPHbc8Bh4VxyphtP60acGoXDCYQcrW4bZRFsOk-5gug,1070
-mapres/resolver.py,sha256=l3ZI2wvUqPzfzWS0G-fW5QGTCjfcAyIGB6T2u4A0dL8,6773
-mapres/maps/__init__.py,sha256=lIRRfem1Fw4iynuwUQ7BY5qrC4fbJKxqLivao2_Dtm4,239
-mapres/maps/color.py,sha256=sHLHgVmO2BFmx1EK5E78-tMHvB8oxbjJplAaVb1JNFQ,1545
-mapres/maps/time.py,sha256=aC290F-B4stnFdKGHpWLqTsT6gPPOyxR18ZZuJZT_Nk,2081
-mapres-2.4.dev6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-mapres-2.4.dev6.dist-info/METADATA,sha256=fin4_gnhRxox8cEJQQWAsoMlze-OCnnFL3alQZsM5Sw,1477
-mapres-2.4.dev6.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-mapres-2.4.dev6.dist-info/top_level.txt,sha256=5LMVQqJdtyjxfzv7wJBOZ-360m0Yc79w_-Y7s3n6cTw,7
-mapres-2.4.dev6.dist-info/RECORD,,