mapres 2.4.dev6__tar.gz → 3.dev1__tar.gz

{mapres-2.4.dev6/src/mapres.egg-info → mapres-3.dev1}/PKG-INFO

@@ -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-2.4.dev6 → mapres-3.dev1}/pyproject.toml

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

{mapres-2.4.dev6 → mapres-3.dev1}/src/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-3.dev1/src/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-3.dev1/src/mapres/datamap.py

@@ -0,0 +1,129 @@
+import re
+from dataclasses import dataclass, fields, is_dataclass
+
+# syntax identifiers
+class syntax:
+    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 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
+
+
+# main decorator factory
+def datamap(_cls=None, *, syntax=None, mode=None):
+    '''
+    @datamap decorator.
+
+    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__'] = {}
+        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:
+        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)
+
+# global mode shortcut
+datamap.config = datamap(mode='config')

mapres-3.dev1/src/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-3.dev1/src/mapres/layers.py

@@ -0,0 +1,56 @@
+# layers.py
+
+class Layer:
+    """
+    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
+
+    def add(self, m):
+        self.maps.append(m)
+
+    def __iter__(self):
+        return iter(self.maps)
+
+
+class LayerStack:
+    """
+    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):
+        """
+        Yield all maps in priority order.
+        """
+        for layer in self.layers:
+            for m in layer:
+                yield m
+
+    def clone(self):
+        """
+        Return a shallow copy of the layerstack.
+        """
+        new = LayerStack()
+        new.layers = list(self.layers)
+        return new

{mapres-2.4.dev6 → mapres-3.dev1}/src/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-2.4.dev6 → mapres-3.dev1}/src/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-3.dev1/src/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-3.dev1/src/mapres/resolver.py

@@ -0,0 +1,113 @@
+from .tokenizer import Tokenizer
+from .parser import Parser
+from .evaluator import Evaluator
+from .layers import LayerStack
+from .cache import LRUCache
+from .exceptions import MapResError
+
+
+class MapResolver:
+    """
+    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.cache_enabled = cache
+        self.cache = LRUCache(cache_size) if cache else None
+
+    # ---------------------------------------
+    # 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
+        """
+
+        try:
+            # caching
+            if self.cache_enabled:
+                key = (text, tuple(sorted(ctx.items())))
+                cached = self.cache.get(key)
+                if cached is not None:
+                    return cached
+
+            # build working layerstack
+            layerstack = self._build_layerstack(extra_maps, override_maps)
+
+            # tokenize
+            tokens = Tokenizer(text).tokenize()
+
+            # 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 Exception as 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
+
+        if extra_maps is not None:
+            temp = self.layers.clone()
+            temp.add_layer(extra_maps, priority=999)
+            return temp
+
+        return self.layers
+
+
+# ---------------------------------------
+# SIMPLE GLOBAL USAGE
+# ---------------------------------------
+
+_DEFAULT_RESOLVER = MapResolver()
+
+def setGlobalMaps(maps, *, priority=0):
+    """
+    Register a global map or datamap instance/class/dict.
+    Lower priority = earlier lookup.
+    """
+    _DEFAULT_RESOLVER.layers.add_layer(maps, priority=priority)
+
+def res(text: str, **ctx) -> str:
+    """
+    Simple global resolution.
+    """
+    return _DEFAULT_RESOLVER.res(text, **ctx)

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

@@ -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-2.4.dev6 → mapres-3.dev1}/src/mapres.egg-info/SOURCES.txt

@@ -2,11 +2,15 @@ LICENSE
 README.md
 pyproject.toml
 src/mapres/__init__.py
+src/mapres/ast.py
 src/mapres/cache.py
 src/mapres/datamap.py
+src/mapres/evaluator.py
 src/mapres/exceptions.py
 src/mapres/layers.py
+src/mapres/parser.py
 src/mapres/resolver.py
+src/mapres/tokenizer.py
 src/mapres.egg-info/PKG-INFO
 src/mapres.egg-info/SOURCES.txt
 src/mapres.egg-info/dependency_links.txt

mapres-2.4.dev6/src/mapres/datamap.py

@@ -1,64 +0,0 @@
-import re
-from dataclasses import dataclass, fields, is_dataclass
-
-class syntax:
-    braces   = r'\{([^{}]+)\}'
-    dollars  = r'\$\{([^{}]+)\}'
-    angles   = r'<([^<>]+)>'
-    percents = r'%([^%]+)%'
-
-
-@dataclass
-class DataMap:
-    '''Core datamap class. Contains logic used to make datamaps'''
-    __syntax__: str = syntax.braces
-    __mode__: str | None = None
-
-    def as_map(self):
-        result = {}
-        for f in fields(self):
-            if not f.init or f.name in ('__syntax__', '__mode__'):
-                continue
-            val = getattr(self, f.name)
-            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)
-
-
-# decorator
-def datamap(
-    _cls = None,
-    *,
-    syntax: str = syntax.braces,
-    mode: bool | str | None = None,
-):
-    '''@datamap decorator with optional values'''
-    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)
-
-
-# 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)

mapres-2.4.dev6/src/mapres/layers.py

@@ -1,43 +0,0 @@
-class Layer:
-    '''Holds a map with a priority'''
-    def __init__(self, name, maps=None, priority=0):
-        self.name = name
-        self.maps = maps or []
-        self.priority = priority
-
-    def add(self, m):
-        self.maps.append(m)
-
-    def __iter__(self):
-        return iter(self.maps)
-
-
-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()))
-
-    def all_maps(self):
-        ordered = sorted(self.layers.values(), key=lambda l: l.priority)
-        for layer in ordered:
-            for m in layer:
-                yield m
-
-    def __iter__(self):
-        return self.all_maps()

mapres-2.4.dev6/src/mapres/resolver.py

@@ -1,219 +0,0 @@
-import re
-from .datamap import DataMap, syntax
-from .cache import LRUCache
-from .layers import Layer, LayerStack
-from .exceptions import MapResError, MissingKeyError, MapSyntaxError
-
-
-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
-    ):
-        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
-
-    # 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())))
-                cached = self.cache.get(key)
-                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
-
-            result = current
-
-            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
-
-
-# global resolver
-_DEFAULT = MapResolver()
-
-def res(text: str, passes=None, **ctx) -> str:
-    '''
-    Resolve using the global default resolver.
-    '''
-    return _DEFAULT.res(text, passes=passes, **ctx)
-
-def setGlobalMaps(maps, *, name=None, priority=0):
-    """
-    Register a global map or datamap class into the default resolver.
-
-    maps: datamap class OR dict
-    name: optional layer name (default = class name or 'global')
-    priority: layer priority (lower = earlier)
-    """
-    layer_name = name or getattr(maps, "__name__", "global")
-    layer = Layer(layer_name, maps=[maps], priority=priority)
-    _DEFAULT.layers.add_layer(layer)