crossplane-function-pythonic 0.6.3__py3-none-any.whl → 0.7.0__py3-none-any.whl

crossplane/pythonic/diff.py

@@ -1,880 +0,0 @@
-import asyncio
-import importlib
-import inspect
-import json
-import logging
-import pathlib
-import sys
-
-import inflect
-import kr8s
-import yaml
-
-from . import (
-    command,
-    function,
-    protobuf,
-)
-from .composite import BaseComposite
-from .proto.v1 import run_function_pb2 as fnv1
-
-INFLECT = inflect.engine()
-INFLECT.classical(all=False)
-
-
-class Command(command.Command):
-    name = "diff"
-    help = "Compare the results of a local Composition with a live Composite"
-
-    @classmethod
-    def add_parser_arguments(cls, parser):
-        cls.add_function_arguments(parser)
-        parser.add_argument(
-            "composition",
-            type=pathlib.Path,
-            metavar="COMPOSITION",
-            help="A YAML file containing the Composition resource.",
-        )
-        parser.add_argument(
-            "composite",
-            type=pathlib.Path,
-            nargs="?",
-            metavar="COMPOSITE",
-            help="kind:apiVersion:namespace:name of cluster Composite.",
-        )
-        parser.add_argument(
-            "--kube-context",
-            "-k",
-            action="append",
-            metavar="CONTEXT",
-            help="The kubectl context to use to obtain external resources from, such as required resources, connections, etc.",
-        )
-
-    def initialize(self):
-        if self.args:
-            self.initialize_function()
-        self.logger = logging.getLogger(__name__)
-
-    async def run(self):
-        if self.args.kube_context:
-            api = await kr8s.asyncio.api(context=self.args.kube_context)
-        else:
-            api = None
-        composite = await self.setup_composite(api)
-        observed = self.collect_resources(self.args.observed_resources)
-        composition = await self.setup_composition(composite, api)
-        resources = self.collect_resources(self.args.required_resources)
-        schemas = self.collect_schemas(self.args.required_schemas)
-        context = self.setup_context()
-
-        render = await self.render(
-            composite,
-            observed,
-            composition,
-            resources,
-            schemas,
-            context,
-            api,
-            self.args.render_unknowns,
-            self.args.crossplane_v1,
-        )
-        if not render:
-            sys.exit(1)
-
-        if self.args.include_full_xr:
-            render.composite.metadata = composite.metadata
-            del render.composite.metadata.managedFields
-            if composite.spec:
-                render.composite.spec = composite.spec
-        else:
-            if composite.metadata.namespace:
-                render.composite.metadata.namespace = composite.metadata.namespace
-            render.composite.metadata.name = composite.metadata.name
-
-        # Print the composite.
-        print("---")
-        print(str(render.composite), end="")
-        # Print Composite connection if requested.
-        if self.args.include_connection_xr:
-            print("---")
-            print(
-                str(
-                    protobuf.Map(
-                        apiVersion="render.crossplane.io/v1beta1",
-                        kind="Connection",
-                        values=render.connection,
-                    )
-                ),
-                end="",
-            )
-        # Print the composed resources.
-        for resource in sorted(
-            render.resources,
-            key=lambda resource: str(
-                resource.metadata.annotations["crossplane.io/composition-resource-name"]
-            ),
-        ):
-            print("---")
-            print(str(resource), end="")
-        # Print the results (AKA events) if requested.
-        if self.args.include_function_results:
-            for result in render.results:
-                result.apiVersion = "render.crossplane.io/v1beta1"
-                result.kind = "Result"
-                print("---")
-                print(str(result), end="")
-        # Print the final context if requested.
-        if self.args.include_context:
-            print("---")
-            print(
-                str(
-                    protobuf.Map(
-                        apiVersion="render.crossplane.io/v1beta1",
-                        kind="Context",
-                        values=render.context,
-                    )
-                ),
-                end="",
-            )
-
-    async def setup_composite(self, api=None):
-        # Obtain the Composite to render.
-        if self.args.composite.is_file():
-            return protobuf.Yaml(self.args.composite.read_text())
-        if not api:
-            print(f'Composite "{self.args.composite}" is not a file', file=sys.stderr)
-            sys.exit(1)
-        composite = str(self.args.composite).split(":")
-        if len(composite) == 3:
-            namespace = None
-        elif len(composite) == 4:
-            if len(composite[2]):
-                namespace = composite[2]
-            else:
-                namespace = None
-        else:
-            print(
-                f'Composite "{self.args.composite}" is not kind:apiVersion:namespace:name',
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        composite = await self.kr8s_get(
-            api, composite[0], composite[1], namespace, composite[-1]
-        )
-        if not composite:
-            print(f'Composite "{self.args.composite}" not found', file=sys.stderr)
-            sys.exit(1)
-        return composite
-
-    async def setup_composition(self, composite, api=None):
-        # Obtain the Composition that will be used to render the Composite.
-        if not self.args.composition:
-            return None
-        if self.args.composition.is_file():
-            composition = self.args.composition.read_text()
-            if self.args.composition.suffix == ".py":
-                return self.create_composition(composite, composition)
-            composition = protobuf.Yaml(composition)
-            if not len(composition.spec.pipeline):
-                print(
-                    f"Composition file does not contain any pipeline steps: {self.args.composition}",
-                    file=sys.stderr,
-                )
-                sys.exit(1)
-            return composition
-        composition = str(self.args.composition).rsplit(".", 1)
-        if len(composition) == 1:
-            print(
-                f"Composition class name does not include module: {self.args.composition}",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        try:
-            module = importlib.import_module(composition[0])
-        except Exception as e:  # noqa: BLE001
-            print(e)
-            print(
-                f"Unable to import composition module: {composition[0]}",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        clazz = getattr(module, composition[1], None)
-        if not clazz:
-            print(
-                f"Composition class {composition[0]} does not define: {composition[1]}",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        if not inspect.isclass(clazz):
-            print(
-                f"Composition class {self.args.composition} is not a class",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        if not issubclass(clazz, BaseComposite):
-            print(
-                f"Composition class {self.args.composition} is not a subclass of BaseComposite",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        return self.create_composition(composite, self.args.composition)
-
-    def create_composition(self, composite, module=""):
-        composition = protobuf.Map()
-        composition.apiVersion = "apiextensions.crossplane.io/v1"
-        composition.kind = "Composition"
-        composition.metadata.name = "function-pythonic-render"
-        composition.spec.compositeTypeRef.apiVersion = composite.apiVersion
-        composition.spec.compositeTypeRef.kind = composite.kind
-        composition.spec.mode = "Pipeline"
-        composition.spec.pipeline[0].step = "function-pythonic-render"
-        composition.spec.pipeline[0].functionRef.name = "function-pythonic"
-        composition.spec.pipeline[
-            0
-        ].input.apiVersion = "pythonic.fn.crossplane.io/v1alpha1"
-        composition.spec.pipeline[0].input.kind = "Composite"
-        composition.spec.pipeline[0].input.composite = str(module)
-        return composition
-
-    def collect_resources(self, entries):
-        resources = []
-        for entry in entries:
-            if entry.is_file():
-                for document in yaml.safe_load_all(entry.read_text()):
-                    resources.append(protobuf.Value(None, None, document))
-            elif entry.is_dir():
-                for file in entry.iterdir():
-                    if file.suffix in (".yaml", ".yml"):
-                        for document in yaml.safe_load_all(file.read_text()):
-                            resources.append(protobuf.Value(None, None, document))
-            else:
-                print(
-                    f"Specified resource is not a file or a directory: {entry}",
-                    file=sys.stderr,
-                )
-                sys.exit(1)
-        resources.sort(key=lambda resource: str(resource.metadata.name))
-        return resources
-
-    def collect_schemas(self, entries):
-        schemas = []
-        for entry in entries:
-            if entry.is_file():
-                document = json.loads(entry.read_text())
-                schemas.append(protobuf.Value(None, None, document))
-            elif entry.is_dir():
-                for file in entry.iterdir():
-                    if file.suffix == ".json":
-                        document = json.loads(file.read_text())
-                        schemas.append(protobuf.Value(None, None, document))
-            else:
-                print(
-                    f"Specified resource is not a file or a directory: {entry}",
-                    file=sys.stderr,
-                )
-                sys.exit(1)
-        return schemas
-
-    def setup_context(self):
-        # Load the request context with any specified command line options.
-        context = protobuf.Map()
-        for entry in self.args.context_files:
-            key_path = entry.split("=", 1)
-            if len(key_path) != 2:
-                print(f"Invalid --context-files: {entry}", file=sys.stderr)
-                sys.exit(1)
-            path = pathlib.Path(key_path[1])
-            if not path.is_file():
-                print(f"Invalid --context-files {path} is not a file", file=sys.stderr)
-                sys.exit(1)
-            context[key_path[0]] = protobuf.Yaml(path.read_text())
-        for entry in self.args.context_values:
-            key_value = entry.split("=", 1)
-            if len(key_value) != 2:
-                print(f"Invalid --context-values: {entry}", file=sys.stderr)
-                sys.exit(1)
-            context[key_value[0]] = protobuf.Yaml(key_value[1])
-        return context
-
-    async def render(
-        self,
-        composite,
-        observeds=None,
-        composition=None,
-        resources=None,
-        schemas=None,
-        context=None,
-        api=None,
-        render_unknowns=False,
-        crossplane_v1=False,
-        composite_observeds=True,
-    ):
-        # Create the request used when running Composition steps.
-        if schemas is None:
-            schemas = []
-        if resources is None:
-            resources = []
-        if observeds is None:
-            observeds = []
-        request = protobuf.Message(
-            None,
-            "request",
-            fnv1.RunFunctionRequest.DESCRIPTOR,
-            fnv1.RunFunctionRequest(),
-        )
-        if context is not None:
-            request.context = context
-
-        # Establish the request observed composite.
-        await self.set_resource(composite, request.observed.composite, resources, api)
-        # Establish the manually configured observed resources.
-        if observeds:
-            async with asyncio.TaskGroup() as group:
-                for resource in observeds:
-                    name = resource.metadata.annotations[
-                        "crossplane.io/composition-resource-name"
-                    ]
-                    if name:
-                        group.create_task(
-                            self.set_resource(
-                                resource,
-                                request.observed.resources[name],
-                                resources,
-                                api,
-                            )
-                        )
-        if api and composite_observeds:
-            refs = composite.spec.crossplane.resourceRefs
-            if not refs:
-                refs = composite.spec.resourceRefs
-            if refs:
-                async with asyncio.TaskGroup() as group:
-                    for ref in refs:
-                        group.create_task(
-                            self.get_composite_ref(
-                                composite, ref, request, resources, api
-                            )
-                        )
-
-        if not composition:
-            if (
-                composite.apiVersion
-                in ("pythonic.crossplane.io/v1alpha1", "pythonic.fortra.com/v1alpha1")
-                and composite.kind == "Composite"
-            ):
-                composition = self.create_composition(composite)
-            else:
-                if not api:
-                    print('"composition" required', file=sys.stderr)
-                    return None
-                revision = composite.spec.crossplane.compositionRevisionRef
-                if not revision.name:
-                    # Crossplane V1 location
-                    revision = composite.spec.compositionRevisionRef
-                    if not revision.name:
-                        print(
-                            "Composite does not contain a CompositionRevision name",
-                            file=sys.stderr,
-                        )
-                        return None
-                composition = await self.kr8s_get(
-                    api,
-                    "CompositionRevision",
-                    "apiextensions.crossplane.io/v1",
-                    None,
-                    revision.name,
-                )
-                if not composition:
-                    print(f'Compositioin "{revision.name}" not found', file=sys.stderr)
-                    return None
-
-        # These will hold the response conditions and results.
-        conditions = protobuf.List()
-        results = protobuf.List()
-
-        # Create a function-pythonic function runner used to run pipeline steps.
-        runner = function.FunctionRunner(render_unknowns, crossplane_v1)
-        fatal = False
-
-        # Process the composition pipeline steps.
-        for step in composition.spec.pipeline:
-            if step.functionRef.name != "function-pythonic":
-                print(
-                    f"Only function-pythonic functions can be run: {step.functionRef.name}",
-                    file=sys.stderr,
-                )
-                return None
-            if not step.input.step:
-                step.input.step = step.step
-            request.input = step.input
-
-            # Supply step requested credentials.
-            request.credentials()
-            for credential in step.credentials:
-                if credential.source == "Secret" and credential.secretRef:
-                    namespace = credential.secretRef.namespace
-                    name = credential.secretRef.name
-                    if namespace and name:
-                        for resource in resources:
-                            if (
-                                resource.kind == "Secret"
-                                and resource.apiVersion == "v1"
-                                and resource.metadata.namespace == namespace
-                                and resource.metadata.name == name
-                            ):
-                                data = request.credentials[
-                                    credential.name
-                                ].credential_data.data
-                                data()
-                                for key, value in resource.data:
-                                    data[key] = protobuf.B64Decode(value)
-                                break
-                        else:
-                            print(
-                                f'Step "{step.step}" secret not found: {namespace}/{name}',
-                                file=sys.stderr,
-                            )
-                            return None
-
-            # Track what extra/required resources have been processed.
-            requirements = protobuf.Message(
-                None, "requirements", fnv1.Requirements.DESCRIPTOR, fnv1.Requirements()
-            )
-            for _ in range(5):
-                # Fetch the step bootstrap resources specified.
-                request.required_resources()
-                for requirement in step.requirements.requiredResources:
-                    await self.set_required(
-                        requirement.requirementName,
-                        requirement,
-                        request.required_resources,
-                        resources,
-                        api,
-                    )
-                # Fetch the required resources requested.
-                for name, selector in requirements.resources:
-                    await self.set_required(
-                        name, selector, request.required_resources, resources, api
-                    )
-                # Fetch the now deprecated extra resources requested.
-                request.extra_resources()
-                for name, selector in requirements.extra_resources:
-                    await self.set_required(
-                        name, selector, request.extra_resources, resources, api
-                    )
-                # Fetch the schemas requested.
-                request.required_schemas()
-                for name, selector in requirements.schemas:
-                    await self.set_schema(
-                        name, selector, request.required_schemas, schemas, api
-                    )
-                # Run the step using the function-pythonic function runner.
-                response = protobuf.Message(
-                    None,
-                    "response",
-                    fnv1.RunFunctionResponse.DESCRIPTOR,
-                    await runner.RunFunction(request._message, None),
-                )
-                # Copy the response context to the request context to use in subsequent steps.
-                request.context = response.context
-                # All done if there is a fatal result.
-                for result in response.results:
-                    if result.severity == fnv1.Severity.SEVERITY_FATAL:
-                        fatal = True
-                        break
-                if fatal:
-                    break
-                # Exit this loop if the function has not requested additional extra/required resources.
-                if response.requirements == requirements:
-                    break
-                # Establish the new set of requested extra/required resoruces.
-                requirements = response.requirements
-
-            # Copy the response desired state to the request desired state to use in subsequent steps.
-            request.desired.resources()
-            self.copy_resource(response.desired.composite, request.desired.composite)
-            for name, resource in response.desired.resources:
-                self.copy_resource(resource, request.desired.resources[name])
-
-            # Collect the step's returned conditions.
-            for condition in response.conditions:
-                if condition.type not in ("Ready", "Synced", "Healthy"):
-                    conditions[protobuf.append] = self.create_condition(
-                        condition.type,
-                        condition.status,
-                        condition.reason,
-                        condition.message,
-                    )
-            # Collect the step's returned results.
-            for result in response.results:
-                ix = len(results)
-                results[ix].step = step.step
-                results[ix].severity = fnv1.Severity.Name(result.severity._value)
-                if result.reason:
-                    results[ix].reason = result.reason
-                if result.message:
-                    results[ix].message = result.message
-
-            # All done if a fatal result was returned
-            if fatal:
-                break
-
-        # Collect and format all the returned desired composed resources.
-        resources = protobuf.List()
-        unready = protobuf.List()
-        prefix = composite.metadata.labels["crossplane.io/composite"]
-        if not prefix:
-            prefix = composite.metadata.name
-        for name, resource in request.desired.resources:
-            if resource.ready == fnv1.Ready.READY_TRUE:
-                ready = True
-            elif resource.ready == fnv1.Ready.READY_FALSE:
-                ready = False
-            else:
-                ready = None
-            if not ready:
-                unready[protobuf.append] = name
-            resource = resource.resource
-            observed = request.observed.resources[name].resource
-            if observed:
-                for key in ("namespace", "generateName", "name"):
-                    if observed.metadata[key]:
-                        resource.metadata[key] = observed.metadata[key]
-            if not resource.metadata.name and not resource.metadata.generateName:
-                resource.metadata.generateName = f"{prefix}-"
-            if composite.metadata.namespace:
-                resource.metadata.namespace = composite.metadata.namespace
-            resource.metadata.annotations["crossplane.io/composition-resource-name"] = (
-                name
-            )
-            resource.metadata.labels["crossplane.io/composite"] = prefix
-            if (
-                composite.metadata.labels["crossplane.io/claim-name"]
-                and composite.metadata.labels["crossplane.io/claim-namespace"]
-            ):
-                resource.metadata.labels["crossplane.io/claim-namespace"] = (
-                    composite.metadata.labels["crossplane.io/claim-namespace"]
-                )
-                resource.metadata.labels["crossplane.io/claim-name"] = (
-                    composite.metadata.labels["crossplane.io/claim-name"]
-                )
-            elif composite.spec.claimRef.namespace and composite.spec.claimRef.name:
-                resource.metadata.labels["crossplane.io/claim-namespace"] = (
-                    composite.spec.claimRef.namespace
-                )
-                resource.metadata.labels["crossplane.io/claim-name"] = (
-                    composite.spec.claimRef.name
-                )
-            resource.metadata.ownerReferences[0].controller = True
-            resource.metadata.ownerReferences[0].blockOwnerDeletion = True
-            resource.metadata.ownerReferences[0].apiVersion = composite.apiVersion
-            resource.metadata.ownerReferences[0].kind = composite.kind
-            resource.metadata.ownerReferences[0].name = composite.metadata.name
-            resource.metadata.ownerReferences[0].uid = ""
-            resource.ready = ready
-            resources[protobuf.append] = resource
-
-        # Format the returned desired composite
-        composite = protobuf.Map()
-        for name, value in request.desired.composite.resource:
-            composite[name] = value
-        composite.apiVersion = request.observed.composite.resource.apiVersion
-        composite.kind = request.observed.composite.resource.kind
-        # Add in the composite's status.conditions.
-        if request.desired.composite.ready == fnv1.Ready.READY_FALSE:
-            condition = self.create_condition("Ready", False, "Creating")
-        elif request.desired.composite.ready == fnv1.Ready.READY_UNSPECIFIED and len(
-            unready
-        ):
-            condition = self.create_condition(
-                "Ready",
-                False,
-                "Creating",
-                f"Unready resources: {','.join(str(name) for name in unready)}",
-            )
-        else:
-            condition = self.create_condition("Ready", True, "Available")
-        composite.status.conditions[protobuf.append] = condition
-        for condition in conditions:
-            composite.status.conditions[protobuf.append] = condition
-
-        return protobuf.Map(
-            composite=composite,
-            connection=request.desired.composite.connection_details,
-            resources=resources,
-            results=results,
-            context=request.context,
-            observed=request.observed,
-        )
-
-    async def get_composite_ref(self, composite, ref, request, resources, api):
-        namespace = ref.namespace
-        if not namespace:
-            namespace = composite.metadata.namespace
-            if not namespace:
-                namespace = None
-        source = await self.kr8s_get(api, ref.kind, ref.apiVersion, namespace, ref.name)
-        if source:
-            name = source.metadata.annotations[
-                "crossplane.io/composition-resource-name"
-            ]
-            if name:
-                destination = request.observed.resources[name]
-                if not destination:  # Do not override manual observed
-                    await self.set_resource(source, destination, resources, api)
-
-    async def set_required(self, name, selector, requireds, resources=None, api=None):
-        if resources is None:
-            resources = []
-        if not name:
-            return
-        name = str(name)
-        items = requireds[name].items
-        items()  # Force this to get created
-        for resource in resources:
-            if (
-                selector.api_version == resource.apiVersion
-                and selector.kind == resource.kind
-                and (
-                    (
-                        not len(selector.namespace)
-                        and not len(resource.metadata.namespace)
-                    )
-                    or (selector.namespace == resource.metadata.namespace)
-                )
-            ):
-                if selector.match_name == resource.metadata.name:
-                    await self.set_resource(
-                        resource, items[protobuf.append], resources, api
-                    )
-                elif selector.match_labels.labels:
-                    for key, value in selector.match_labels.labels:
-                        if value != resource.metadata.labels[key]:
-                            break
-                    else:
-                        await self.set_resource(
-                            resource, items[protobuf.append], resources, api
-                        )
-        if not len(items) and api:
-            if len(selector.match_name):
-                resource = await self.kr8s_get(
-                    api,
-                    selector.kind,
-                    selector.api_version,
-                    selector.namespace,
-                    selector.match_name,
-                )
-                if resource:
-                    await self.set_resource(
-                        resource, items[protobuf.append], resources, api
-                    )
-            elif len(selector.match_labels.labels):
-                for resource in await self.kr8s_list(
-                    api,
-                    selector.kind,
-                    selector.api_version,
-                    selector.namespace,
-                    selector.match_labels.labels,
-                ):
-                    await self.set_resource(
-                        resource, items[protobuf.append], resources, api
-                    )
-
-    async def set_resource(self, source, destination, resources=None, api=None):
-        if resources is None:
-            resources = []
-        destination.resource = source
-        namespace = (
-            source.spec.writeConnectionSecretToRef.namespace
-            or source.metadata.namespace
-        )
-        name = source.spec.writeConnectionSecretToRef.name
-        if namespace and name:
-            connection = None
-            for resource in resources:
-                if (
-                    resource.kind == "Secret"
-                    and resource.apiVersion == "v1"
-                    and resource.metadata.namespace == namespace
-                    and resource.metadata.name == name
-                ):
-                    connection = resource
-                    break
-            else:
-                if api:
-                    connection = await self.kr8s_get(
-                        api, "Secret", "v1", namespace, name
-                    )
-            if connection:
-                destination.connection_details()
-                for key, value in connection.data:
-                    destination.connection_details[key] = protobuf.B64Decode(value)
-
-    async def set_schema(self, name, selector, schemas, documents=None, api=None):
-        if documents is None:
-            documents = []
-        if not name:
-            return
-        name = str(name)
-        schema = schemas[name].openapi_v3
-        schema()  # Force this to get created
-        gvk = protobuf.Map(kind=selector.kind)
-        version = str(selector.api_version)
-        if "/" in version:
-            gvk.group, gvk.version = version.split("/", 1)
-        else:
-            gvk.group = ""
-            gvk.version = version
-        for document in documents:
-            if self.find_schema(gvk, document, schema):
-                return
-        if api:
-            if gvk.group == "":
-                url = f"api/{gvk.version}"
-            else:
-                url = f"apis/{gvk.group}/{gvk.version}"
-            try:
-                async with api.call_api(
-                    base="/openapi/v3", version="", url=url
-                ) as response:
-                    document = protobuf.Value(None, None, response.json())
-            except kr8s.NotFoundError:
-                return
-            self.find_schema(gvk, document, schema)
-
-    def find_schema(self, gvk, document, schema):
-        for name, s in document.components.schemas:
-            gvks = s["x-kubernetes-group-version-kind"]
-            if len(gvks) == 1 and gvks[0] == gvk:
-                self.resolve_ref(
-                    document, set(), f"#/components/schemas/{name}", schema
-                )
-                return True
-        return False
-
-    def resolve_ref(self, document, visiting, ref, schema):
-        if not ref:
-            return
-        ref = str(ref)
-        if ref in visiting:
-            return
-        d = None
-        for segment in ref.split("/"):
-            if segment == "#":
-                d = document
-            else:
-                d = d[segment]
-        if not d:
-            return
-        visiting.add(ref)
-        try:
-            for name, value in d:
-                self.copy_schema(document, visiting, name, value, schema)
-        finally:
-            visiting.remove(ref)
-
-    def copy_schema(self, document, visiting, key, value, schema):
-        if key == "$ref":
-            self.resolve_ref(document, visiting, value, schema)
-        elif key == "allOf":
-            if value._isList and len(value) == 1:
-                self.resolve_ref(document, visiting, value[0]["$ref"], schema)
-        else:
-            if value._isMap:
-                s = schema[key]
-                for n, v in value:
-                    self.copy_schema(document, visiting, n, v, s)
-            elif value._isList:
-                s = schema[key]
-                for ix, v in enumerate(value):
-                    self.copy_schema(document, visiting, ix, v, s)
-            else:
-                schema[key] = value
-
-    def copy_resource(self, source, destination):
-        destination.resource = source.resource
-        destination.connection_details()
-        for key, value in source.connection_details:
-            destination.connection_details[key] = value
-        destination.ready = source.ready
-
-    def create_condition(self, type, status, reason, message=None):
-        if isinstance(status, protobuf.FieldMessage):
-            if status._value == fnv1.Status.STATUS_CONDITION_TRUE:
-                status = "True"
-            elif status._value == fnv1.Status.STATUS_CONDITION_FALSE:
-                status = "False"
-            else:
-                status = "Unknown"
-        elif isinstance(status, bool):
-            if status:
-                status = "True"
-            else:
-                status = "False"
-        elif status is None:
-            status = "Unknown"
-        condition = {
-            "type": type,
-            "status": status,
-            "reason": reason,
-            "lastTransitionTime": "2026-01-01T00:00:00Z",
-        }
-        if message:
-            condition["message"] = message
-        return condition
-
-    async def kr8s_get(self, api, kind, apiVersion, namespace, name):
-        namespaced = namespace and len(namespace)
-        clazz = self.kr8s_class(kind, apiVersion, namespaced)
-        try:
-            fullName = [str(kind), str(apiVersion), str(name)]
-            if namespaced:
-                fullName.insert(-1, str(namespace))
-                resource = await clazz.get(str(name), namespace=str(namespace), api=api)
-            else:
-                resource = await clazz.get(str(name), api=api)
-            resource = protobuf.Value(None, None, resource.raw)
-            result = "found"
-        except kr8s.NotFoundError:
-            resource = None
-            result = "missing"
-        self.logger.debug(f"Resource {result}: {':'.join(fullName)}")
-        return resource
-
-    async def kr8s_list(self, api, kind, apiVersion, namespace, labelSelector):
-        namespaced = namespace and len(namespace)
-        clazz = self.kr8s_class(kind, apiVersion, namespaced)
-        resources = [
-            protobuf.Value(None, None, resource.raw)
-            async for resource in clazz.list(
-                namespace=str(namespace) if namespaced else None,
-                label_selector={label: str(value) for label, value in labelSelector},
-                api=api,
-            )
-        ]
-        if self.logger.isEnabledFor(logging.DEBUG):
-            fullName = [str(kind), str(apiVersion)]
-            if namespaced:
-                fullName.append(str(namespace))
-            fullName.append(
-                "&".join(f"{label}={value}" for label, value in labelSelector)
-            )
-            if resources:
-                result = f"found {INFLECT.number_to_words(len(resources))}"
-            else:
-                result = "missing"
-            self.logger.debug(f"Resources {result}: {':'.join(fullName)}")
-        return resources
-
-    def kr8s_class(self, kind, apiVersion, namespaced):
-        try:
-            return kr8s.asyncio.objects.get_class(str(kind), str(apiVersion), True)
-        except KeyError:
-            pass
-        return kr8s.asyncio.objects.new_class(
-            str(kind),
-            str(apiVersion),
-            True,
-            namespaced,
-            plural=INFLECT.plural_noun(str(kind)).lower(),
-        )