crossplane-function-pythonic 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

crossplane/pythonic/__about__.py

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

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()
 
@@ -77,6 +77,12 @@ class Command:
         logger = logging.getLogger()
         logger.handlers = [handler]
         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)
         for logger_level in self.args.logger_level:
             for logger_level in logger_level.split(','):
                 logger_level = logger_level.split('=')

crossplane/pythonic/composite.py

@@ -43,7 +43,7 @@ class Connection:
 
     def __set__(self, composite, values):
         connection = self.__get__(composite)
-        coneection()
+        connection()
         for key, value in values:
             connection[key] = value
 
@@ -384,7 +384,7 @@ class Resource:
                     field = resource.observed.metadata.name
                 else:
                     field = resource.status.notReady
-        self.metadata.annotations[f"Dependency{resource.name}"] = field
+        self.metadata.annotations[f"pythonic.dependency/{resource.name}"] = field
 
 class Requireds:
     def __init__(self, composite):
@@ -757,7 +757,7 @@ class Results:
         return len(self) > 0
 
     def __len__(self):
-        len(self._results)
+        return len(self._results)
 
     def __getitem__(self, key):
         if key >= len(self._results):
@@ -832,7 +832,7 @@ class Result:
 
     @property
     def claim(self):
-        return bool(self) and self._result == fnv1.Target.TARGET_COMPOSITE_AND_CLAIM
+        return bool(self) and self._result.target == fnv1.Target.TARGET_COMPOSITE_AND_CLAIM
 
     @claim.setter
     def claim(self, claim):
@@ -887,10 +887,10 @@ class _Connection:
 
     def __call__(self, **kwargs):
         self._composite.response.desired.composite.connection_details(**kwargs)
-        if self._composite_v1:
+        if self._composite.crossplane_v1:
             return
         del self._composite.resources[self._resource_name]
-        for key, value in kwargs:
+        for key, value in kwargs.items():
             self[key] = value
 
     def __setattr__(self, key, value):

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 = {}
@@ -182,7 +181,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 +277,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 +318,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 +377,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:
@@ -406,12 +413,26 @@ class RepeatedMessage:
 
     def __getitem__(self, key):
         key = self._validate_key(key)
-        if key in self._cache:
-            return self._cache[key]
-        if self._messages is _Unknown or key >= len(self._messages):
+        if key == append:
+            if self._messages is _Unknown:
+                key = 0
+            else:
+                key = len(self._messages)
             value = _Unknown
         else:
-            value = self._messages[key]
+            if key < 0:
+                if self._messages is _Unknown:
+                    key = 0
+                else:
+                    key = len(self._messages) + key
+                    if key < 0:
+                        key = 0
+            if key in self._cache:
+                return self._cache[key]
+            if self._messages is _Unknown or key >= len(self._messages):
+                value = _Unknown
+            else:
+                value = self._messages[key]
         if value is None and self._field.has_default_value:
             value = self._field.default_value
         if self._field.type == self._field.TYPE_MESSAGE:

crossplane/pythonic/render.py

@@ -1,6 +1,5 @@
 
 import asyncio
-import kr8s.asyncio
 import importlib
 import inflect
 import inspect
@@ -103,80 +102,268 @@ 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)
+            kapi = Kr8sApi(self.args.kube_context, self.logger)
+        else:
+            kapi = None
+        composite = await self.setup_composite(kapi)
+        observed = self.collect_resources(self.args.observed_resources)
+        composition = await self.setup_composition(composite, kapi)
+        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, kapi, 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(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, kapi=None):
+        # Obtain the Composite to render.
+        if self.args.composite.is_file():
+            return protobuf.Yaml(self.args.composite.read_text())
+        if not kapi:
+            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:
-            self.kube_context = None
+            print(f"Composite \"{self.args.composite}\" is not kind:apiVersion:namespace:name", file=sys.stderr)
+            sys.exit(1)
+        composite = await kapi.get(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, kapi=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
+
+    async def render(self, composite, observed=[], composition=None, resources=[], context=None, kapi=None, render_unknowns=False, crossplane_v1=False):
+        # 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
 
-        # 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()
+        # Establish the request observed composite.
+        await self.set_resource(composite, request.observed.composite, resources, kapi)
+        # 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, kapi))
+        if kapi:
+            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, kapi))
+
+        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 kapi:
+                    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 kapi.get('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, kapi)
                 # 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, kapi)
                 # 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, kapi)
                 # 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),
                 )
                 # All done if there is a fatal result.
                 for result in response.results:
@@ -184,7 +371,7 @@ class Command(command.Command):
                         fatal = True
                         break
                 # Copy the response context to the request context to use in subsequent steps.
-                self.request.context = response.context
+                request.context = response.context
                 # Exit this loop if the function has not requested additional extra/required resources.
                 if response.requirements == requirements:
                     break
@@ -192,10 +379,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 +407,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 +420,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,264 +463,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)
-            if self.args.crossplane_v1:
-                revision = self.composite.spec.compositionRevisionRef
-            else:
-                revision = self.composite.spec.crossplane.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:
-                if self.args.crossplane_v1:
-                    refs = self.composite.spec.resourceRefs
-                else:
-                    refs = self.composite.spec.crossplane.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, kapi):
+        namespace = ref.namespace
+        if not namespace:
+            namespace = composite.metadata.namespace
+            if not namespace:
+                namespace = None
+        source = await kapi.get(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)
-
-    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)
+                destination = request.observed.resources[name]
+                if not destination: # Do not override manual observed
+                    await self.set_resource(source, destination, resources, kapi)
 
-    async def fetch_requireds(self, name, selector, resources):
+    async def set_required(self, name, selector, requireds, resources=[], kapi=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, kapi)
                     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:
-            if 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])
-            elif selector.match_labels.labels:
-                for requiest in await kube_list(selector.kind, selector.api_version, selector.namespace, selector.match_labels.labels):
-                    await self.setup_resource(required, items[protobuf.append])
+                            await self.set_resource(resource, items[protobuf.append], resources, kapi)
+        if not len(items) and kapi:
+            if len(selector.match_name):
+                resource = await kapi.get(selector.kind, selector.api_version, selector.namespace, selector.match_name)
+                if resource:
+                    await self.set_resource(resource, items[protobuf.append], resources, kapi)
+            elif len(selector.match_labels.labels):
+                for resource in await kapi.list(selector.kind, selector.api_version, selector.namespace, selector.match_labels.labels):
+                    await self.set_resource(resource, items[protobuf.append], resources, kapi)
+
+    async def set_resource(self, source, destination, resources=[], kapi=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 kapi:
+                    connection = await kapi.get('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
@@ -576,45 +572,50 @@ 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)
+class Kr8sApi:
+    def __init__(self, context=None, logger=None):
+        self.kr8s = importlib.import_module('kr8s')
+        self.inflect = inflect.engine()
+        self.inflect.classical(all=False)
+        self.context = context
+        self.logger = logger
+        self._api = None
+
+    async def api(self):
+        if not self._api:
+            self._api = await self.kr8s.asyncio.api(context=self.context)
+        return self._api
+
+    async def get(self, kind, apiVersion, namespace, name):
+        clazz = self._get_clazz(kind, apiVersion, namespace)
         try:
             fullName = [str(kind), str(apiVersion), str(name)]
             if namespace and len(namespace):
                 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=await self.api())
             else:
-                resource = await clazz.get(str(name), api=self.kube_context)
+                resource = await clazz.get(str(name), api=await self.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)
+        except self.kr8s.NotFoundError:
             resource = None
             result = 'missing'
-        self.logger.debug(f"Resource {result}: {':'.join(fullName)}")
+        if self.logger:
+            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 list(self, kind, apiVersion, namespace, labelSelector):
+        clazz = self._get_clazz(kind, apiVersion, namespace)
         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
-                    },
+                namespace=str(namespace) if namespace and len(namespace) else None,
+                label_selector={
+                    label: str(value)
+                    for label, value in labelSelector
+                },
+                api=await self.api()
             )
         ]
         if self.logger.isEnabledFor(logging.DEBUG):
@@ -628,3 +629,12 @@ class Command(command.Command):
                 result = 'missing'
             self.logger.debug(f"Resources {result}: {':'.join(fullName)}")
         return resources
+
+    def _get_clazz(self, kind, apiVersion, namespaced):
+        kind = str(kind)
+        apiVersion = str(apiVersion)
+        try:
+            return self.kr8s.asyncio.objects.get_class(kind, apiVersion, True)
+        except KeyError:
+            pass
+        return self.kr8s.asyncio.objects.new_class(kind, apiVersion, True, bool(namespaced) and len(namespaced), plural=self.inflect.plural_noun(kind))

{crossplane_function_pythonic-0.4.0.dist-info → crossplane_function_pythonic-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crossplane-function-pythonic
-Version: 0.4.0
+Version: 0.4.2
 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
@@ -19,7 +19,7 @@ Requires-Dist: inflect==7.5.0
 Requires-Dist: kr8s==0.20.15
 Requires-Dist: pyyaml==6.0.3
 Provides-Extra: packages
-Requires-Dist: kopf==1.42.5; extra == 'packages'
+Requires-Dist: kopf==1.43.0; extra == 'packages'
 Provides-Extra: pip-install
 Requires-Dist: pip==26.0.1; extra == 'pip-install'
 Description-Content-Type: text/markdown
@@ -83,7 +83,7 @@ kind: Function
 metadata:
   name: function-pythonic
 spec:
-  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.0
+  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.0
+  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.2
   runtimeConfigRef:
     name: function-pythonic
 --
@@ -241,6 +241,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 |
@@ -616,7 +617,7 @@ kind: Function
 metadata:
   name: function-pythonic
 spec:
-  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.0
+  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.2
   runtimeConfigRef:
     name: function-pythonic
 ---

crossplane_function_pythonic-0.4.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+crossplane/pythonic/__about__.py,sha256=6nxRspkiSsLkBLqHh-X--3FLozkQy1xfr-6ZG0LORbs,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=f9SYjtXVqRx7vse7nQ06Ic6EnnfCYVtpoOmBhR9Jv6g,30451
+crossplane/pythonic/function.py,sha256=uILb3XICcWi2JA5W1xuq37nFQA3_TqbdJefo0-gUUNI,18063
+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=YcKqH0Y4Vj63m6pUb1ptL4gIKcdNLU-WR8TaQ5eGW-M,52987
+crossplane/pythonic/render.py,sha256=e_WQF5TlemfsZim2oGkTPAWuU6BDJztexJ9iBbuFQbo,30417
+crossplane/pythonic/version.py,sha256=-RiB0p146ayqJj0SXfYxTNv49u9Fx9pPgm59Ji2blhc,214
+crossplane_function_pythonic-0.4.2.dist-info/METADATA,sha256=KemrVxbVM4-B6I1P-Gq3hDdqE67sPMCRyfu9gjBY4_w,31561
+crossplane_function_pythonic-0.4.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+crossplane_function_pythonic-0.4.2.dist-info/entry_points.txt,sha256=jJ4baywFDviB9WyAhyhNYF2VOCb6XtbRSjKf7bnBwhg,68
+crossplane_function_pythonic-0.4.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+crossplane_function_pythonic-0.4.2.dist-info/RECORD,,

crossplane_function_pythonic-0.4.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-crossplane/pythonic/__about__.py,sha256=lDX3x8k47nyHPBKNc91376Yj6P16n0uGqBZGVhqsHLY,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=KZxklRR3Z5iiAPxqUbQgaPgoXOIN5T8bcRev4ZUmrrY,3830
-crossplane/pythonic/composite.py,sha256=ERwcyAkbX2AJi3cB1muyXH0zMrDreZcJBGEqmmsweIE,30408
-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=qL3RMsOsuyUaRMHKYOlZEE_5E8BM9wl8K574-cR0agg,52271
-crossplane/pythonic/render.py,sha256=K8pbiFrw76zsJVkwN3lgHcA9P8Mfsmj3jih2LlUinrc,29824
-crossplane/pythonic/version.py,sha256=-RiB0p146ayqJj0SXfYxTNv49u9Fx9pPgm59Ji2blhc,214
-crossplane_function_pythonic-0.4.0.dist-info/METADATA,sha256=I64Dq_5k4brXlGjOtjkswzuNeSlxP2H5Xx_1yn729WE,31501
-crossplane_function_pythonic-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-crossplane_function_pythonic-0.4.0.dist-info/entry_points.txt,sha256=jJ4baywFDviB9WyAhyhNYF2VOCb6XtbRSjKf7bnBwhg,68
-crossplane_function_pythonic-0.4.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-crossplane_function_pythonic-0.4.0.dist-info/RECORD,,