chalkruntime 3.35.4__tar.gz → 3.35.6__tar.gz

{chalkruntime-3.35.4 → chalkruntime-3.35.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalkruntime
-Version: 3.35.4
+Version: 3.35.6
 Summary: Runtime support library for Chalk AI
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{chalkruntime-3.35.4 → chalkruntime-3.35.6}/chalkruntime/graph/overlay_graph.py

@@ -68,9 +68,17 @@ def add_overlay_to_graph(graph: ResolvedGraphImpl, overlay: graph_pb2.OverlayGra
             list(overlay.feature_sets) + dummy_feature_sets, graph, ctx, is_externally_defined=True
         )
 
+        captured_global_values = {captured.id: captured.value for captured in overlay.captured_global_values}
+
         # Convert new resolvers
         resolvers = [
-            FromProtoConverter.convert_resolver(r, graph=graph, is_externally_defined=True) for r in overlay.resolvers
+            FromProtoConverter.convert_resolver(
+                r,
+                graph=graph,
+                is_externally_defined=True,
+                captured_global_values=captured_global_values,
+            )
+            for r in overlay.resolvers
         ]
         ctx.upsert_resolvers(resolvers, replace_on_conflict=False)
 

{chalkruntime-3.35.4 → chalkruntime-3.35.6}/chalkruntime/graph/protograph_deserializer.py

@@ -1574,7 +1574,11 @@ class FromProtoConverter:
 
     @classmethod
     def convert_stream_resolver(
-        cls, r: pb.StreamResolver, graph: ResolvedGraph, stream_sources: Dict[Tuple[str, str | None], StreamSource]
+        cls,
+        r: pb.StreamResolver,
+        graph: ResolvedGraph,
+        stream_sources: Dict[Tuple[str, str | None], StreamSource],
+        captured_global_values: Mapping[str, pb.FunctionReferenceCapturedGlobal] | None = None,
     ) -> StreamResolverParsed:
         # Resolver outputs
         outputs: list[TResolverFeatureType] = []
@@ -1817,7 +1821,10 @@ class FromProtoConverter:
             resource_hint=None,
             resource_group=r.resource_group if r.HasField("resource_group") else None,
             function_definition=r.function.function_definition,
-            function_captured_globals=FromProtoConverter.convert_function_captured_globals(r.function.captured_globals),
+            function_captured_globals=FromProtoConverter.convert_function_captured_globals(
+                r.function.captured_globals,
+                captured_global_values=captured_global_values,
+            ),
             filename=r.function.file_name,
             fqn=r.fqn,
             module=r.function.module,
@@ -1896,7 +1903,12 @@ class FromProtoConverter:
             raise ValueError(f"Unsupported variant type for StreamResolverParam: '{type_name}'")
 
     @staticmethod
-    def convert_resolver(r: pb.Resolver, graph: ResolvedGraph, is_externally_defined: bool) -> ResolverParsed:
+    def convert_resolver(
+        r: pb.Resolver,
+        graph: ResolvedGraph,
+        is_externally_defined: bool,
+        captured_global_values: Mapping[str, pb.FunctionReferenceCapturedGlobal] | None = None,
+    ) -> ResolverParsed:
         parsed_inputs = FromProtoConverter._parse_inputs(
             r.inputs,
             graph,
@@ -2049,7 +2061,10 @@ class FromProtoConverter:
         return resolver_cls(
             function_definition=r.function.function_definition,
             source_line=source_line,
-            function_captured_globals=FromProtoConverter.convert_function_captured_globals(r.function.captured_globals),
+            function_captured_globals=FromProtoConverter.convert_function_captured_globals(
+                r.function.captured_globals,
+                captured_global_values=captured_global_values,
+            ),
             filename=r.function.file_name,
             fqn=r.fqn,
             module=r.function.module,
@@ -2091,6 +2106,7 @@ class FromProtoConverter:
     def convert_function_captured_globals(
         cls,
         captured_globals: Iterable[pb.FunctionReferenceCapturedGlobal],
+        captured_global_values: Mapping[str, pb.FunctionReferenceCapturedGlobal] | None = None,
     ) -> Mapping[str, FunctionCapturedGlobal]:
         """
         Converts a list of protograph `FunctionReferenceCapturedGlobal` values into the equivalent Chalkpy type.
@@ -2154,7 +2170,10 @@ class FromProtoConverter:
             elif captured_global.HasField("function"):
                 if not captured_global.global_name:
                     continue
-                inner_captured = cls.convert_function_captured_globals(captured_global.function.captured_globals)
+                inner_captured = cls.convert_function_captured_globals(
+                    captured_global.function.captured_globals,
+                    captured_global_values=captured_global_values,
+                )
                 src_ref = captured_global.source_reference if captured_global.HasField("source_reference") else None
                 out[captured_global.global_name] = FunctionCapturedGlobalFunction(
                     source=captured_global.function.source,
@@ -2165,6 +2184,18 @@ class FromProtoConverter:
                     source_line_start=src_ref.range.start.line if src_ref else None,
                     source_line_end=src_ref.range.end.line if src_ref else None,
                 )
+            elif captured_global.HasField("value_ref"):
+                if not captured_global.global_name or captured_global_values is None:
+                    continue
+                referenced_value = captured_global_values.get(captured_global.value_ref.id)
+                if referenced_value is None:
+                    continue
+                out.update(
+                    cls.convert_function_captured_globals(
+                        [referenced_value],
+                        captured_global_values=captured_global_values,
+                    )
+                )
             elif captured_global.HasField("variable"):
                 out[captured_global.global_name] = FunctionCapturedGlobalVariable(
                     name=captured_global.variable.name,
@@ -2187,6 +2218,10 @@ class FromProtoConverter:
     def convert_graph(
         cls, pb_graph: pb.Graph, source_secrets: sources_pb.SourceSecrets | None = None
     ) -> ResolvedGraphImpl:
+        captured_global_values: dict[str, pb.FunctionReferenceCapturedGlobal] = {
+            captured_value.id: captured_value.value
+            for captured_value in getattr(pb_graph, "captured_global_values", ())
+        }
         sql_sources: list[BaseSQLSource] = [
             cls.convert_data_source(x, source_secrets) for x in pb_graph.database_sources_v2
         ]
@@ -2212,14 +2247,24 @@ class FromProtoConverter:
                 list(pb_graph.feature_sets), resolved_graph, ctx, is_externally_defined=False
             )
             converted_resolvers = [
-                FromProtoConverter.convert_resolver(r, graph=resolved_graph, is_externally_defined=False)
+                FromProtoConverter.convert_resolver(
+                    r,
+                    graph=resolved_graph,
+                    is_externally_defined=False,
+                    captured_global_values=captured_global_values,
+                )
                 for r in pb_graph.resolvers
             ]
 
             ctx.upsert_resolvers(converted_resolvers, replace_on_conflict=False)
 
             converted_stream_resolvers = [
-                cls.convert_stream_resolver(r, graph=resolved_graph, stream_sources=stream_sources_dict)
+                cls.convert_stream_resolver(
+                    r,
+                    graph=resolved_graph,
+                    stream_sources=stream_sources_dict,
+                    captured_global_values=captured_global_values,
+                )
                 for r in pb_graph.stream_resolvers
             ]
             ctx.upsert_resolvers(converted_stream_resolvers, replace_on_conflict=False)

{chalkruntime-3.35.4 → chalkruntime-3.35.6}/chalkruntime/server/entrypoint.py

@@ -375,8 +375,12 @@ def _import_and_validate_graph(
     # 5. Capture explicit values of any function-captured global variables
     with safe_trace("get_function_capture_global_variable_values"):
         resolver_captured_global_variables: dict[bytes, types_pb.CodeVariable] = {}
+        captured_global_values = {
+            captured_value.id: captured_value.value
+            for captured_value in getattr(proto_export.graph, "captured_global_values", ())
+        }
         # Recursively collect variables from all captured globals, including those
-        # nested inside helper functions (FunctionGlobalCapturedFunction).
+        # nested inside shared captured global values.
         globals_to_visit: list[FunctionReferenceCapturedGlobal] = [
             glbl for r in proto_export.graph.resolvers for glbl in r.function.captured_globals
         ]
@@ -390,6 +394,9 @@ def _import_and_validate_graph(
                 )
             elif glbl.HasField("function"):
                 globals_to_visit.extend(glbl.function.captured_globals)
+            elif glbl.HasField("value_ref"):
+                if glbl.value_ref.id in captured_global_values:
+                    globals_to_visit.append(captured_global_values[glbl.value_ref.id])
         variable_values = get_variables(resolver_captured_global_variables.values())
 
     return ImportGraphResult.make_successful(

{chalkruntime-3.35.4 → chalkruntime-3.35.6}/chalkruntime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalkruntime
-Version: 3.35.4
+Version: 3.35.6
 Summary: Runtime support library for Chalk AI
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{chalkruntime-3.35.4 → chalkruntime-3.35.6}/chalkruntime.egg-info/SOURCES.txt

@@ -144,5 +144,6 @@ chalkruntime/utils/posix_file_lock.py
 chalkruntime/utils/tracing.py
 chalkruntime/utils/viztracer_profiling.py
 tests/test_branch_model_endpoint_config.py
+tests/test_captured_global_function_refs.py
 tests/test_graph_cache.py
 tests/test_posix_file_lock.py

{chalkruntime-3.35.4 → chalkruntime-3.35.6}/pyproject.toml

@@ -42,7 +42,7 @@ name = "chalkruntime"
 description = "Runtime support library for Chalk AI"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "3.35.4"
+version = "3.35.6"
 
 
 [tool.deptry]

chalkruntime-3.35.6/tests/test_captured_global_function_refs.py

@@ -0,0 +1,75 @@
+from chalk._gen.chalk.graph.v1 import graph_pb2
+from chalk.features.resolver import FunctionCapturedGlobalFunction, FunctionCapturedGlobalVariable
+
+from chalkruntime.graph.protograph_deserializer import FromProtoConverter
+
+
+def test_convert_function_captured_globals_resolves_value_refs() -> None:
+    converted = FromProtoConverter.convert_function_captured_globals(
+        [
+            graph_pb2.FunctionReferenceCapturedGlobal(
+                global_name="helper",
+                value_ref=graph_pb2.FunctionGlobalCapturedValueRef(id="helper-id"),
+            )
+        ],
+        captured_global_values={
+            "helper-id": graph_pb2.FunctionReferenceCapturedGlobal(
+                global_name="helper",
+                function=graph_pb2.FunctionGlobalCapturedFunction(
+                    name="helper",
+                    module="test_module",
+                    source="def helper():\n    return GLOBAL_VALUE\n",
+                    captured_globals=[
+                        graph_pb2.FunctionReferenceCapturedGlobal(
+                            global_name="GLOBAL_VALUE",
+                            value_ref=graph_pb2.FunctionGlobalCapturedValueRef(id="global-value-id"),
+                        )
+                    ],
+                ),
+            ),
+            "global-value-id": graph_pb2.FunctionReferenceCapturedGlobal(
+                global_name="GLOBAL_VALUE",
+                variable=graph_pb2.FunctionGlobalCapturedVariable(
+                    name="GLOBAL_VALUE",
+                    module="test_module",
+                ),
+            ),
+        },
+    )
+
+    helper = converted["helper"]
+    assert isinstance(helper, FunctionCapturedGlobalFunction)
+    assert helper.name == "helper"
+    assert helper.module == "test_module"
+    assert helper.source == "def helper():\n    return GLOBAL_VALUE\n"
+    assert helper.captured_globals is not None
+
+    global_value = helper.captured_globals["GLOBAL_VALUE"]
+    assert isinstance(global_value, FunctionCapturedGlobalVariable)
+    assert global_value.name == "GLOBAL_VALUE"
+    assert global_value.module == "test_module"
+
+
+def test_convert_function_captured_globals_resolves_variable_value_refs() -> None:
+    converted = FromProtoConverter.convert_function_captured_globals(
+        [
+            graph_pb2.FunctionReferenceCapturedGlobal(
+                global_name="GLOBAL_VALUE",
+                value_ref=graph_pb2.FunctionGlobalCapturedValueRef(id="global-value-id"),
+            )
+        ],
+        captured_global_values={
+            "global-value-id": graph_pb2.FunctionReferenceCapturedGlobal(
+                global_name="GLOBAL_VALUE",
+                variable=graph_pb2.FunctionGlobalCapturedVariable(
+                    name="GLOBAL_VALUE",
+                    module="test_module",
+                ),
+            )
+        },
+    )
+
+    global_value = converted["GLOBAL_VALUE"]
+    assert isinstance(global_value, FunctionCapturedGlobalVariable)
+    assert global_value.name == "GLOBAL_VALUE"
+    assert global_value.module == "test_module"