omlish 0.0.0.dev374__tar.gz → 0.0.0.dev376__tar.gz

{omlish-0.0.0.dev374/omlish.egg-info → omlish-0.0.0.dev376}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev374
+Version: 0.0.0.dev376
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/README.md

@@ -123,34 +123,34 @@ Core utilities and foundational code. It's relatively large but completely self-
 
 # Lite code
 
-A subset of this codebase is written in a 'lite' style. While most of the code is written for python 3.13+, 'lite' code
-is written for 3.8+, and is written in a style conducive to
+A subset of this codebase is written in a 'lite' style (non-'lite' code is referred to as *standard* code). While
+standard code is written for python 3.13+, 'lite' code is written for 3.8+, and is written in a style conducive to
 [amalgamation](https://github.com/wrmsr/omlish/tree/master/omdev#amalgamation) in which multiple python source files are
 stitched together into one single self-contained python script.
 
 Code written in this style has notable differences from standard code, including (but not limited to):
 
 - No name mangling is done in amalgamation, which means (among other things) that code must be written expecting to be
-  all dumped into the same giant namespace. Where a non-lite class might be [`omlish.inject.keys.Key`](inject/keys.py),
+  all dumped into the same giant namespace. Where a standard class might be [`omlish.inject.keys.Key`](inject/keys.py),
   a lite equivalent might be [`omlish.lite.inject.InjectorKey`](lite/inject.py).
 - All internal imports `import` each individual item out of modules rather than importing the modules and referencing
-  their contents. Where non-lite code would `from .. import x; x.y`, lite code would `from ..x import y; y`. As a result
+  their contents. Where standard code would `from .. import x; x.y`, lite code would `from ..x import y; y`. As a result
   there are frequently 'api' non-instantiated namespace classes serving the purpose of modules - just handy bags of
   stuff with shortened names.
 - As lite code is tested in 3.8+ but core code requires 3.13+, packages containing lite code can't import anything
-  non-lite in their (and their ancestors') `__init__.py`'s. Furthermore, `__init__.py` files are omitted outright in
+  standard in their (and their ancestors') `__init__.py`'s. Furthermore, `__init__.py` files are omitted outright in
   amalgamation, so they effectively must be empty in any package containing any lite code. As a result there are
   frequently [`all.py`](configs/all.py) files in mixed-lite packages which serve the purpose of `__init__.py` for
-  non-lite usage - where importing non-lite packages from non-lite code would be done via `from .. import lang`,
-  importing mixed-lite packages from non-lite code would be done via `from ..configs import all as cfgs`.
+  standard usage - where importing standard packages from standard code would be done via `from .. import lang`,
+  importing mixed-lite packages from standard code would be done via `from ..configs import all as cfgs`.
 
 # Dependencies
 
 This library has no required dependencies of any kind, but there are numerous optional integrations - see
 [`__about__.py`](__about__.py) for a full list, but some specific examples are:
 
-- **anyio** - While lite code must use only asyncio, non-trivial async non-lite code prefers to be written to anyio.
-- **pytest** - What is used for all non-lite testing - as lite code has no dependencies of any kind its testing uses
+- **anyio** - While lite code must use only asyncio, non-trivial async standard code prefers to be written to anyio.
+- **pytest** - What is used for all standard testing - as lite code has no dependencies of any kind its testing uses
   stdlib's [unittest](https://docs.python.org/3/library/unittest.html).
 - **asttokens / executing** - For getting runtime source representations of function call arguments, an optional
   capability of [check](check.py).

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev374'
-__revision__ = '7a173b571acabc80999972c98a5fb486b6be9464'
+__version__ = '0.0.0.dev376'
+__revision__ = 'ba3fd063088632563a12a5083389e08d9c13bedc'
 
 
 #

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/collections/__init__.py

@@ -37,10 +37,6 @@ from .coerce import (  # noqa
     seq_or_none,
 )
 
-from .errors import (  # noqa
-    DuplicateKeyError,
-)
-
 from .frozen import (  # noqa
     Frozen,
     FrozenDict,

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/collections/mappings.py

@@ -66,9 +66,27 @@ class TypeMap(ta.Generic[T]):
     def get(self, ty: type[T]) -> T | None:
         return self._dct.get(ty)
 
-    def __getitem__(self, ty: type[T]) -> ta.Sequence[T]:
+    def __getitem__(self, ty: type[T]) -> T:
         return self._dct[ty]
 
+    _any_dct: dict[type | tuple[type, ...], tuple[T, ...]]
+
+    def get_any(self, cls: type | tuple[type, ...]) -> ta.Sequence[T]:
+        try:
+            any_dct = self._any_dct
+        except AttributeError:
+            any_dct = {}
+            self._any_dct = any_dct
+
+        try:
+            return any_dct[cls]
+        except KeyError:
+            pass
+
+        ret = tuple(tv for tv in self if isinstance(tv, cls))
+        any_dct[cls] = ret
+        return ret
+
 
 class DynamicTypeMap(ta.Generic[V]):
     def __init__(self, items: ta.Iterable[V] = (), *, weak: bool = False) -> None:

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/collections/utils.py

@@ -1,7 +1,6 @@
 import typing as ta
 
 from .. import lang
-from .errors import DuplicateKeyError
 from .identity import IdentityKeyDict
 from .identity import IdentitySet
 
@@ -48,7 +47,7 @@ def unique(
         k = key(e)
         if k in seen:
             if strict:
-                raise DuplicateKeyError(k, e)
+                raise lang.DuplicateKeyError(k, e)
         else:
             seen.add(k)
             ret.append(e)
@@ -88,7 +87,7 @@ def make_map(
     for k, v in kvs:
         if k in d:
             if strict:
-                raise DuplicateKeyError(k)
+                raise lang.DuplicateKeyError(k)
         else:
             d[k] = v
     return d

omlish-0.0.0.dev376/omlish/funcs/builders.py

@@ -0,0 +1,162 @@
+# ruff: noqa: UP006 UP045
+# @omlish-lite
+import abc
+import io
+import os.path
+import sys
+import typing as ta
+
+from ..lite.cached import cached_nullary
+from ..lite.check import check
+from ..os.paths import is_path_in_dir
+
+
+##
+
+
+class FnBuilder(abc.ABC):
+    @abc.abstractmethod
+    def build_fn(
+            self,
+            name: str,
+            src: str,
+            ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Callable:
+        ...
+
+
+#
+
+
+class SimpleFnBuilder(FnBuilder):
+    def build_fn(
+            self,
+            name: str,
+            src: str,
+            ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Callable:
+        ns = dict(ns or {})
+        exec(src, ns)
+        return ns[name]
+
+
+build_fn = SimpleFnBuilder().build_fn
+
+
+#
+
+
+class DebugFnBuilder(FnBuilder):
+    def __init__(
+            self,
+            *,
+            mod_name_prefix: ta.Optional[str] = None,
+            src_dir: ta.Optional[str] = None,
+    ) -> None:
+        super().__init__()
+
+        if mod_name_prefix is None:
+            mod_name_prefix = f'_{self.__class__.__name__}_{id(self):x}_'
+        self._mod_name_prefix = mod_name_prefix
+
+        self._given_src_dir = src_dir
+
+        self._num_fns = 0
+        self._mod_names: ta.Set[str] = set()
+        self._installed_sys_path = False
+
+    @cached_nullary
+    def _src_dir(self) -> str:
+        if self._given_src_dir is not None:
+            return self._given_src_dir
+        else:
+            return __import__('tempfile').mkdtemp(prefix=f'_{self.__class__.__name__}_{os.getpid()}__')  # noqa
+
+    @cached_nullary
+    def _install_sys_path(self) -> None:
+        if (src_dir := self._src_dir()) not in sys.path:
+            self._installed_sys_path = True
+            sys.path.append(src_dir)
+
+    def uninstall_sys_path(self) -> None:
+        if self._installed_sys_path:
+            while True:
+                try:
+                    sys.path.remove(self._src_dir())
+                except ValueError:
+                    break
+            self._installed_sys_path = True
+
+    def _gen_mod_name(
+            self,
+            fn_num: int,
+            fn_name: str,
+            *,
+            suffix: ta.Optional[str] = None,
+    ) -> str:
+        mod_name = f'{self._mod_name_prefix}{fn_num}__{fn_name}{suffix or ""}'
+
+        check.not_in(mod_name, self._mod_names)
+        check.not_in(mod_name, sys.modules)
+
+        self._mod_names.add(mod_name)
+
+        return mod_name
+
+    def _build_mod(
+            self,
+            mod_name: str,
+            mod_src: str,
+    ) -> ta.Any:
+        self._install_sys_path()
+
+        src_dir = self._src_dir()
+        src_file = os.path.join(src_dir, f'{mod_name}.py')
+        check.state(is_path_in_dir(src_dir, src_file))
+
+        with open(src_file, 'w') as f:
+            f.write(mod_src)
+
+        mod = __import__(mod_name)
+
+        check.equal(mod.__file__, src_file)
+
+        return mod
+
+    def build_fn(
+            self,
+            name: str,
+            src: str,
+            ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Callable:
+        fn_num = self._num_fns
+        self._num_fns += 1
+
+        mod_name = self._gen_mod_name(fn_num, name)
+
+        src_preamble: ta.List[str] = []
+
+        if ns:
+            ns_mod_name = self._gen_mod_name(fn_num, name, suffix='__ns')
+            ns_mod = self._build_mod(ns_mod_name, '')
+
+            for k, v in ns.items():
+                setattr(ns_mod, k, v)
+
+            src_preamble.append(f'from {ns_mod_name} import (')
+            for k in sorted(ns):
+                src_preamble.append(f'    {k},')
+            src_preamble.append(')')
+
+        src_sb = io.StringIO()
+        if src_preamble:
+            src_sb.write('\n'.join(src_preamble))
+            src_sb.write('\n\n')
+        src_sb.write(src)
+        if not src.endswith('\n'):
+            src_sb.write('\n')
+
+        mod = self._build_mod(mod_name, src_sb.getvalue())
+
+        fn = mod.__dict__[name]
+        return fn

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/funcs/match.py

@@ -1,4 +1,6 @@
 """
+Analogous to scala's partial functions ( https://www.scala-lang.org/api/current/scala/PartialFunction.html ).
+
 TODO:
  - unify MatchFnClass with dispatch.method?
   - __call__ = mfs.method(); @__call__.register(lambda: ...) def _call_... ?

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/lang/__init__.py

@@ -173,6 +173,10 @@ from .enums import (  # noqa
     enum_name_repr,
 )
 
+from .errors import (  # noqa
+    DuplicateKeyError,
+)
+
 from .functions import (  # noqa
     VoidError,
     as_async,

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/lite/__init__.py

@@ -1,5 +1,5 @@
 # @omlish-lite
 """
-These are the 'core' lite modules. These generally have a 'full' equivalent, in which case non-lite code should prefer
+These are the 'core' lite modules. These generally have a 'full' equivalent, in which case standard code should prefer
 that.
 """

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/lite/json.py

@@ -12,7 +12,7 @@ JSON_PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
     indent=JSON_PRETTY_INDENT,
 )
 
-json_dump_pretty: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_PRETTY_KWARGS)  # type: ignore
+json_dump_pretty: ta.Callable[..., None] = functools.partial(json.dump, **JSON_PRETTY_KWARGS)
 json_dumps_pretty: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_PRETTY_KWARGS)
 
 
@@ -26,5 +26,5 @@ JSON_COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
     separators=JSON_COMPACT_SEPARATORS,
 )
 
-json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_COMPACT_KWARGS)  # type: ignore
+json_dump_compact: ta.Callable[..., None] = functools.partial(json.dump, **JSON_COMPACT_KWARGS)
 json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/lite/marshal.py

@@ -17,7 +17,7 @@ import inspect
 import threading
 import typing as ta
 import uuid
-import weakref  # noqa
+import weakref
 
 from .check import check
 from .reflect import deep_subclasses

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/testing/unittest/loading.py

@@ -43,13 +43,13 @@ import types
 import typing as ta
 import unittest
 
-from .types import Test
+from .types import UnittestTest
 
 
 ##
 
 
-class TestTargetLoader:
+class UnittestTargetLoader:
     def __init__(
             self,
             *,
@@ -81,7 +81,7 @@ class TestTargetLoader:
         pattern: ta.Optional[str] = None
         top: ta.Optional[str] = None
 
-    def load(self, target: Target) -> Test:
+    def load(self, target: Target) -> UnittestTest:
         loader = self._loader
         if loader is None:
             loader = unittest.loader.TestLoader()
@@ -89,8 +89,8 @@ class TestTargetLoader:
         if self._test_name_patterns:
             loader.testNamePatterns = self._test_name_patterns  # type: ignore[assignment]
 
-        if isinstance(target, TestTargetLoader.DiscoveryTarget):
-            return ta.cast(Test, loader.discover(
+        if isinstance(target, UnittestTargetLoader.DiscoveryTarget):
+            return ta.cast(UnittestTest, loader.discover(
                 target.start,  # type: ignore[arg-type]
                 target.pattern,  # type: ignore[arg-type]
                 target.top,
@@ -102,11 +102,11 @@ class TestTargetLoader:
             for part in module.split('.')[1:]:
                 module = getattr(module, part)
 
-        if isinstance(target, TestTargetLoader.ModuleTarget):
-            return ta.cast(Test, loader.loadTestsFromModule(module))
+        if isinstance(target, UnittestTargetLoader.ModuleTarget):
+            return ta.cast(UnittestTest, loader.loadTestsFromModule(module))
 
-        elif isinstance(target, TestTargetLoader.NamesTarget):
-            return ta.cast(Test, loader.loadTestsFromNames(
+        elif isinstance(target, UnittestTargetLoader.NamesTarget):
+            return ta.cast(UnittestTest, loader.loadTestsFromNames(
                 target.test_names,  # type: ignore[arg-type]
                 module,
             ))

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/testing/unittest/main.py

@@ -49,25 +49,14 @@ import sys
 import types
 import typing as ta
 
-from .loading import TestTargetLoader
-from .running import TestRunner
+from .loading import UnittestTargetLoader
+from .running import UnittestTestRunner
 
 
 ##
 
 
-def _get_attr_dict(obj: ta.Optional[ta.Any], *attrs: str) -> ta.Dict[str, ta.Any]:
-    if obj is None:
-        return {}
-
-    return {
-        a: v
-        for a in attrs
-        if (v := getattr(obj, a, None)) is not None
-    }
-
-
-class TestRunCli:
+class UnittestRunCli:
     def __init__(self) -> None:
         super().__init__()
 
@@ -195,9 +184,22 @@ class TestRunCli:
 
     #
 
+    @staticmethod
+    def _get_attr_dict(obj: ta.Optional[ta.Any], *attrs: str) -> ta.Dict[str, ta.Any]:
+        if obj is None:
+            return {}
+
+        return {
+            a: v
+            for a in attrs
+            if (v := getattr(obj, a, None)) is not None
+        }
+
+    #
+
     IMPORT_PATH_PAT = re.compile(r'[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*')
 
-    def _build_target(self, name: str, args: ParsedArgs) -> TestTargetLoader.Target:
+    def _build_target(self, name: str, args: ParsedArgs) -> UnittestTargetLoader.Target:
         is_discovery = False
         if os.path.isdir(name):
             is_discovery = True
@@ -207,12 +209,12 @@ class TestRunCli:
                 is_discovery = True
 
         if not is_discovery:
-            return TestTargetLoader.NamesTarget([name])
+            return UnittestTargetLoader.NamesTarget([name])
 
         else:
-            return TestTargetLoader.DiscoveryTarget(
+            return UnittestTargetLoader.DiscoveryTarget(
                 start=name,
-                **_get_attr_dict(
+                **self._get_attr_dict(
                     args.args,
                     'pattern',
                     'top',
@@ -229,7 +231,7 @@ class TestRunCli:
             *,
             exit: bool = False,  # noqa
     ) -> None:
-        loader = TestTargetLoader(**_get_attr_dict(
+        loader = UnittestTargetLoader(**self._get_attr_dict(
             args.args,
             'test_name_patterns',
         ))
@@ -239,7 +241,7 @@ class TestRunCli:
             for target_arg in (args.args.target if args.args is not None else None) or []  # noqa
         ]
 
-        runner = TestRunner(TestRunner.Args(**_get_attr_dict(
+        runner = UnittestTestRunner(UnittestTestRunner.Args(**self._get_attr_dict(
             args.args,
             'verbosity',
             'failfast',
@@ -266,7 +268,7 @@ class TestRunCli:
 
 
 def _main() -> None:
-    cli = TestRunCli()
+    cli = UnittestRunCli()
     args = cli.parse_args(sys.argv[1:])
     cli.run(args, exit=True)
 

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/testing/unittest/running.py

@@ -45,30 +45,13 @@ import typing as ta
 import unittest
 import warnings
 
-from .types import Test
+from .types import UnittestTest
 
 
 ##
 
 
-class _WritelnDecorator:
-    def __init__(self, stream):
-        super().__init__()
-
-        self.stream = stream
-
-    def __getattr__(self, attr):
-        if attr in ('stream', '__getstate__'):
-            raise AttributeError(attr)
-        return getattr(self.stream, attr)
-
-    def writeln(self, arg=None):
-        if arg:
-            self.write(arg)
-        self.write('\n')  # text-mode streams translate to \r\n if needed
-
-
-class TestRunner:
+class UnittestTestRunner:
     """
     A test runner class that displays results in textual form.
 
@@ -98,7 +81,25 @@ class TestRunner:
 
         if stream is None:
             stream = sys.stderr
-        self._stream = _WritelnDecorator(stream)
+        self._stream = UnittestTestRunner._WritelnDecorator(stream)
+
+    #
+
+    class _WritelnDecorator:
+        def __init__(self, stream):
+            super().__init__()
+
+            self.stream = stream
+
+        def __getattr__(self, attr):
+            if attr in ('stream', '__getstate__'):
+                raise AttributeError(attr)
+            return getattr(self.stream, attr)
+
+        def writeln(self, arg=None):
+            if arg:
+                self.write(arg)
+            self.write('\n')  # text-mode streams translate to \r\n if needed
 
     #
 
@@ -179,7 +180,7 @@ class TestRunner:
 
         time_taken = stop_time - start_time
 
-        return TestRunner._InternalRunTestResult(
+        return UnittestTestRunner._InternalRunTestResult(
             result,
             time_taken,
         )
@@ -206,7 +207,7 @@ class TestRunner:
         unexpected_successes: ta.Sequence[str]
 
         @classmethod
-        def merge(cls, results: ta.Iterable['TestRunner.RunResult']) -> 'TestRunner.RunResult':
+        def merge(cls, results: ta.Iterable['UnittestTestRunner.RunResult']) -> 'UnittestTestRunner.RunResult':
             def reduce_attr(fn, a):
                 return fn(getattr(r, a) for r in results)
 
@@ -233,11 +234,11 @@ class TestRunner:
 
         def as_test_and_reasons(l):
             return [
-                TestRunner.RunResult.TestAndReason(result.getDescription(t), r)
+                UnittestTestRunner.RunResult.TestAndReason(result.getDescription(t), r)
                 for t, r in l
             ]
 
-        return TestRunner.RunResult(
+        return UnittestTestRunner.RunResult(
             raw_results=[result],
             time_taken=internal_result.time_taken,
 
@@ -254,11 +255,11 @@ class TestRunner:
 
     #
 
-    def run(self, test: Test) -> RunResult:
+    def run(self, test: UnittestTest) -> RunResult:
         return self._build_run_result(self._internal_run_test(test))
 
-    def run_many(self, tests: ta.Iterable[Test]) -> RunResult:
-        return TestRunner.RunResult.merge([self.run(t) for t in tests])
+    def run_many(self, tests: ta.Iterable[UnittestTest]) -> RunResult:
+        return UnittestTestRunner.RunResult.merge([self.run(t) for t in tests])
 
     #
 

omlish-0.0.0.dev376/omlish/testing/unittest/types.py

@@ -0,0 +1,5 @@
+import typing as ta
+import unittest
+
+
+UnittestTest = ta.Callable[[unittest.TestResult], None]  # ta.TypeAlias

{omlish-0.0.0.dev374 → omlish-0.0.0.dev376}/omlish/text/minja.py

@@ -10,6 +10,8 @@ import io
 import re
 import typing as ta
 
+from ..funcs.builders import FnBuilder
+from ..funcs.builders import SimpleFnBuilder
 from ..lite.cached import cached_nullary
 from ..lite.check import check
 from ..lite.maybes import Maybe
@@ -76,19 +78,9 @@ class MinjaTemplate:
 ##
 
 
-class MinjaFunctionBuilder(ta.Protocol):
-    def __call__(
-            self,
-            name: str,
-            src: str,
-            ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
-    ) -> ta.Callable:
-        ...
-
-
 class MinjaTemplateCompiler:
     """
-    Compiles a template string into a Python function. The returned function takes a dictionary 'context' and returns
+    Compiles a template string into a Python fn. The returned fn takes a dictionary 'context' and returns
     the rendered string.
 
     Supported syntax:
@@ -111,7 +103,7 @@ class MinjaTemplateCompiler:
             fragment_processor: ta.Optional[ta.Callable[[MinjaTemplateFragmentKind, str], str]] = None,
             strict_strings: bool = False,
             stringifier: ta.Optional[ta.Callable[[ta.Any], str]] = None,
-            function_builder: ta.Optional[MinjaFunctionBuilder] = None,
+            fn_builder: ta.Optional[FnBuilder] = None,
     ) -> None:
         super().__init__()
 
@@ -136,9 +128,9 @@ class MinjaTemplateCompiler:
                 stringifier = lambda o: str(o)
         self._stringifier = stringifier
 
-        if function_builder is None:
-            function_builder = self._build_function
-        self._function_builder = function_builder
+        if fn_builder is None:
+            fn_builder = SimpleFnBuilder()
+        self._fn_builder = fn_builder
 
         self._stack: ta.List[ta.Literal['for', 'if']] = []
 
@@ -148,18 +140,6 @@ class MinjaTemplateCompiler:
             raise TypeError(o)
         return o
 
-    @staticmethod
-    def _build_function(
-            name: str,
-            src: str,
-            ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
-    ) -> ta.Callable:
-        glo: dict = {}
-        if ns:
-            glo.update(ns)
-        exec(src, glo)
-        return glo[name]
-
     #
 
     _TAG_PAT = re.compile(
@@ -315,7 +295,7 @@ class MinjaTemplateCompiler:
                 raise KeyError(k)
             ns[k] = v
 
-        render_fn = self._function_builder(
+        render_fn = self._fn_builder.build_fn(
             self._RENDER_FN_NAME,
             rendered.src,
             ns,