crossplane-function-pythonic 0.0.9.post0__py3-none-any.whl → 0.0.11__py3-none-any.whl

crossplane/pythonic/composite.py

@@ -1,5 +1,6 @@
 
 import datetime
+from google.protobuf.duration_pb2 import Duration
 from crossplane.function.proto.v1 import run_function_pb2 as fnv1
 
 from . import protobuf
@@ -9,8 +10,18 @@ _notset = object()
 
 
 class BaseComposite:
-    def __init__(self, request, response, logger):
+    def __init__(self, request, logger):
         self.request = protobuf.Message(None, 'request', request.DESCRIPTOR, request, 'Function Request')
+        response = fnv1.RunFunctionResponse(
+            meta=fnv1.ResponseMeta(
+                tag=request.meta.tag,
+                ttl=Duration(
+                    seconds=60,
+                ),
+            ),
+            desired=request.desired,
+            context=request.context,
+        )
         self.response = protobuf.Message(None, 'response', response.DESCRIPTOR, response)
         self.logger = logger
         self.credentials = Credentials(self.request)
@@ -36,11 +47,23 @@ class BaseComposite:
 
     @property
     def ttl(self):
+        if self.response.meta.ttl.nanos:
+            return float(self.response.meta.ttl.seconds) + (float(self.response.meta.ttl.nanos) / 1000000000.0)
         return self.response.meta.ttl.seconds
 
     @ttl.setter
     def ttl(self, ttl):
-        self.response.meta.ttl.seconds = ttl    
+        if isinstance(ttl, int):
+            self.response.meta.ttl.seconds = ttl
+            self.response.meta.ttl.nanos = 0
+        elif isinstance(ttl, float):
+            self.response.meta.ttl.seconds = int(ttl)
+            if ttl.is_integer():
+                self.response.meta.ttl.nanos = 0
+            else:
+                self.response.meta.ttl.nanos = int((ttl -  self.response.meta.ttl.seconds) * 1000000000)
+        else:
+            raise ValueError('ttl must be an int or float')
 
     @property
     def ready(self):
@@ -73,22 +96,46 @@ class Credentials:
         return self[key]
 
     def __getitem__(self, key):
-        return self._request.credentials[key].credentials_data.data
+        return Credential(self._request.credentials[key])
 
     def __bool__(self):
-        return bool(_request.credentials)
+        return bool(self._request.credentials)
 
     def __len__(self):
         return len(self._request.credentials)
 
     def __contains__(self, key):
-        return key in _request.credentials
+        return key in self._request.credentials
 
     def __iter__(self):
         for key, resource in self._request.credentials:
             yield key, self[key]
 
 
+class Credential:
+    def __init__(self, credential):
+        self.__dict__['_credential'] = credential
+
+    def __getattr__(self, key):
+        return self[key]
+
+    def __getitem__(self, key):
+        return self._credential.credential_data.data[key]
+
+    def __bool__(self):
+        return bool(self._credential.credential_data.data)
+
+    def __len__(self):
+        return len(self._credential.credential_data.data)
+
+    def __contains__(self, key):
+        return key in self._credential.credential_data.data
+
+    def __iter__(self):
+        for key, resource in self._credential.credential_data.data:
+            yield key, self[key]
+
+
 class Resources:
     def __init__(self, composite):
         self.__dict__['_composite'] = composite
@@ -587,7 +634,7 @@ class Events:
     def __getitem__(self, key):
         if key >= len(self._results):
             return Event()
-        return Event(self._results[ix])
+        return Event(self._results[key])
 
     def __iter__(self):
         for ix in range(len(self._results)):

crossplane/pythonic/function.py

@@ -1,38 +1,26 @@
 """A Crossplane composition function."""
 
 import asyncio
-import base64
-import builtins
 import importlib
 import inspect
 import logging
 import sys
 
 import grpc
-import crossplane.function.response
 from crossplane.function.proto.v1 import run_function_pb2 as fnv1
 from crossplane.function.proto.v1 import run_function_pb2_grpc as grpcv1
 from .. import pythonic
 
-builtins.BaseComposite = pythonic.BaseComposite
-builtins.append = pythonic.append
-builtins.Map = pythonic.Map
-builtins.List = pythonic.List
-builtins.Unknown = pythonic.Unknown
-builtins.Yaml = pythonic.Yaml
-builtins.Json = pythonic.Json
-builtins.B64Encode = pythonic.B64Encode
-builtins.B64Decode = pythonic.B64Decode
-
 logger = logging.getLogger(__name__)
 
 
 class FunctionRunner(grpcv1.FunctionRunnerService):
     """A FunctionRunner handles gRPC RunFunctionRequests."""
 
-    def __init__(self, debug=False):
+    def __init__(self, debug=False, renderUnknowns=False):
         """Create a new FunctionRunner."""
         self.debug = debug
+        self.renderUnknowns = renderUnknowns
         self.clazzes = {}
 
     def invalidate_module(self, module):
@@ -46,9 +34,8 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
     ) -> fnv1.RunFunctionResponse:
         try:
             return await self.run_function(request)
-        except:
-            logger.exception('Exception thrown in run fuction')
-            raise
+        except Exception as e:
+            return self.fatal(request, logger, 'RunFunction', e)
 
     async def run_function(self, request):
         composite = request.observed.composite.resource
@@ -56,27 +43,22 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         name.append(composite['kind'])
         name.append(composite['metadata']['name'])
         logger = logging.getLogger('.'.join(name))
-        if 'iteration' in request.context:
-            request.context['iteration'] = request.context['iteration'] + 1
-        else:
-            request.context['iteration'] = 1
-        logger.debug(f"Starting compose, {ordinal(request.context['iteration'])} pass")
-
-        response = crossplane.function.response.to(request)
 
         if composite['apiVersion'] == 'pythonic.fortra.com/v1alpha1' and composite['kind'] == 'Composite':
-            if 'composite' not in composite['spec']:
-                logger.error('Missing spec "composite"')
-                crossplane.function.response.fatal(response, 'Missing spec "composite"')
-                return response
+            if 'spec' not in composite or 'composite' not in composite['spec']:
+                return self.fatal(request, logger, 'Missing spec "composite"')
             composite = composite['spec']['composite']
         else:
             if 'composite' not in request.input:
-                logger.error('Missing input "composite"')
-                crossplane.function.response.fatal(response, 'Missing input "composite"')
-                return response
+                return self.fatal(request, logger, 'Missing input "composite"')
             composite = request.input['composite']
 
+        # Ideally this is something the Function API provides
+        if 'step' in request.input:
+            step = request.input['step']
+        else:
+            step = str(hash(composite))
+
         clazz = self.clazzes.get(composite)
         if not clazz:
             if '\n' in composite:
@@ -84,81 +66,67 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                 try:
                     exec(composite, module.__dict__)
                 except Exception as e:
-                    logger.exception('Exec exception')
-                    crossplane.function.response.fatal(response, f"Exec exception: {e}")
-                    return response
+                    return self.fatal(request, logger, 'Exec', e)
                 for field in dir(module):
                     value = getattr(module, field)
-                    if inspect.isclass(value) and issubclass(value, BaseComposite):
+                    if inspect.isclass(value) and issubclass(value, pythonic.BaseComposite) and value != pythonic.BaseComposite:
                         if clazz:
-                            logger.error('Composite script has multiple BaseComposite classes')
-                            crossplane.function.response.fatal(response, 'Composite script has multiple BaseComposite classes')
-                            return response
+                            return self.fatal(request, logger, 'Composite script has multiple BaseComposite classes')
                         clazz = value
                 if not clazz:
-                    logger.error('Composite script does not have have a BaseComposite class')
-                    crossplane.function.response.fatal(response, 'Composite script does have have a BaseComposite class')
-                    return response
+                    return self.fatal(request, logger, 'Composite script does not have a BaseComposite class')
             else:
                 composite = composite.rsplit('.', 1)
                 if len(composite) == 1:
-                    logger.error(f"Composite class name does not include module: {composite[0]}")
-                    crossplane.function.response.fatal(response, f"Composite class name does not include module: {composite[0]}")
-                    return response
+                    return self.fatal(request, logger, f"Composite class name does not include module: {composite[0]}")
                 try:
                     module = importlib.import_module(composite[0])
                 except Exception as e:
-                    logger.error(str(e))
-                    crossplane.function.response.fatal(response, f"Import module exception: {e}")
-                    return response
+                    return self.fatal(request, logger, 'Import module', e)
                 clazz = getattr(module, composite[1], None)
                 if not clazz:
-                    logger.error(f"{composite[0]} did not define: {composite[1]}")
-                    crossplane.function.response.fatal(response, f"{composite[0]} did not define: {composite[1]}")
-                    return response
+                    return self.fatal(request, logger, f"{composite[0]} does not define: {composite[1]}")
                 composite = '.'.join(composite)
                 if not inspect.isclass(clazz):
-                    logger.error(f"{composite} is not a class")
-                    crossplane.function.response.fatal(response, f"{composite} is not a class")
-                    return response
-                if not issubclass(clazz, BaseComposite):
-                    logger.error(f"{composite} is not a subclass of BaseComposite")
-                    crossplane.function.response.fatal(response, f"{composite} is not a subclass of BaseComposite")
-                    return response
+                    return self.fatal(request, logger, f"{composite} is not a class")
+                if not issubclass(clazz, pythonic.BaseComposite):
+                    return self.fatal(request, logger, f"{composite} is not a subclass of BaseComposite")
             self.clazzes[composite] = clazz
 
         try:
-            composite = clazz(request, response, logger)
+            composite = clazz(request, logger)
         except Exception as e:
-            logger.exception('Instatiate exception')
-            crossplane.function.response.fatal(response, f"Instatiate exception: {e}")
-            return response
+            return self.fatal(request, logger, 'Instantiate', e)
+
+        step = composite.context._pythonic[step]
+        iteration = (step.iteration or 0) + 1
+        step.iteration = iteration
+        composite.context.iteration = iteration
+        logger.debug(f"Starting compose, {ordinal(len(composite.context._pythonic))} step, {ordinal(iteration)} pass")
 
         try:
             result = composite.compose()
             if asyncio.iscoroutine(result):
                 await result
         except Exception as e:
-            logger.exception('Compose exception')
-            crossplane.function.response.fatal(response, f"Compose exception: {e}")
-            return response
+            return self.fatal(request, logger, 'Compose', e)
 
         requested = []
         for name, required in composite.requireds:
             if required.apiVersion and required.kind:
-                r = Map(apiVersion=required.apiVersion, kind=required.kind)
+                r = pythonic.Map(apiVersion=required.apiVersion, kind=required.kind)
                 if required.namespace:
                     r.namespace = required.namespace
                 if required.matchName:
                     r.matchName = required.matchName
                 for key, value in required.matchLabels:
                     r.matchLabels[key] = value
-                if r != composite.context._requireds[name]:
-                    composite.context._requireds[name] = r
+                if r != step.requireds[name]:
+                    step.requireds[name] = r
                     requested.append(name)
         if requested:
             logger.info(f"Requireds requested: {','.join(requested)}")
-            return response
+            return composite.response._message
 
         unknownResources = []
         warningResources = []
@@ -187,6 +155,8 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                             logger.debug(f'Desired unknown: {destination} = {source}')
                 if resource.observed:
                     resource.desired._patchUnknowns(resource.observed)
+                elif self.renderUnknowns:
+                    resource.desired._renderUnknowns(self.trimFullName)
                 else:
                     del composite.resources[name]
 
@@ -227,7 +197,29 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                         resource.ready = True
 
         logger.info('Completed compose')
-        return response
+        return composite.response._message
+
+    def fatal(self, request, logger, message, exception=None):
+        if exception:
+            message += ' exceptiion'
+            logger.exception(message)
+            m = str(exception)
+            if not m:
+                m = exception.__class__.__name__
+            message += ': ' + m
+        else:
+            logger.error(message)
+        return fnv1.RunFunctionResponse(
+            meta=fnv1.ResponseMeta(
+                tag=request.meta.tag,
+            ),
+            results=[
+                fnv1.Result(
+                    severity=fnv1.SEVERITY_FATAL,
+                    message=message,
+                )
+            ]
+        )
 
     def trimFullName(self, name):
         name = name.split('.')
@@ -236,10 +228,15 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                 ('request', 'extra_resources', None, 'items', 'resource'),
                 ('response', 'desired', 'resources', None, 'resource'),
         ):
-            if len(values) <= len(name):
-                for ix, value in enumerate(values):
-                    if value and value != name[ix] and not name[ix].startswith(f"{value}["):
-                       break
+            if len(values) < len(name):
+                ix = 0
+                for iv, value in enumerate(values):
+                    if value:
+                        if value != name[ix]:
+                            if not name[ix].startswith(f"{values[iv]}[") or iv+1 >= len(values) or values[iv+1]:
+                                break
+                            continue
+                    ix += 1
                 else:
                     ix = 0
                     for value in values:
@@ -251,7 +248,6 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                                 del name[ix]
                             else:
                                 name[ix] = name[ix][len(value):]
-                                ix += 1
                         else:
                             ix += 1
                     break
@@ -268,4 +264,13 @@ def ordinal(ix):
 
 
 class Module:
-    pass
+    def __init__(self):
+        self.BaseComposite = pythonic.BaseComposite
+        self.append = pythonic.append
+        self.Map = pythonic.Map
+        self.List = pythonic.List
+        self.Unknown = pythonic.Unknown
+        self.Yaml = pythonic.Yaml
+        self.Json = pythonic.Json
+        self.B64Encode = pythonic.B64Encode
+        self.B64Decode = pythonic.B64Decode

crossplane/pythonic/main.py

@@ -92,6 +92,11 @@ class Main:
             action='store_true',
             help='Allow oversized protobuf messages'
         )
+        parser.add_argument(
+            '--render-unknowns',
+            action='store_true',
+            help='Render resources with unknowns, useful during local develomment'
+        )
         args = parser.parse_args()
         if not args.tls_certs_dir and not args.insecure:
             print('Either --tls-certs-dir or --insecure must be specified', file=sys.stderr)
@@ -117,7 +122,7 @@ class Main:
                 api_implementation._c_module.SetAllowOversizeProtos(True)
 
         grpc.aio.init_grpc_aio()
-        grpc_runner = function.FunctionRunner(args.debug)
+        grpc_runner = function.FunctionRunner(args.debug, args.render_unknowns)
         grpc_server = grpc.aio.server()
         grpcv1.add_FunctionRunnerServiceServicer_to_server(grpc_runner, grpc_server)
         if args.insecure:

crossplane/pythonic/packages.py

@@ -1,6 +1,5 @@
 
 import base64
-import importlib
 import logging
 import pathlib
 import sys
@@ -10,8 +9,8 @@ import kopf
 
 GRPC_SERVER = None
 GRPC_RUNNER = None
-PACKAGE_LABEL = {'function-pythonic.package': kopf.PRESENT}
 PACKAGES_DIR = None
+PACKAGE_LABEL = {'function-pythonic.package': kopf.PRESENT}
 
 
 def operator(grpc_server, grpc_runner, packages_secrets, packages_namespaces, packages_dir):
@@ -46,95 +45,43 @@ async def cleanup(**_):
 @kopf.on.create('', 'v1', 'configmaps', labels=PACKAGE_LABEL)
 @kopf.on.resume('', 'v1', 'configmaps', labels=PACKAGE_LABEL)
 async def create(body, logger, **_):
-    package_dir, package = get_package_dir(body)
+    package_dir = get_package_dir(body, logger)
     if package_dir:
-        package_dir.mkdir(parents=True, exist_ok=True)
         secret = body['kind'] == 'Secret'
-        invalidate = False
         for name, text in body.get('data', {}).items():
-            package_file = package_dir / name
-            if secret:
-                package_file.write_bytes(base64.b64decode(text.encode('utf-8')))
-            else:
-                package_file.write_text(text)
-            if package_file.suffixes == ['.py']:
-                module = '.'.join(package + [package_file.stem])
-                GRPC_RUNNER.invalidate_module(module)
-                logger.info(f"Created module: {module}")
-            else:
-                logger.info(f"Created file: {'/'.join(package + [name])}")
+            package_file_write(package_dir, name, secret, text, 'Created', logger)
 
 
 @kopf.on.update('', 'v1', 'configmaps', labels=PACKAGE_LABEL)
 async def update(body, old, logger, **_):
-    old_package_dir, old_package = get_package_dir(old)
+    old_package_dir = get_package_dir(old)
     if old_package_dir:
         old_data = old.get('data', {})
     else:
         old_data = {}
     old_names = set(old_data.keys())
-    package_dir, package = get_package_dir(body, logger)
+    package_dir = get_package_dir(body, logger)
     if package_dir:
-        package_dir.mkdir(parents=True, exist_ok=True)
         secret = body['kind'] == 'Secret'
         for name, text in body.get('data', {}).items():
-            package_file = package_dir / name
             if package_dir == old_package_dir and text == old_data.get(name, None):
                 action = 'Unchanged'
             else:
-                if secret:
-                    package_file.write_bytes(base64.b64decode(text.encode('utf-8')))
-                else:
-                    package_file.write_text(text)
                 action = 'Updated' if package_dir == old_package_dir and name in old_names else 'Created'
-            if package_file.suffixes == ['.py']:
-                module = '.'.join(package + [package_file.stem])
-                if action != 'Unchanged':
-                    GRPC_RUNNER.invalidate_module(module)
-                logger.info(f"{action} module: {module}")
-            else:
-                logger.info(f"{action} file: {'/'.join(package + [name])}")
+            package_file_write(package_dir, name, secret, text, action, logger)
             if package_dir == old_package_dir:
                 old_names.discard(name)
     if old_package_dir:
         for name in old_names:
-            package_file = old_package_dir / name
-            package_file.unlink(missing_ok=True)
-            if package_file.suffixes == ['.py']:
-                module = '.'.join(old_package + [package_file.stem])
-                GRPC_RUNNER.invalidate_module(module)
-                logger.info(f"Removed module: {module}")
-            else:
-                logger.info(f"Removed file: {'/'.join(old_package + [name])}")
-        while old_package and old_package_dir.is_dir() and not list(old_package_dir.iterdir()):
-            old_package_dir.rmdir()
-            module = '.'.join(old_package)
-            GRPC_RUNNER.invalidate_module(module)
-            logger.info(f"Removed package: {module}")
-            old_package_dir = old_package_dir.parent
-            old_package.pop()
+            package_file_unlink(old_package_dir, name, 'Removed', logger)
 
 
 @kopf.on.delete('', 'v1', 'configmaps', labels=PACKAGE_LABEL)
 async def delete(old, logger, **_):
-    package_dir, package = get_package_dir(old)
+    package_dir = get_package_dir(old)
     if package_dir:
         for name in old.get('data', {}).keys():
-            package_file = package_dir / name
-            package_file.unlink(missing_ok=True)
-            if package_file.suffixes == ['.py']:
-                module = '.'.join(package + [package_file.stem])
-                GRPC_RUNNER.invalidate_module(module)
-                logger.info(f"Deleted module: {module}")
-            else:
-                logger.info(f"Deleted file: {'/'.join(package + [name])}")
-        while package and package_dir.is_dir() and not list(package_dir.iterdir()):
-            package_dir.rmdir()
-            module = '.'.join(package)
-            GRPC_RUNNER.invalidate_module(module)
-            logger.info(f"Deleted package: {module}")
-            package_dir = package_dir.parent
-            package.pop()
+            package_file_unlink(package_dir, name, 'Deleted', logger)
 
 
 def get_package_dir(body, logger=None):
@@ -142,16 +89,60 @@ def get_package_dir(body, logger=None):
     if package is None:
         if logger:
             logger.error('function-pythonic.package label is missing')
-        return None, None
+        return None
     package_dir = PACKAGES_DIR
-    if package == '':
-        package = []
-    else:
-        package = package.split('.')
-        for segment in package:
+    if package:
+        for segment in package.split('.'):
             if not segment.isidentifier():
                 if logger:
                     logger.error('Package has invalid package name: %s', package)
-                return None, None
+                return None
             package_dir = package_dir / segment
-    return package_dir, package
+    return package_dir
+
+
+def package_file_write(package_dir, name, secret, text, action, logger):
+    package_file = package_dir / name
+    if action != 'Unchanged':
+        package_file.parent.mkdir(parents=True, exist_ok=True)
+        if secret:
+            package_file.write_bytes(base64.b64decode(text.encode('utf-8')))
+        else:
+            package_file.write_text(text)
+    module, name = package_file_name(package_file)
+    if module:
+        if action != 'Unchanged':
+            GRPC_RUNNER.invalidate_module(name)
+        logger.info(f"{action} module: {name}")
+    else:
+        logger.info(f"{action} file: {name}")
+
+
+def package_file_unlink(package_dir, name, action, logger):
+    package_file = package_dir / name
+    package_file.unlink(missing_ok=True)
+    module, name = package_file_name(package_file)
+    if module:
+        GRPC_RUNNER.invalidate_module(name)
+        logger.info(f"{action} module: {name}")
+    else:
+        logger.info(f"{action} file: {name}")
+    package_dir = package_file.parent
+    while (
+            package_dir.is_relative_to(PACKAGES_DIR)
+            and package_dir.is_dir()
+            and not list(package_dir.iterdir())
+    ):
+        package_dir.rmdir()
+        module = str(package_dir.relative_to(PACKAGES_DIR)).replace('/', '.')
+        if module != '.':
+            GRPC_RUNNER.invalidate_module(module)
+            logger.info(f"{action} package: {module}")
+        package_dir = package_dir.parent
+
+
+def package_file_name(package_file):
+    name = str(package_file.relative_to(PACKAGES_DIR))
+    if name.endswith('.py'):
+        return True, name[:-3].replace('/', '.')
+    return False, name

crossplane/pythonic/protobuf.py

@@ -83,16 +83,16 @@ class Message:
             value = None
         if value is None and field.has_default_value:
             value = field.default_value
-        if field.type == field.TYPE_MESSAGE:
+        if field.label == field.LABEL_REPEATED:
+            if field.type == field.TYPE_MESSAGE and field.message_type.GetOptions().map_entry:
+                value = MapMessage(self, key, field.message_type.fields_by_name['value'], value, self._readOnly)
+            else:
+                value = RepeatedMessage(self, key, field, value, self._readOnly)
+        elif field.type == field.TYPE_MESSAGE:
             if field.message_type.name == 'Struct':
                 value = Values(self, key, value, Values.Type.MAP, self._readOnly)
             elif field.message_type.name == 'ListValue':
                 value = Values(self, key, value, Values.Type.LIST, self._readOnly)
-            elif field.label == field.LABEL_REPEATED:
-                if field.message_type.GetOptions().map_entry:
-                    value = MapMessage(self, key, field.message_type, value, self._readOnly)
-                else:
-                    value = RepeatedMessage(self, key, field.message_type, value, self._readOnly)
             else:
                 value = Message(self, key, field.message_type, value, self._readOnly)
         self._cache[key] = value
@@ -147,10 +147,10 @@ class Message:
             else:
                 name = str(self._key)
             if key is not None:
-                if key.isidentifier():
-                    name += f".{key}"
+                if '.' in key:
+                    name += f"[{key}]"
                 else:
-                    name += f"['{key}']"
+                    name += f".{key}"
             return name
         if key is not None:
             return str(key)
@@ -202,15 +202,15 @@ class Message:
         if key not in self._descriptor.fields_by_name:
             raise AttributeError(obj=self, name=key)
         if self._message is not None:
-            del self._message[key]
+            self._message.ClearField(key)
             self._cache.pop(key, None)
 
 
 class MapMessage:
-    def __init__(self, parent, key, descriptor, messages, readOnly=False):
+    def __init__(self, parent, key, field, messages, readOnly=False):
         self.__dict__['_parent'] = parent
         self.__dict__['_key'] = key
-        self.__dict__['_field'] = descriptor.fields_by_name['value']
+        self.__dict__['_field'] = field
         self.__dict__['_messages'] = messages
         self.__dict__['_readOnly'] = readOnly
         self.__dict__['_cache'] = {}
@@ -232,11 +232,6 @@ class MapMessage:
                 value = Values(self, key, value, Values.Type.MAP, self._readOnly)
             elif self._field.message_type.name == 'ListValue':
                 value = Values(self, key, value, Values.Type.LIST, self._readOnly)
-            elif self._field.label == self._field.LABEL_REPEATED:
-                if self._field.message_type.GetOptions().map_entry:
-                    value = MapMessage(self, key, self._field.message_type, value, self._readOnly)
-                else:
-                    value = RepeatedMessage(self, key, self._field.message_type, value, self._readOnly)
             else:
                 value = Message(self, key, self._field.message_type, value, self._readOnly)
         elif self._field.type == self._field.TYPE_BYTES and isinstance(value, bytes):
@@ -266,8 +261,11 @@ class MapMessage:
     def __eq__(self, other):
         if not isinstance(other, MapMessage):
             return False
-        if self._descriptor.full_name != other._descriptor.full_name:
+        if self._field.type != other._field.type:
             return False
+        if self._field.type == self._field.TYPE_MESSAGE:
+            if self._field.message_type.full_name != other._field.message_type.full_name:
+                return False
         if self._messages is None:
             return other._messages is None
         elif other._messages is None:
@@ -294,10 +292,10 @@ class MapMessage:
             else:
                 name = str(self._key)
             if key is not None:
-                if key.isidentifier():
-                    name += f".{key}"
+                if '.' in key:
+                    name += f"[{key}]"
                 else:
-                    name += f"['{key}']"
+                    name += f".{key}"
             return name
         if key is not None:
             return str(key)
@@ -349,10 +347,10 @@ class MapMessage:
 
 
 class RepeatedMessage:
-    def __init__(self, parent, key, descriptor, messages, readOnly=False):
+    def __init__(self, parent, key, field, messages, readOnly=False):
         self._parent = parent
         self._key = key
-        self._descriptor = descriptor
+        self._field = field
         self._messages = messages
         self._readOnly = readOnly
         self._cache = {}
@@ -361,10 +359,20 @@ class RepeatedMessage:
         if key in self._cache:
             return self._cache[key]
         if self._messages is None or key >= len(self._messages):
-            message = None
+            value = None
         else:
-            message = self._messages[key]
-        value = Message(self, key, self._descriptor, message, self._readOnly)
+            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:
+            if self._field.message_type.name == 'Struct':
+                value = Values(self, key, value, Values.Type.MAP, self._readOnly)
+            elif self._field.message_type.name == 'ListValue':
+                value = Values(self, key, value, Values.Type.LIST, self._readOnly)
+            else:
+                value = Message(self, key, self._field.message_type, value, self._readOnly)
+        elif self._field.type == self._field.TYPE_BYTES and isinstance(value, bytes):
+            value = value.decode('utf-8')
         self._cache[key] = value
         return value
 
@@ -394,8 +402,11 @@ class RepeatedMessage:
     def __eq__(self, other):
         if not isinstance(other, RepeatedMessage):
             return False
-        if self._descriptor.full_name != other._descriptor.full_name:
+        if self._field.type != other._field.type:
             return False
+        if self._field.type == self._field.TYPE_MESSAGE:
+            if self._field.message_type.full_name != other._field.message_type.full_name:
+                return False
         if self._messages is None:
             return other._messages is None
         elif other._messages is None:
@@ -440,7 +451,7 @@ class RepeatedMessage:
             raise ValueError(f"{self._readOnly} is read only")
         if self._messages is None:
             self.__dict__['_messages'] = self._parent._create_child(self._key)
-        self._messages.Clear()
+        self._messages.clear()
         self._cache.clear()
         for arg in args:
             self.append(arg)
@@ -451,22 +462,23 @@ class RepeatedMessage:
             raise ValueError(f"{self._readOnly} is read only")
         if self._messages is None:
             self._messages = self._parent._create_child(self._key)
-        if key == append:
-            key = len(self._messages)
-        elif key < 0:
+        if key < 0:
             key = len(self._messages) + key
-        while key >= len(self._messages):
-            self._messages.add()
         if isinstance(message, Message):
             message = message._message
-        self._messages[key] = message
+        if self._field.type == self._field.TYPE_BYTES and isinstance(message, str):
+            message = message.encode('utf-8')
+        if key >= len(self._messages):
+            self._messages.append(message)
+        else:
+            self._messages[key] = message
         self._cache.pop(key, None)
 
     def __delitem__(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
-        if self._values is not None:
-            del self._values[key]
+        if self._messages is not None:
+            del self._messages[key]
             self._cache.pop(key, None)
 
     def append(self, message=None):
@@ -513,7 +525,7 @@ class Values:
         if isinstance(key, str):
             if not self._isMap:
                 if not self._isUnknown:
-                    raise ValueError(f"Invalid key, must be a str for maps: {key}")
+                    raise ValueError(f"Invalid key, must be a int for lists: {key}")
                 self.__dict__['_type'] = self.Type.MAP
             if self._values is None or key not in self._values:
                 struct_value = None
@@ -522,7 +534,7 @@ class Values:
         elif isinstance(key, int):
             if not self._isList:
                 if not self._isUnknown:
-                    raise ValueError(f"Invalid key, must be an int for lists: {key}")
+                    raise ValueError(f"Invalid key, must be a str for maps: {key}")
                 self.__dict__['_type'] = self.Type.LIST
             if self._values is None or key >= len(self._values):
                 struct_value = None
@@ -638,10 +650,10 @@ class Values:
                     if isinstance(key, int):
                         name += f"[{key}]"
                     else:
-                        if key.isidentifier():
-                            name += f".{key}"
+                        if '.' in key:
+                            name += f"[{key}]"
                         else:
-                            name += f"['{key}']"
+                            name += f".{key}"
             return name
         if key is not None:
             return str(key)
@@ -849,7 +861,7 @@ class Values:
         return unknowns
 
     def _patchUnknowns(self, patches):
-        for key in [key for key in self._unknowns.keys()]:
+        for key in list(self._unknowns.keys()):
             self[key] = patches[key]
         if self._isMap:
             for key, value in self:
@@ -864,6 +876,18 @@ class Values:
                     if isinstance(patch, Values) and patch._type == value._type and len(patch):
                         value._patchUnknowns(patch)
 
+    def _renderUnknowns(self, trimFullName):
+        for key, unknown in list(self._unknowns.items()):
+            self[key] = f"UNKNOWN:{trimFullName(unknown._fullName())}"
+        if self._isMap:
+            for key, value in self:
+                if isinstance(value, Values) and len(value):
+                    value._renderUnknowns(trimFullName)
+        elif self._isList:
+            for ix, value in enumerate(self):
+                if isinstance(value, Values) and len(value):
+                    value._renderUnknowns(trimFullName)
+
 
 def _formatObject(object, spec):
     if spec == 'json':
@@ -901,7 +925,7 @@ class _JSONEncoder(json.JSONEncoder):
             return '<<UNEXPECTED>>'
         if isinstance(object, datetime.datetime):
             return object.isoformat()
-        return super(JSONEncoder, self).default(object)
+        return super(_JSONEncoder, self).default(object)
 
 
 class _Dumper(yaml.SafeDumper):

{crossplane_function_pythonic-0.0.9.post0.dist-info → crossplane_function_pythonic-0.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crossplane-function-pythonic
-Version: 0.0.9.post0
+Version: 0.0.11
 Summary: A Python centric Crossplane Function
 Project-URL: Documentation, https://github.com/fortra/function-pythonic#readme
 Project-URL: Issues, https://github.com/fortra/function-pythonic/issues
@@ -81,7 +81,7 @@ kind: Function
 metadata:
   name: function-pythonic
 spec:
-  package: ghcr.io/fortra/function-pythonic:v0.0.9
+  package: ghcr.io/fortra/function-pythonic:v0.0.10
 ```
 ## Composed Resource Dependencies
 
@@ -386,11 +386,11 @@ metadata:
   annotations:
     render.crossplane.io/runtime: Development
 spec:
-  package: ghcr.io/fortra/function-pythonic:v0.0.9
+  package: ghcr.io/fortra/function-pythonic:v0.0.10
 ```
 In one terminal session, run function-pythonic:
 ```shell
-$ function-pythonic --insecure --debug
+$ function-pythonic --insecure --debug --render-unknowns
 [2025-08-21 15:32:37.966] grpc._cython.cygrpc  [DEBUG   ] Using AsyncIOEngine.POLLER as I/O engine
 ```
 In another terminal session, render the Composite:
@@ -488,7 +488,7 @@ kind: Function
 metadata:
   name: function-pythonic
 spec:
-  package: ghcr.io/fortra/function-pythonic:v0.0.9
+  package: ghcr.io/fortra/function-pythonic:v0.0.10
   runtimeConfigRef:
     name: function-pythonic
 ---

crossplane_function_pythonic-0.0.11.dist-info/RECORD

@@ -0,0 +1,11 @@
+crossplane/pythonic/__init__.py,sha256=9Oz3mvFO-8GXb75iEfybSHgVr3p8INdqA201tCusuSo,408
+crossplane/pythonic/composite.py,sha256=a_TVaz4ABRvsyhEEnMpZKFtSrH1mYWmqAn8IXGUtgrc,21519
+crossplane/pythonic/function.py,sha256=8B-chQmuBSSbX3ptOIuE2Tz5KAZ7M5U4-q6wf0Qlwf0,11139
+crossplane/pythonic/main.py,sha256=HILfW6WP-QvOiyfLLu41bAN_2hbkxuw-3DD8rEUMTPQ,6893
+crossplane/pythonic/packages.py,sha256=4TxyT6V79R0m4tJbC8R1gwU_vgHGLXKSBzeTTKd8xGo,5120
+crossplane/pythonic/protobuf.py,sha256=qkzhrXWsaqWHnciKiPavJNcq-qSLcFEoKw-tEJj2Ou4,35037
+crossplane_function_pythonic-0.0.11.dist-info/METADATA,sha256=OKe1qRnvorxI0qVHWxmIJxnEHTPMxW9tK7mZ7H8Z6DA,23468
+crossplane_function_pythonic-0.0.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+crossplane_function_pythonic-0.0.11.dist-info/entry_points.txt,sha256=jJ4baywFDviB9WyAhyhNYF2VOCb6XtbRSjKf7bnBwhg,68
+crossplane_function_pythonic-0.0.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+crossplane_function_pythonic-0.0.11.dist-info/RECORD,,

crossplane_function_pythonic-0.0.9.post0.dist-info/RECORD

@@ -1,11 +0,0 @@
-crossplane/pythonic/__init__.py,sha256=9Oz3mvFO-8GXb75iEfybSHgVr3p8INdqA201tCusuSo,408
-crossplane/pythonic/composite.py,sha256=TxloK31jx3xDmLnalntPXCHNnxuudevdeqPzKcSBO_I,19937
-crossplane/pythonic/function.py,sha256=95asJ_6dFy-KSXiMIkJkxqI264kSqBs4Vh61RAojqSY,11336
-crossplane/pythonic/main.py,sha256=kcpoR4F84IhxLzaPSWWdIoaXmrUyjXofvwQuenVPHSE,6683
-crossplane/pythonic/packages.py,sha256=quxAkmioIGJr9g4uRHsqPwhzyu2f2_UyNHHQmZjSJ8A,6108
-crossplane/pythonic/protobuf.py,sha256=ULcaqeyeqCaz0SSSZXNpeUPh1EQLdAV09Dwj3ltIx7k,33899
-crossplane_function_pythonic-0.0.9.post0.dist-info/METADATA,sha256=FhRLdxg9QMegatxFTBkSNROk93V-G-B1EfWksEBxf3w,23452
-crossplane_function_pythonic-0.0.9.post0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-crossplane_function_pythonic-0.0.9.post0.dist-info/entry_points.txt,sha256=jJ4baywFDviB9WyAhyhNYF2VOCb6XtbRSjKf7bnBwhg,68
-crossplane_function_pythonic-0.0.9.post0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-crossplane_function_pythonic-0.0.9.post0.dist-info/RECORD,,