crossplane-function-pythonic 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

crossplane/pythonic/__about__.py

@@ -1,2 +1,2 @@
 # This is set at build time, using "hatch version"
-__version__ = "0.4.1"
+__version__ = "0.5.0"

crossplane/pythonic/__init__.py

@@ -1,7 +1,7 @@
 
 
 from .composite import BaseComposite
-from .protobuf import append, Map, List, Unknown, Yaml, Json, B64Encode, B64Decode
+from .protobuf import append, Map, List, Unknown, Yaml, YamlAll, Json, B64Encode, B64Decode
 
 __all__ = [
     'BaseComposite',
@@ -10,6 +10,7 @@ __all__ = [
     'List',
     'Unknown',
     'Yaml',
+    'YamlAll',
     'Json',
     'B64Encode',
     'B64Decode',

crossplane/pythonic/command.py

@@ -63,7 +63,7 @@ class Command:
             help='Enable Crossplane V1 compatibility mode',
         )
 
-    def __init__(self, args):
+    def __init__(self, args=None):
         self.args = args
         self.initialize()
 
@@ -79,6 +79,7 @@ class Command:
         logger.setLevel(logging.DEBUG if self.args.debug else logging.INFO)
         # Suppress noisy libraries, these can be overriden using --logger-level
         logging.getLogger('asyncio').setLevel(logging.INFO)
+        logging.getLogger('grpc').setLevel(logging.INFO)
         logging.getLogger('httpcore').setLevel(logging.INFO)
         logging.getLogger('httpx').setLevel(logging.WARNING)
         logging.getLogger('kr8s').setLevel(logging.INFO)

crossplane/pythonic/composite.py

@@ -89,7 +89,7 @@ class Ready:
 
 
 class BaseComposite:
-    def __init__(self, crossplane_v1, request, single_use, logger):
+    def __init__(self, crossplane_v1, request, logger):
         self.crossplane_v1 = crossplane_v1
         self.request = protobuf.Message(None, 'request', request.DESCRIPTOR, request, 'Function Request')
         response = fnv1.RunFunctionResponse(
@@ -104,10 +104,7 @@ class BaseComposite:
         )
         self.response = protobuf.Message(None, 'response', response.DESCRIPTOR, response)
         self.logger = logger
-        if single_use:
-            self.parameters = self.request.observed.composite.resource.spec.parameters
-        else:
-            self.parameters = self.request.input.parameters
+        self.parameters = self.request.input.parameters
         self.credentials = Credentials(self.request)
         self.context = self.response.context
         self.environment = self.context['apiextensions.crossplane.io/environment']

crossplane/pythonic/function.py

@@ -17,9 +17,8 @@ logger = logging.getLogger(__name__)
 class FunctionRunner(grpcv1.FunctionRunnerService):
     """A FunctionRunner handles gRPC RunFunctionRequests."""
 
-    def __init__(self, debug=False, renderUnknowns=False, crossplane_v1=False):
+    def __init__(self, renderUnknowns=False, crossplane_v1=False):
         """Create a new FunctionRunner."""
-        self.debug = debug
         self.renderUnknowns = renderUnknowns
         self.crossplane_v1 = crossplane_v1
         self.clazzes = {}
@@ -49,15 +48,13 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         name.append(composite['metadata']['name'])
         logger = logging.getLogger('.'.join(name))
 
-        if composite['apiVersion'] in ('pythonic.crossplane.io/v1alpha1', 'pythonic.fortra.com/v1alpha1') and composite['kind'] == 'Composite':
-            if 'spec' not in composite or 'composite' not in composite['spec']:
-                return self.fatal(request, logger, 'Missing spec "composite"')
-            single_use = True
-            composite = composite['spec']['composite']
+        if 'inlined' in request.input and request.input['inlined']:
+            if 'spec' not in composite or request.input['inlined'] not in composite['spec']:
+                return self.fatal(request, logger, f"Missing inlined spec.{request.input['inlined']}")
+            composite = composite['spec'][request.input['inlined']]
         else:
             if 'composite' not in request.input:
                 return self.fatal(request, logger, 'Missing input "composite"')
-            single_use = False
             composite = request.input['composite']
 
         # Ideally this is something the Function API provides
@@ -101,7 +98,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
             self.clazzes[composite] = clazz
 
         try:
-            composite = clazz(self.crossplane_v1, request, single_use, logger)
+            composite = clazz(self.crossplane_v1, request, logger)
         except Exception as e:
             return self.fatal(request, logger, 'Instantiate', e)
 
@@ -182,7 +179,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         for _, resource in sorted(entry for entry in composite.resources):
             dependencies = resource.desired._getDependencies
             if dependencies:
-                if self.debug:
+                if composite.logger.isEnabledFor(logging.DEBUG):
                     for destination, source in sorted(dependencies.items()):
                         destination = self.trimFullName(destination)
                         source = self.trimFullName(source)
@@ -278,7 +275,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                     if resource.unknownsFatal or (resource.unknownsFatal is None and composite.unknownsFatal):
                         fatalResources.append(name)
                         fatal = True
-                if self.debug:
+                if composite.logger.isEnabledFor(logging.DEBUG):
                     for destination, source in sorted(unknowns.items()):
                         destination = self.trimFullName(destination)
                         source = self.trimFullName(source)
@@ -319,7 +316,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
             message = 'All resources are composed'
             status = True
             result = None
-        if not self.debug and level:
+        if not composite.logger.isEnabledFor(logging.DEBUG) and level:
             level(message)
         composite.conditions.ResourcesComposed(reason, message, status)
         if result:
@@ -378,6 +375,7 @@ class Module:
         self.List = pythonic.List
         self.Unknown = pythonic.Unknown
         self.Yaml = pythonic.Yaml
+        self.YamlAll = pythonic.YamlAll
         self.Json = pythonic.Json
         self.B64Encode = pythonic.B64Encode
         self.B64Decode = pythonic.B64Decode

crossplane/pythonic/grpc.py

@@ -88,7 +88,7 @@ class Command(command.Command):
 
     async def run(self):
         grpc.aio.init_grpc_aio()
-        grpc_runner = function.FunctionRunner(self.args.debug, self.args.render_unknowns, self.args.crossplane_v1)
+        grpc_runner = function.FunctionRunner(self.args.render_unknowns, self.args.crossplane_v1)
         grpc_server = grpc.aio.server()
         grpcv1.add_FunctionRunnerServiceServicer_to_server(grpc_runner, grpc_server)
         if self.args.insecure:

crossplane/pythonic/protobuf.py

@@ -42,6 +42,13 @@ def Yaml(string, readOnly=None):
         string = str(string)
     return Value(None, None, yaml.safe_load(string), readOnly)
 
+def YamlAll(string, readOnly=None):
+    if isinstance(string, (FieldMessage, Value)):
+        if not string:
+            return string
+        string = str(string)
+    return Value(None, None, [document for document in yaml.safe_load_all(string)], readOnly)
+
 def Json(string, readOnly=None):
     if isinstance(string, (FieldMessage, Value)):
         if not string:
@@ -789,8 +796,10 @@ class Value:
     def __contains__(self, item):
         match self._kind:
             case 'struct_value':
+                item = self._validate_key(item)
                 return item in self._value.struct_value.fields or item in self._unknowns
             case 'Struct':
+                item = self._validate_key(item)
                 return item in self._value.fields or item in self._unknowns
             case 'list_value' | 'ListValue':
                 for value in self:

crossplane/pythonic/render.py

@@ -1,9 +1,9 @@
 
 import asyncio
-import kr8s.asyncio
 import importlib
 import inflect
 import inspect
+import kr8s
 import logging
 import pathlib
 import sys
@@ -17,6 +17,9 @@ from . import (
     protobuf,
 )
 
+INFLECT = inflect.engine()
+INFLECT.classical(all=False)
+
 
 class Command(command.Command):
     name = 'render'
@@ -55,7 +58,7 @@ class Command(command.Command):
             action='append',
             default=[],
             metavar='KEY=VALUE',
-            help='Context key-value pairs to pass to the Function pipeline. Values must be YAML/JSON. Keys take precedence over --context-files.',
+            help='Context key-value pairs to pass to the Function pipeline. Values must be sYAML/JSON. Keys take precedence over --context-files.',
         )
         parser.add_argument(
             '--observed-resources', '-o',
@@ -103,88 +106,278 @@ class Command(command.Command):
         )
 
     def initialize(self):
-        self.initialize_function()
+        if self.args:
+            self.initialize_function()
         self.logger = logging.getLogger(__name__)
-        self.inflect = inflect.engine()
-        self.inflect.classical(all=False)
 
     async def run(self):
         if self.args.kube_context:
-            self.kube_context = await kr8s.asyncio.api(context=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)
+        resources += self.collect_resources(self.args.secret_store)
+        resources.sort(key=lambda resource: str(resource.metadata.name))
+        context = self.setup_context()
+
+        render = await self.render(composite, observed, composition, resources, 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:
-            self.kube_context = None
+            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(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:
+                print('---')
+                print(str(result), end='')
+        # Print the final context if requested.
+        if self.args.include_context:
+            print('---')
+            print(str(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(compsite, 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:
+            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, composite.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)
+        return resources
 
-        await self.setup_composite()
-        await self.setup_composition()
+    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
 
-        # Build up the RunFunctionRequest protobuf message used to call function-pythonic.
-        self.request = protobuf.Message(None, 'request', fnv1.RunFunctionRequest.DESCRIPTOR, fnv1.RunFunctionRequest())
-        self.setup_local_resources()
-        await self.setup_observed_resources()
+    async def render(self, composite, observed=[], composition=None, resources=[], context=None, api=None, render_unknowns=False, crossplane_v1=False, composite_observeds=True):
+        # Create the request used when running Composition steps.
+        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 observed:
+            async with asyncio.TaskGroup() as group:
+                for resource in observed:
+                    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(self.args.debug, self.args.render_unknowns, self.args.crossplane_v1)
+        runner = function.FunctionRunner(render_unknowns, crossplane_v1)
         fatal = False
 
         # Process the composition pipeline steps.
-        for step in self.composition.spec.pipeline:
+        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)
-                sys.exit(1)
+                return None
             if not step.input.step:
                 step.input.step = step.step
-            self.request.input = step.input
+            request.input = step.input
 
             # Supply step requested credentials.
-            self.request.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 secret in self.secrets:
-                            if secret.metadata.namespace == namespace and secret.metadata.name == name:
-                                data = self.request.credentials[credential.name].credential_data.data
-                                data()
-                                for key, value in secret.data:
-                                    data[key] = protobuf.B64Decode(value)
-                                break
+                        for resource in resources:
+                            if resource.kind == 'Secret' and resource.apiVersion == 'v1':
+                                if 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)
-                            sys.exit(1)
+                            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.
-                self.request.required_resources()
+                request.required_resources()
                 for requirement in step.requirements.requiredResources:
-                    await self.fetch_requireds(requirement.requirementName, requirement, self.request.required_resources)
+                    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.fetch_requireds(name, selector, self.request.required_resources)
+                    await self.set_required(name, selector, request.required_resources, resources, api)
                 # Fetch the now deprecated extra resources requested.
-                self.request.extra_resources()
+                request.extra_resources()
                 for name, selector in requirements.extra_resources:
-                    await self.fetch_requireds(name, selector, self.request.extra_resources)
+                    await self.set_required(name, selector, request.extra_resources, resources, api)
                 # Run the step using the function-pythonic function runner.
                 response = protobuf.Message(
                     None,
                     'response',
                     fnv1.RunFunctionResponse.DESCRIPTOR,
-                    await runner.RunFunction(self.request._message, None),
+                    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
-                # Copy the response context to the request context to use in subsequent steps.
-                self.request.context = response.context
+                if fatal:
+                    break
                 # Exit this loop if the function has not requested additional extra/required resources.
                 if response.requirements == requirements:
                     break
@@ -192,10 +385,10 @@ class Command(command.Command):
                 requirements = response.requirements
 
             # Copy the response desired state to the request desired state to use in subsequent steps.
-            self.request.desired.resources()
-            self.copy_resource(response.desired.composite, self.request.desired.composite)
+            request.desired.resources()
+            self.copy_resource(response.desired.composite, request.desired.composite)
             for name, resource in response.desired.resources:
-                self.copy_resource(resource, self.request.desired.resources[name])
+                self.copy_resource(resource, request.desired.resources[name])
 
             # Collect the step's returned conditions.
             for condition in response.conditions:
@@ -220,10 +413,10 @@ class Command(command.Command):
         # Collect and format all the returned desired composed resources.
         resources = protobuf.List()
         unready = protobuf.List()
-        prefix = self.composite.metadata.labels['crossplane.io/composite']
+        prefix = composite.metadata.labels['crossplane.io/composite']
         if not prefix:
-            prefix = self.composite.metadata.name
-        for name, resource in self.request.desired.resources:
+            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:
@@ -233,51 +426,42 @@ class Command(command.Command):
             if not ready:
                 unready[protobuf.append] = name
             resource = resource.resource
-            observed = self.request.observed.resources[name].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 self.composite.metadata.namespace:
-                resource.metadata.namespace = self.composite.metadata.namespace
+            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 self.composite.metadata.labels['crossplane.io/claim-name'] and self.composite.metadata.labels['crossplane.io/claim-namespace']:
-                resource.metadata.labels['crossplane.io/claim-namespace'] = self.composite.metadata.labels['crossplane.io/claim-namespace']
-                resource.metadata.labels['crossplane.io/claim-name'] = self.composite.metadata.labels['crossplane.io/claim-name']
-            elif self.composite.spec.claimRef.namespace and self.composite.spec.claimRef.name:
-                resource.metadata.labels['crossplane.io/claim-namespace'] = self.composite.spec.claimRef.namespace
-                resource.metadata.labels['crossplane.io/claim-name'] = self.composite.spec.claimRef.name
+            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 = self.composite.apiVersion
-            resource.metadata.ownerReferences[0].kind = self.composite.kind
-            resource.metadata.ownerReferences[0].name = self.composite.metadata.name
+            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 self.request.desired.composite.resource:
+        for name, value in request.desired.composite.resource:
             composite[name] = value
-        composite.apiVersion = self.request.observed.composite.resource.apiVersion
-        composite.kind = self.request.observed.composite.resource.kind
-        if self.args.include_full_xr:
-            composite.metadata = self.request.observed.composite.resource.metadata
-            del composite.metadata.managedFields
-            if self.request.observed.composite.resource.spec:
-                composite.spec = self.request.observed.composite.resource.spec
-        else:
-            if self.request.observed.composite.resource.metadata.namespace:
-                composite.metadata.namespace = self.request.observed.composite.resource.metadata.namespace
-            composite.metadata.name = self.request.observed.composite.resource.metadata.name
+        composite.apiVersion = request.observed.composite.resource.apiVersion
+        composite.kind = request.observed.composite.resource.kind
         # Add in the composite's status.conditions.
-        if self.request.desired.composite.ready == fnv1.Ready.READY_FALSE:
+        if request.desired.composite.ready == fnv1.Ready.READY_FALSE:
             condition = self.create_condition('Ready', False, 'Creating')
-        elif self.request.desired.composite.ready == fnv1.Ready.READY_UNSPECIFIED and len(unready):
+        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')
@@ -285,263 +469,82 @@ class Command(command.Command):
         for condition in conditions:
             composite.status.conditions[protobuf.append] = condition
 
-        # Print the composite.
-        print('---')
-        print(str(composite), end='')
-
-        # Print Composite connection if requested.
-        if self.args.include_connection_xr:
-            connection = protobuf.Map(
-                apiVersion = 'render.crossplane.io/v1beta1',
-                kind = 'Connection',
-            )
-            for key, value in self.request.desired.composite.connection_details:
-                connection.values[key] = value
-            print('---')
-            print(str(connection), end='')
-
-        # Print the composed resources.
-        for resource in sorted(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 results:
-                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 = self.request.context,
-                )),
-                end='',
-            )
-
-    async def setup_composite(self):
-        # Obtain the Composite to render.
-        if self.args.composite.is_file():
-            self.composite = protobuf.Yaml(self.args.composite.read_text())
-            return
-        if not self.kube_context:
-            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)
-        self.composite = await self.kube_get(composite[0], composite[1], namespace, composite[-1])
-
-    async def setup_composition(self):
-        # Obtain the Composition that will be used to render the Composite.
-        if self.composite.apiVersion in ('pythonic.crossplane.io/v1alpha1', 'pythonic.fortra.com/v1alpha1') and self.composite.kind == 'Composite':
-            if self.args.composition:
-                print('Composite type of "composite.pythonic.crossplane.io" does not use "composition" argument', file=sys.stderr)
-                sys.exit(1)
-            self.create_composition()
-            return
-        if not self.args.composition:
-            if not self.kube_context:
-                print('"composition" argument required', file=sys.stderr)
-                sys.exit(1)
-            revision = self.composite.spec.crossplane.compositionRevisionRef
-            if not revision.name:
-                # Crossplane V1 location
-                revision = self.composite.spec.compositionRevisionRef
-                if not revision.name:
-                    print('Composite does not contain a CompositionRevision name', file=sys.stderr)
-                    sys.exit(1)
-            self.composition = await self.kube_get('CompositionRevision', 'apiextensions.crossplane.io/v1', None, str(revision.name))
-            return
-        if self.args.composition.is_file():
-            composition = self.args.composition.read_text()
-            if self.args.composition.suffix == '.py':
-                self.create_composition(composition)
-            else:
-                self.composition = protobuf.Yaml(composition)
-                if not len(self.composition.spec.pipeline):
-                    print(f"Composition file does not contain any pipeline steps: {self.args.composition}", file=sys.stderr)
-                    sys.exit(1)
-            return
-        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:
-            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, composite.BaseComposite):
-            print(f"Composition class {self.args.composition} is not a subclass of BaseComposite", file=sys.stderr)
-            sys.exit(1)
-        self.create_composition(self.args.composition)
-
-    def setup_local_resources(self):
-        # Load the request context with any specified command line options.
-        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)
-            self.request.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)
-            self.request.context[key_value[0]] = protobuf.Yaml(key_value[1])
-        # Collect specified required/extra resources. Sort for stable order when processed.
-        self.requireds = sorted(
-            self.collect_resources(self.args.required_resources),
-            key=lambda required: str(required.metadata.name),
+        return protobuf.Map(
+            composite=composite,
+            connection=protobuf.Map(
+                apiVersion='render.crossplane.io/v1beta1',
+                kind='Connection',
+                values={key: value for key, value in request.desired.composite.connection_details}
+            ),
+            resources=resources,
+            results=results,
+            context=protobuf.Map(
+                apiVersion='render.crossplane.io/v1beta1',
+                kind='Context',
+                values=request.context,
+            ),
         )
-        # Collect specified connection and credential secrets.
-        self.secrets = [
-            secret
-            for secret in self.collect_resources(self.args.secret_store)
-            if secret.apiVersion == 'v1' and secret.kind == 'Secret'
-        ]
 
-    async def setup_observed_resources(self):
-        # Establish the request observed composite.
-        await self.setup_resource(self.composite, self.request.observed.composite)
-
-        # Obtain observed resources if using external cluster
-        if self.kube_context:
-            async with asyncio.TaskGroup() as group:
-                refs = self.composite.spec.crossplane.resourceRefs
-                if not refs:
-                    refs = self.composite.spec.resourceRefs
-                for ref in refs:
-                    group.create_task(self.setup_observed_resource(ref))
-
-        # Establish the manually configured observed resources.
-        for resource in self.collect_resources(self.args.observed_resources):
-            name = resource.metadata.annotations['crossplane.io/composition-resource-name']
-            if name:
-                await self.setup_resource(resource, self.request.observed.resources[name])
-
-    async def setup_observed_resource(self, ref):
-        if ref.namespace:
-            namespace = str(ref.namespace)
-        elif self.composite.metadata.namespace:
-            namespace = str(self.composite.metadata.namespace)
-        else:
-            namespace = None
-        source = await self.kube_get(
-            str(ref.kind),
-            str(ref.apiVersion),
-            namespace,
-            str(ref.name),
-            False,
-        )
+    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:
-                resource = self.request.observed.resources[name]
-                if not resource:
-                    await self.setup_resource(source, resource)
-
-    def create_composition(self, module=''):
-        self.composition = protobuf.Map()
-        self.composition.apiVersion = 'apiextensions.crossplane.io/v1'
-        self.composition.kind = 'Composition'
-        self.composition.metadata.name = 'function-pythonic-render'
-        self.composition.spec.compositeTypeRef.apiVersion = self.composite.apiVersion
-        self.composition.spec.compositeTypeRef.kind = self.composite.kind
-        self.composition.spec.mode = 'Pipeline'
-        self.composition.spec.pipeline[0].step = 'function-pythonic-render'
-        self.composition.spec.pipeline[0].functionRef.name = 'function-pythonic'
-        self.composition.spec.pipeline[0].input.apiVersion = 'pythonic.fn.crossplane.io/v1alpha1'
-        self.composition.spec.pipeline[0].input.kind = 'Composite'
-        self.composition.spec.pipeline[0].input.composite = str(module)
-
-    def collect_resources(self, resources):
-        files = []
-        for resource in resources:
-            if resource.is_file():
-                files.append(resource)
-            elif resource.is_dir():
-                for file in resource.iterdir():
-                    if file.suffix in ('.yaml', '.yml'):
-                        files.append(file)
-            else:
-                print(f"Specified resource is not a file or a directory: {resource}", file=sys.stderr)
-                sys.exit(1)
-        for file in files:
-            for document in yaml.safe_load_all(file.read_text()):
-                yield protobuf.Value(None, None, document)
+                destination = request.observed.resources[name]
+                if not destination: # Do not override manual observed
+                    await self.set_resource(source, destination, resources, api)
 
-    async def setup_resource(self, source, resource):
-        resource.resource = source
-        namespace = source.spec.writeConnectionSecretToRef.namespace or source.metadata.namespace
-        name = source.spec.writeConnectionSecretToRef.name
-        if namespace and name:
-            connection = None
-            for secret in self.secrets:
-                if secret.metadata.namespace == namespace and secret.metadata.name == name:
-                    connection = secret
-                    break
-            else:
-                if self.kube_context:
-                    connection = await self.kube_get('Secret', 'v1', namespace, name, False)
-            if connection:
-                resource.connection_details()
-                for key, value in connection.data:
-                    resource.connection_details[key] = protobuf.B64Decode(value)
-
-    async def fetch_requireds(self, name, selector, resources):
+    async def set_required(self, name, selector, requireds, resources=[], api=None):
         if not name:
             return
         name = str(name)
-        items = resources[name].items
+        items = requireds[name].items
         items() # Force this to get created
-        for required in self.requireds:
-            if selector.api_version == required.apiVersion and selector.kind == required.kind:
-                if ((not selector.namespace and not required.metadata.namespace)
-                    or (selector.namespace == required.metadata.namespace)
+        for resource in resources:
+            if selector.api_version == resource.apiVersion and selector.kind == resource.kind:
+                if ((not len(selector.namespace) and not len(resource.metadata.namespace))
+                    or (selector.namespace == resource.metadata.namespace)
                     ):
-                    if selector.match_name == required.metadata.name:
-                        await self.setup_resource(required, items[protobuf.append])
+                    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 != required.metadata.labels[key]:
+                            if value != resource.metadata.labels[key]:
                                 break
                         else:
-                            await self.setup_resource(required, items[protobuf.append])
-        if not len(items) and self.kube_context:
+                            await self.set_resource(resource, items[protobuf.append], resources, api)
+        if not len(items) and api:
             if len(selector.match_name):
-                required = await self.kube_get(selector.kind, selector.api_version, selector.namespace, selector.match_name, False)
-                if required:
-                    await self.setup_resource(required, items[protobuf.append])
+                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 required in await self.kube_list(selector.kind, selector.api_version, selector.namespace, selector.match_labels.labels):
-                    await self.setup_resource(required, items[protobuf.append])
+                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=[], api=None):
+        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':
+                    if 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)
 
     def copy_resource(self, source, destination):
         destination.resource = source.resource
@@ -575,56 +578,53 @@ class Command(command.Command):
             condition['message'] = message
         return condition
 
-    def kube_clazz(self, kind, apiVersion, namespaced):
-        kind = str(kind)
-        apiVersion = str(apiVersion)
-        try:
-            return kr8s.asyncio.objects.get_class(kind, apiVersion, True)
-        except KeyError:
-            pass
-        return kr8s.asyncio.objects.new_class(kind, apiVersion, True, bool(namespaced) and len(namespaced), plural=self.inflect.plural_noun(kind))
-
-    async def kube_get(self, kind, apiVersion, namespace, name, required=True):
-        clazz = self.kube_clazz(kind, apiVersion, namespace)
+    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 namespace and len(namespace):
+            if namespaced:
                 fullName.insert(-1, str(namespace))
-                resource = await clazz.get(str(name), namespace=str(namespace), api=self.kube_context)
+                resource = await clazz.get(str(name), namespace=str(namespace), api=api)
             else:
-                resource = await clazz.get(str(name), api=self.kube_context)
+                resource = await clazz.get(str(name), api=api)
             resource = protobuf.Value(None, None, resource.raw)
             result = 'found'
         except kr8s.NotFoundError:
-            if required:
-                print(f"Resource not found: {':'.join(fullName)}", file=sys.stderr)
-                sys.exit(1)
             resource = None
             result = 'missing'
         self.logger.debug(f"Resource {result}: {':'.join(fullName)}")
         return resource
 
-    async def kube_list(self, kind, apiVersion, namespace, labelSelector):
-        clazz = self.kube_clazz(kind, apiVersion, namespace)
+    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 namespace and len(namespace) else None,
-                label_selector={
-                    label: str(value)
-                    for label, value in labelSelector
-                },
-                api=self.kube_context,
+                    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 namespace and len(namespace):
+            if namespaced:
                 fullName.append(str(namespace))
             fullName.append('&'.join(f"{label}={value}" for label, value in labelSelector))
             if resources:
-                result = f"found {self.inflect.number_to_words(len(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())

{crossplane_function_pythonic-0.4.1.dist-info → crossplane_function_pythonic-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crossplane-function-pythonic
-Version: 0.4.1
+Version: 0.5.0
 Summary: A Python centric Crossplane Function
 Project-URL: Documentation, https://github.com/crossplane-contrib/function-pythonic#readme
 Project-URL: Issues, https://github.com/crossplane-contrib/function-pythonic/issues
@@ -83,7 +83,7 @@ kind: Function
 metadata:
   name: function-pythonic
 spec:
-  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.1
+  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.2
 ```
 
 ### Crossplane V1
@@ -95,7 +95,7 @@ kind: Function
 metadata:
   name: function-pythonic
 spec:
-  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.1
+  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.2
   runtimeConfigRef:
     name: function-pythonic
 --
@@ -199,6 +199,11 @@ subnet.spec.forProvider.cidrBlock = '10.0.0.0/20'
 ```
 Will generate the appropriate Crossplane Usage resource.
 
+## API Documentation
+
+- [Composite API (`composite.py`)](https://github.com/crossplane-contrib/function-pythonic/blob/main/docs/composite.md)
+- [Protobuf Wrapper API (`protobuf.py`)](https://github.com/crossplane-contrib/function-pythonic/blob/main/docs/protobuf.md)
+
 ## Pythonic access of Protobuf Messages
 
 All Protobuf messages are wrapped by a set of python classes which enable using
@@ -241,6 +246,7 @@ The following functions are provided to create Protobuf structures:
 | List | Create a new Protobuf list |
 | Unknown | Create a new Protobuf unknown placeholder |
 | Yaml | Create a new Protobuf structure from a yaml string |
+| YamlAll | Create a new Protobuf list from a yaml string |
 | Json | Create a new Protobuf structure from a json string |
 | B64Encode | Encode a string into base 64 |
 | B64Decode | Decode a string from base 64 |
@@ -405,25 +411,78 @@ optionally to the Claim.
 | Result.message | String | Human-readable details about the result |
 | Result.claim | Boolean | Also apply the result to the claim |
 
-## Single use Composites
+## Inlined Composites
 
 Tired of creating a CompositeResourceDefinition, a Composition, and a Composite
-just to run that Composition once in a single use or initialize task?
+just to run that Composition once in a setup or initialize task?
 
-function-pythonic installs a `Composite` CompositeResourceDefinition that enables
-creating such tasks using a single Composite resource:
+function-pythonic supports "inlined" Compositions, where the python module
+is obtained from a field in the Composite's spec.
 ```yaml
-apiVersion: pythonic.fn.crossplane.io/v1alpha1
-kind: Composite
+apiVersion: inlined.example.org/v1alpha1
+kind: Step
 metadata:
-  name: composite-example
+  name: inlined-example
 spec:
   composite: |
     class HelloComposite(BaseComposite):
       def compose(self):
-        self.status.composite = 'Hello, World!'
+        self.status.step = 'Hello, World!'
+```
+The CompositeResourceDefinition and Composition to support the above example:
+```yaml
+apiVersion: apiextensions.crossplane.io/v1
+kind: CompositeResourceDefinition
+metadata:
+  name: inlined.example.org/v1alpha1
+spec:
+  group: inlined.example.org
+  names:
+    kind: Step
+    plural: steps
+  defaultCompositionRef:
+    name: steps.inlined.example.org
+  versions:
+  - name: v1alpha1
+    served: true
+    referenceable: true
+    schema:
+      openAPIV3Schema:
+        type: object
+        properties:
+          spec:
+            type: object
+            properties:
+              composite:
+                type: string
+                description: 'A Python module that defines a class with the signature: class Composite(BaseComposite)'
+            required:
+            - composite
+          status:
+            type: object
+            properties:
+              composite:
+                x-kubernetes-preserve-unknown-fields: true
+```
+```yaml
+apiVersion: apiextensions.crossplane.io/v1
+kind: Composition
+metadata:
+  name: steps.inlined.example.org
+spec:
+  compositeTypeRef:
+    apiVersion: inlined.example.org/v1alpha1
+    kind: Step
+  mode: Pipeline
+  pipeline:
+  - step: inlined
+    functionRef:
+      name: function-pythonic
+    input:
+      apiVersion: pythonic.fn.crossplane.io/v1alpha1
+      kind: Composite
+      inlined: composite
 ```
-
 ## Quick Start Development
 
 function-pythonic includes a pure python implementation of the `crossplane render ...`
@@ -616,7 +675,7 @@ kind: Function
 metadata:
   name: function-pythonic
 spec:
-  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.1
+  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.2
   runtimeConfigRef:
     name: function-pythonic
 ---

crossplane_function_pythonic-0.5.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+crossplane/pythonic/__about__.py,sha256=S3lIpABQ5LwPMuO5TLfDrT_eJOQtFzsph4TXcfnx4OY,73
+crossplane/pythonic/__init__.py,sha256=cRk12kc18RLhc9s5dW6sQqZSCEp80fooRO5zxXqc1oA,292
+crossplane/pythonic/__main__.py,sha256=6vYRlYDJtqFgLyiTamnl3htiNOtz8QlDl5WlIP98I8o,31
+crossplane/pythonic/auto_ready.py,sha256=sPetUuJRhwZbg9muaDmbdqmtTIIUDmY4qoadoJA0EtQ,7201
+crossplane/pythonic/command.py,sha256=aT58WBrhU_scaOGeqmsBfofIDnXyW1CQOpCktVGBj5s,4211
+crossplane/pythonic/composite.py,sha256=niq-JSVZ8NB53Q7khkMqH9vQTJPb6yB-13O-wa2Is1U,30311
+crossplane/pythonic/function.py,sha256=CL2j_Br0eYWbn_8r8md9O9ErfHizz78H1KR8l2oV1IA,17964
+crossplane/pythonic/grpc.py,sha256=9ZQceboDju37NB6AhcUSWpBx_hZQ5W7uo7CZF6ynhfI,4451
+crossplane/pythonic/main.py,sha256=ujUa_FYElQSGqnhZ-0NJrD3kSyYjfRbIp79FV2Yl7hs,599
+crossplane/pythonic/packages.py,sha256=4TxyT6V79R0m4tJbC8R1gwU_vgHGLXKSBzeTTKd8xGo,5120
+crossplane/pythonic/protobuf.py,sha256=nmVf-Xn_-ER8BEfEbqd8uQo2gdhmNYyQh9QlhcaYebs,53083
+crossplane/pythonic/render.py,sha256=Y1-fdjQxvPBSkGjfJnNwCOOg6I-bX7Ys9X4jXkqIZp4,30140
+crossplane/pythonic/version.py,sha256=-RiB0p146ayqJj0SXfYxTNv49u9Fx9pPgm59Ji2blhc,214
+crossplane_function_pythonic-0.5.0.dist-info/METADATA,sha256=yMVu_bg-pjIrhuHDjeTAmKEa082V2pq5NroKIeo9poI,33133
+crossplane_function_pythonic-0.5.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+crossplane_function_pythonic-0.5.0.dist-info/entry_points.txt,sha256=jJ4baywFDviB9WyAhyhNYF2VOCb6XtbRSjKf7bnBwhg,68
+crossplane_function_pythonic-0.5.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+crossplane_function_pythonic-0.5.0.dist-info/RECORD,,

{crossplane_function_pythonic-0.4.1.dist-info → crossplane_function_pythonic-0.5.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: hatchling 1.29.0
 Root-Is-Purelib: true
 Tag: py3-none-any

crossplane_function_pythonic-0.4.1.dist-info/RECORD

@@ -1,18 +0,0 @@
-crossplane/pythonic/__about__.py,sha256=dmVecpNqyy8QqMHx8kQerbsS1bVy_KSbwEjreR9uSZg,73
-crossplane/pythonic/__init__.py,sha256=A9U4-azc4DjSsOnOnjQxCkoTzsZMRBb_AvqzR_Bd95A,268
-crossplane/pythonic/__main__.py,sha256=6vYRlYDJtqFgLyiTamnl3htiNOtz8QlDl5WlIP98I8o,31
-crossplane/pythonic/auto_ready.py,sha256=sPetUuJRhwZbg9muaDmbdqmtTIIUDmY4qoadoJA0EtQ,7201
-crossplane/pythonic/command.py,sha256=IHWS3Rb4xarCz_4S6thds5R-5O-JCDm0JAwpbLxyK9Y,4149
-crossplane/pythonic/composite.py,sha256=f9SYjtXVqRx7vse7nQ06Ic6EnnfCYVtpoOmBhR9Jv6g,30451
-crossplane/pythonic/function.py,sha256=BSQmgjGmKM9-2ryu1gLApV0Xf3_VwjmbuAQtjIK-gB0,17961
-crossplane/pythonic/grpc.py,sha256=8hQZZsNrcbiCGfEdPWRrG9SYfTrmuPgMmAIHwWhCdt8,4468
-crossplane/pythonic/main.py,sha256=ujUa_FYElQSGqnhZ-0NJrD3kSyYjfRbIp79FV2Yl7hs,599
-crossplane/pythonic/packages.py,sha256=4TxyT6V79R0m4tJbC8R1gwU_vgHGLXKSBzeTTKd8xGo,5120
-crossplane/pythonic/protobuf.py,sha256=D_DJQQmuOH-Ij1wWwPDLA1V_evuPzDh9mGSrDomq2XQ,52728
-crossplane/pythonic/render.py,sha256=mXFbFFhovoTWzqsqNmMyiww4mtWvUz5uSzcws7u6LlQ,29842
-crossplane/pythonic/version.py,sha256=-RiB0p146ayqJj0SXfYxTNv49u9Fx9pPgm59Ji2blhc,214
-crossplane_function_pythonic-0.4.1.dist-info/METADATA,sha256=zRTEgofZ2Aw5LAS_1_PDNwIuRpzyPmnFhx-i2Ep-wfY,31501
-crossplane_function_pythonic-0.4.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-crossplane_function_pythonic-0.4.1.dist-info/entry_points.txt,sha256=jJ4baywFDviB9WyAhyhNYF2VOCb6XtbRSjKf7bnBwhg,68
-crossplane_function_pythonic-0.4.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-crossplane_function_pythonic-0.4.1.dist-info/RECORD,,