Add get_transformer builtin for cross-bblock transform composition

Allows a Python transform to call another bblock's Python transform by
calling get_transformer(bblock_id, transform_id), which returns a
callable accepting the content to transform and an optional extra_metadata
dict.

Implementation:
- _build_transforms_registry() in transform.py collects all Python
  transforms from local and imported bblocks into a registry dict
- The registry is serialized into each persistent subprocess harness as a
  module-level constant (_TRANSFORMS_REGISTRY)
- get_transformer() in the harness looks up the target transform, compiles
  its code (cached), installs any pip dependencies, and returns a callable
  that executes the code in an isolated namespace with bblock-level context
  and _nested_transform=True on the metadata
- Cycle detection raises RuntimeError immediately if a transform is
  already executing in the current call stack

Author: avillar

ogc/bblocks/models.py

@@ -846,6 +846,7 @@ class TransformMetadata:
     sandbox_dir: Path | None = None
     id: str | None = None
     ctx: TransformContext | None = None
+    transforms_registry: dict | None = None
 
 
 @dataclasses.dataclass

ogc/bblocks/transform.py

@@ -296,6 +296,47 @@ def cleanup_sandbox(sandbox_dir: Path, bblocks: list[BuildingBlock]) -> None:
             # temporarily renamed) — leave sandboxes intact to avoid a full rebuild on rename-back
 
 
+def _build_transforms_registry(bblocks_register: BuildingBlockRegister) -> dict:
+    registry = {}
+
+    for bblock_id, bblock in bblocks_register.bblocks.items():
+        transforms = bblock.transforms
+        if not transforms:
+            continue
+        python_transforms = {
+            t['id']: {'code': t['code'], 'metadata': t.get('metadata') or {}}
+            for t in transforms if t.get('type') == 'python' and t.get('code')
+        }
+        if not python_transforms:
+            continue
+        bblock_metadata = json.loads(json.dumps(bblock.metadata, default=str))
+        registry[bblock_id] = {
+            'name': bblock.metadata.get('name', bblock_id),
+            'version': bblock.metadata.get('version'),
+            'bblock_metadata': bblock_metadata,
+            'transforms': python_transforms,
+        }
+
+    for bblock_id, raw in bblocks_register.imported_bblocks.items():
+        transforms = raw.get('transforms') or []
+        python_transforms = {
+            t['id']: {'code': t['code'], 'metadata': t.get('metadata') or {}}
+            for t in transforms if t.get('type') == 'python' and t.get('code')
+        }
+        if not python_transforms:
+            continue
+        raw_copy = {k: v for k, v in raw.items() if k != 'register'}
+        bblock_metadata = json.loads(json.dumps(raw_copy, default=str))
+        registry[bblock_id] = {
+            'name': raw.get('name', bblock_id),
+            'version': raw.get('version'),
+            'bblock_metadata': bblock_metadata,
+            'transforms': python_transforms,
+        }
+
+    return registry
+
+
 def apply_transforms(bblock: BuildingBlock,
                      outputs_path: str | Path,
                      output_subpath='transforms',
@@ -316,6 +357,8 @@ def apply_transforms(bblock: BuildingBlock,
     shutil.rmtree(output_dir, ignore_errors=True)
     output_dir.mkdir(parents=True, exist_ok=True)
 
+    transforms_registry = _build_transforms_registry(bblocks_register) if bblocks_register else {}
+
     # Collects ValidationReportItems per profile across all snippets/transforms,
     # so we can write one consolidated _report.json per profile at the end.
     # format: profile_id -> (profile_bblock, profile_subdir, [ValidationReportItem])
@@ -447,7 +490,8 @@ def apply_transforms(bblock: BuildingBlock,
                                                        input_data=snippet['code'],
                                                        sandbox_dir=transform_sandboxes.get(
                                                            transform['id'], sandbox_dir),
-                                                       ctx=ctx)
+                                                       ctx=ctx,
+                                                       transforms_registry=transforms_registry)
 
                 try:
                     result = transformer.transform(transform_metadata)

ogc/bblocks/transformers/python.py

@@ -22,14 +22,106 @@
 _cache_lock = Lock()
 
 
-def _build_persistent_harness(transform_content: str) -> str:
+def _build_persistent_harness(transform_content: str, transforms_registry: dict) -> str:
+    registry_json = json.dumps(transforms_registry)
     return f"""\
 import sys as _sys, json as _json, types as _types, base64 as _b64, io as _io, traceback as _tb
 
 _TRANSFORM_CODE = compile({repr(transform_content)}, '<transform>', 'exec')
+_TRANSFORMS_REGISTRY = _json.loads({repr(registry_json)})
 
 _real_stdout = _sys.stdout.buffer
 
+# Module-level state for get_transformer
+_cycle_set = set()
+_callable_cache = {{}}
+_compiled_code_cache = {{}}
+
+
+def get_transformer(bblock_id, transform_id):
+    key = (bblock_id, transform_id)
+    if key in _cycle_set:
+        raise RuntimeError(
+            f"Cycle detected: transform {{transform_id!r}} of {{bblock_id!r}} is already executing"
+        )
+
+    if key not in _callable_cache:
+        bblock_entry = _TRANSFORMS_REGISTRY.get(bblock_id)
+        if bblock_entry is None:
+            raise KeyError(f"Building block {{bblock_id!r}} not found in transforms registry")
+        transform_entry = bblock_entry['transforms'].get(transform_id)
+        if transform_entry is None:
+            raise KeyError(
+                f"Transform {{transform_id!r}} not found for building block {{bblock_id!r}}"
+            )
+
+        code_str = transform_entry['code']
+        if code_str not in _compiled_code_cache:
+            _compiled_code_cache[code_str] = compile(
+                code_str, f'<transform:{{bblock_id}}/{{transform_id}}>', 'exec'
+            )
+        compiled = _compiled_code_cache[code_str]
+
+        deps = (transform_entry.get('metadata') or {{}}).get('dependencies', {{}})
+        pip_deps = deps.get('pip', [])
+        if isinstance(pip_deps, str):
+            pip_deps = [pip_deps]
+        if pip_deps:
+            import subprocess as _subproc
+            _subproc.run(
+                [_sys.executable, '-m', 'pip', 'install', '--disable-pip-version-check', *pip_deps],
+                check=True,
+            )
+
+        def _make_callable(_key=key, _bblock_id=bblock_id, _transform_id=transform_id,
+                           _compiled=compiled, _entry=transform_entry, _bb=bblock_entry):
+            def _callable(content, extra_metadata=None):
+                _cycle_set.add(_key)
+                try:
+                    _base_meta = dict(_entry.get('metadata') or {{}})
+                    if extra_metadata:
+                        _base_meta.update(extra_metadata)
+                    _base_meta['_nested_transform'] = True
+
+                    _ctx = _types.SimpleNamespace(
+                        bblock_id=_bblock_id,
+                        bblock_name=_bb.get('name'),
+                        bblock_version=_bb.get('bblock_metadata', {{}}).get('version'),
+                        bblock_tags=_bb.get('bblock_metadata', {{}}).get('tags', []),
+                        bblock_metadata=_bb.get('bblock_metadata', {{}}),
+                    )
+                    _tm = _types.SimpleNamespace(
+                        source_mime_type=None,
+                        target_mime_type=None,
+                        metadata=_types.SimpleNamespace(**_base_meta),
+                        context=_ctx,
+                    )
+
+                    if isinstance(content, bytes):
+                        try:
+                            _input = content.decode('utf-8')
+                        except UnicodeDecodeError:
+                            _input = content
+                    else:
+                        _input = content
+
+                    _ns = {{
+                        'transform_metadata': _tm,
+                        'input_data': _input,
+                        'output_data': None,
+                        'get_transformer': get_transformer,
+                    }}
+                    exec(_compiled, _ns)
+                    return _ns.get('output_data')
+                finally:
+                    _cycle_set.discard(_key)
+            return _callable
+
+        _callable_cache[key] = _make_callable()
+
+    return _callable_cache[key]
+
+
 for _line in _sys.stdin:
     _line = _line.strip()
     if not _line:
@@ -50,7 +142,8 @@ def _build_persistent_harness(transform_content: str) -> str:
     _sys.stdout = _capture
     _sys.stderr = _capture
 
-    _ns = {{'transform_metadata': transform_metadata, 'input_data': input_data, 'output_data': None}}
+    _ns = {{'transform_metadata': transform_metadata, 'input_data': input_data, 'output_data': None,
+            'get_transformer': get_transformer}}
     try:
         exec(_TRANSFORM_CODE, _ns)
         output_data = _ns.get('output_data')
@@ -78,17 +171,18 @@ def _build_persistent_harness(transform_content: str) -> str:
 
 class _PersistentProcess:
 
-    def __init__(self, python_bin: Path, transform_content: str):
+    def __init__(self, python_bin: Path, transform_content: str, transforms_registry: dict):
         self._python_bin = python_bin
         self._transform_content = transform_content
+        self._transforms_registry = transforms_registry
         self._proc: subprocess.Popen | None = None
         self._harness_path: Path | None = None
         self._lock = Lock()
         self._start()
 
     def _start(self):
         if self._harness_path is None:
-            harness = _build_persistent_harness(self._transform_content)
+            harness = _build_persistent_harness(self._transform_content, self._transforms_registry)
             with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
                 f.write(harness)
                 self._harness_path = Path(f.name)
@@ -166,11 +260,12 @@ def transform(self, metadata: TransformMetadata) -> TransformResult:
         if isinstance(transform_content, bytes):
             transform_content = transform_content.decode('utf-8')
 
+        transforms_registry = metadata.transforms_registry or {}
         cache_key = (str(python_bin), transform_content)
         with _cache_lock:
             proc = _process_cache.get(cache_key)
             if proc is None:
-                proc = _PersistentProcess(python_bin, transform_content)
+                proc = _PersistentProcess(python_bin, transform_content, transforms_registry)
                 _process_cache[cache_key] = proc
 
         transform_metadata_dict = {