mapres 1.1.2__tar.gz → 2.0__tar.gz

{mapres-1.1.2/src/mapres.egg-info → mapres-2.0}/PKG-INFO

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

{mapres-1.1.2 → mapres-2.0}/pyproject.toml

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

{mapres-1.1.2 → mapres-2.0}/src/mapres/cache.py

@@ -1,5 +1,5 @@
 class LRUCache:
-    def __init__(self, max_size=1024):
+    def __init__(self, max_size: int = 1024):
         self.max_size = max_size
         self.data = {}
 

{mapres-1.1.2 → mapres-2.0}/src/mapres/datamap.py

@@ -12,31 +12,21 @@ class syntax:
 class DataMap:
     '''Core datamap class. Contains logic used to make datamaps'''
     __syntax__: str = syntax.braces
-    __mode__ = None
+    __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)
-
-            # dynamic mode
             if self.__mode__ == "dynamic":
                 providers = getattr(self, "providers", None)
-
-                # explicit provider dict only
                 if isinstance(providers, dict) and f.name in providers:
                     val = providers[f.name]
-
-                # callables are executed
                 if callable(val):
                     val = val()
-
             result[f.name] = val
-
         return result
 
     @classmethod
@@ -54,13 +44,10 @@ def datamap(
     def wrap(cls):
         cls.__syntax__ = syntax
         cls.__mode__ = mode
-
         namespace = dict(cls.__dict__)
         namespace["__dict__"] = {}
-
         cls = type(cls.__name__, (DataMap,), namespace)
         return dataclass(frozen=False)(cls)
-
     return wrap if _cls is None else wrap(_cls)
 
 

{mapres-1.1.2 → mapres-2.0}/src/mapres/exceptions.py

@@ -4,5 +4,5 @@ class MapResError(Exception):
 class MissingKeyError(MapResError):
     pass
 
-class SyntaxError(MapResError):
+class MapSyntaxError(MapResError):
     pass

{mapres-1.1.2 → mapres-2.0}/src/mapres/layers.py

@@ -1,5 +1,5 @@
-# layer holds maps with a priority
 class Layer:
+    '''Holds a map with a priority'''
     def __init__(self, name, maps=None, priority=0):
         self.name = name
         self.maps = maps or []
@@ -11,8 +11,9 @@ class Layer:
     def __iter__(self):
         return iter(self.maps)
 
-# layerstack manages ordered layers
+
 class LayerStack:
+    '''Manages ordered layers'''
     def __init__(self, layers=None):
         self.layers = {}
         if layers:

mapres-2.0/src/mapres/resolver.py

@@ -0,0 +1,174 @@
+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
+    - recursive multi-pass resolution
+    - optional caching
+    """
+    def __init__(
+        self,
+        layers: list | None = None,
+        syntax: list | None = None,
+        pipeline: list | None = None,
+        cache: bool = False,
+        cache_size: int = 1024,
+        max_depth: 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
+        self.max_depth = max_depth
+
+    # 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) -> str:
+        for m in layerstack:
+
+            # class-based layer
+            if isinstance(m, type) and hasattr(m, "as_map"):
+                m = m()
+            if hasattr(m, "as_map"):
+                pattern = m.get_syntax()
+                d = m.as_map()
+            elif isinstance(m, dict):
+                pattern = ctx.get("syntax")
+                if not pattern:
+                    continue
+                d = m
+            else:
+                continue
+
+            def repl(match: re.Match) -> str:
+                k = match.group(1)
+                if k not in d:
+                    raise MissingKeyError(f"Missing key '{k}' in layer {m}")
+                return str(d[k])
+            try:
+                text = re.sub(pattern, repl, text)
+            except re.error as exc:
+                raise MapSyntaxError(f"Regex error in layer {m}: {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
+
+    # recursion
+    def _recursive(self, text: str, ctx: dict, layerstack: LayerStack) -> str:
+        current = text
+        for _ in range(self.max_depth):
+            result = self._resolve_once(current, ctx, layerstack)
+            if result == current:
+                return result
+            current = result
+        return current
+
+    # public api
+    def res(
+        self,
+        text: str,
+        *,
+        extra_maps: dict | None = None,
+        override_maps: dict | None = None,
+        **ctx
+    ) -> str:
+        """
+        Resolve a string using maps, syntax providers, pipeline, and context.
+        """
+        try:
+            if override_maps is not None:
+                temp = LayerStack([Layer("override", override_maps, priority=0)])
+                return self._recursive(text, ctx, temp)
+
+            if extra_maps:
+                temp = self.layers.clone()
+                temp.add_layer(Layer("extra", extra_maps, priority=999))
+                return self._recursive(text, ctx, temp)
+
+            if self.cache_enabled:
+                key = (text, tuple(sorted(ctx.items())))
+                cached = self.cache.get(key)
+                if cached is not None:
+                    return cached
+
+            result = self._recursive(text, ctx, self.layers)
+
+            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, **ctx) -> str:
+    """
+    Resolve using the global default resolver.
+    """
+    return _DEFAULT.res(text, **ctx)

{mapres-1.1.2 → mapres-2.0/src/mapres.egg-info}/PKG-INFO

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

{mapres-1.1.2 → mapres-2.0}/src/mapres.egg-info/SOURCES.txt

@@ -7,7 +7,6 @@ src/mapres/datamap.py
 src/mapres/exceptions.py
 src/mapres/layers.py
 src/mapres/resolver.py
-src/mapres/utils.py
 src/mapres.egg-info/PKG-INFO
 src/mapres.egg-info/SOURCES.txt
 src/mapres.egg-info/dependency_links.txt

mapres-1.1.2/src/mapres/resolver.py

@@ -1,110 +0,0 @@
-import re
-from .datamap import DataMap, syntax
-from .cache import LRUCache
-from .layers import Layer, LayerStack
-
-class MapResolver:
-    def __init__(self, layers=None, syntax=None, pipeline=None, cache=False, cache_size=1024, max_depth=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
-        self.max_depth = max_depth
-
-    # pipeline
-    def _apply_pipeline(self, text, ctx):
-        for stage in self.pipeline:
-            text = stage(text, ctx, self)
-        return text
-
-    # syntax providers
-    def _apply_syntax(self, text, ctx):
-        for provider in self.syntax:
-            pattern = provider.pattern
-            d = provider.get_map(ctx, self)
-            def repl(match):
-                k = match.group(1)
-                return str(d.get(k, match.group(0)))
-            text = re.sub(pattern, repl, text)
-        return text
-
-    # layered maps
-    def _apply_maps(self, text, ctx, layerstack):
-        for m in layerstack:
-            if isinstance(m, type) and hasattr(m, "as_map"):
-                m = m()
-            if hasattr(m, "as_map"):
-                pattern = m.get_syntax()
-                d = m.as_map()
-            elif isinstance(m, dict):
-                pattern = ctx.get("syntax")
-                if not pattern:
-                    continue
-                d = m
-            else:
-                continue
-            def repl(match):
-                k = match.group(1)
-                return str(d.get(k, match.group(0)))
-            text = re.sub(pattern, repl, text)
-        return text
-
-    # ctx
-    def _apply_ctx(self, text, ctx):
-        if not ctx:
-            return text
-        pattern = syntax.braces
-        d = ctx
-        def repl(match):
-            k = match.group(1)
-            return str(d.get(k, match.group(0)))
-        return re.sub(pattern, repl, text)
-
-    # one pass
-    def _resolve_once(self, text, ctx, layerstack):
-        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
-
-    # recursion
-    def _recursive(self, text, ctx, layerstack):
-        current = text
-        for _ in range(self.max_depth):
-            result = self._resolve_once(current, ctx, layerstack)
-            if result == current:
-                return result
-            current = result
-        return current
-
-    # public api
-    def res(self, text, *, extra_maps=None, override_maps=None, **ctx):
-        if override_maps is not None:
-            temp = LayerStack([Layer("override", override_maps, priority=0)])
-            return self._recursive(text, ctx, temp)
-
-        if extra_maps:
-            temp = self.layers.clone()
-            temp.add_layer(Layer("extra", extra_maps, priority=999))
-            return self._recursive(text, ctx, temp)
-
-        if self.cache_enabled:
-            key = (text, tuple(sorted(ctx.items())))
-            cached = self.cache.get(key)
-            if cached is not None:
-                return cached
-
-        result = self._recursive(text, ctx, self.layers)
-
-        if self.cache_enabled:
-            self.cache.set(key, result)
-
-        return result
-
-# global resolver
-_DEFAULT = MapResolver()
-
-def res(text, **ctx):
-    return _DEFAULT.res(text, **ctx)

mapres-1.1.2/src/mapres/utils.py

@@ -1,2 +0,0 @@
-def is_datamap(obj):
-    return hasattr(obj, "as_map")