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

crossplane/pythonic/__about__.py

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

crossplane/pythonic/composite.py

@@ -104,11 +104,13 @@ class BaseComposite:
         )
         self.response = protobuf.Message(None, 'response', response.DESCRIPTOR, response)
         self.logger = logger
+        self.capabilities = Capabilities(self.request.meta.capabilities)
         self.parameters = self.request.input.parameters
         self.credentials = Credentials(self.request)
         self.context = self.response.context
         self.environment = self.context['apiextensions.crossplane.io/environment']
         self.requireds = Requireds(self)
+        self.schemas = Schemas(self)
         self.resources = Resources(self)
         self.autoReady = True
         self.usages = False
@@ -123,6 +125,7 @@ class BaseComposite:
         self.metadata = self.observed.metadata
         self.spec = self.observed.spec
         self.status = self.desired.status
+        self.output = self.response.output
         self.conditions = Conditions(observed, self.response)
         self.results = Results(self.response)
         self.events = Results(self.response) # Deprecated, use self.results
@@ -136,6 +139,30 @@ class BaseComposite:
         raise NotImplementedError()
 
 
+class Capabilities:
+    def __init__(self, capabilities):
+        self._capabilities = capabilities
+
+    def __bool__(self):
+        return fnv1.CAPABILITY_CAPABILITIES in self._capabilities
+
+    @property
+    def requireds(self):
+        return fnv1.CAPABILITY_REQUIRED_RESOURCES in self._capabilities if self else None
+
+    @property
+    def credentials(self):
+        return fnv1.CAPABILITY_CREDENTIALS in self._capabilities if self else None
+
+    @property
+    def conditions(self):
+        return fnv1.CAPABILITY_CONDITIONS in self._capabilities if self else None
+
+    @property
+    def schemas(self):
+        return fnv1.CAPABILITY_REQUIRED_SCHEMAS in self._capabilities if self else None
+
+
 class Credentials:
     def __init__(self, request):
         self.__dict__['_request'] = request
@@ -558,6 +585,131 @@ class RequiredResource:
         return bool(self.observed)
 
 
+class Schemas:
+    def __init__(self, composite):
+        self._composite = composite
+        self._cache = {}
+
+    def __getattr__(self, key):
+        return self[key]
+
+    def __getitem__(self, key):
+        schema = self._cache.get(key)
+        if not schema:
+            schema = Schema(self._composite, key)
+            self._cache[key] = schema
+        return schema
+
+    def __bool__(self):
+        return bool(len(self))
+
+    def __len__(self):
+        names = set()
+        for name, schema in self._composite.request.required_schemas:
+            names.add(name)
+        for name, selector in self._composite.response.requirements.schemas:
+            names.add(name)
+        return len(names)
+
+    def __contains__(self, key):
+        if key in self._composite.request.required_schemas:
+            return True
+        if key in self._composite.response.requirements.schemas:
+            return True
+        return False
+
+    def __iter__(self):
+        names = set()
+        for name, schema in self._composite.request.required_schemas:
+            names.add(name)
+        for name, selector in self._composite.response.requirements.schemas:
+            names.add(name)
+        for name in sorted(names):
+            yield name, self[name]
+
+
+class Schema:
+    def __init__(self, composite, name):
+        self.name = name
+        self._selector = composite.response.requirements.schemas[name]
+        self._schema = composite.request.required_schemas[name].openapi_v3
+
+    def __call__(self, kind=_notset, apiVersion=_notset):
+        self._selector()
+        if kind != _notset:
+            # Allow for apiVersion in the first arg and kind in the second arg
+            if '/' in kind or kind == 'v1':
+                if apiVersion != _notset:
+                    self.kind = apiVersion
+                apiVersion = kind
+            else:
+                self.kind = kind
+        if apiVersion != _notset:
+            self.apiVersion = apiVersion
+        return self
+
+    @property
+    def apiVersion(self):
+        return self._selector.api_version
+
+    @apiVersion.setter
+    def apiVersion(self, apiVersion):
+        self._selector.api_version = apiVersion
+
+    @property
+    def kind(self):
+        return self._selector.kind
+
+    @kind.setter
+    def kind(self, kind):
+        self._selector.kind = kind
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        pass
+
+    def __aenter__(self):
+        return self
+
+    def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    def __getattr__(self, key):
+        return self[key]
+
+    def __getitem__(self, key):
+        return self._schema[key]
+
+    def __bool__(self):
+        return bool(self._schema)
+
+    def __len__(self):
+        return len(self._schema)
+
+    def __contains__(self, item):
+        return item in self._schema
+
+    def __iter__(self):
+        for key, value in self._schema:
+            yield key, value
+
+    def __hash__(self):
+        return hash(self._schema)
+
+    def __eq__(self, other):
+        if instance(other, Schema):
+            other = other._schema
+        return self._schema == other
+
+    def __str__(self):
+        return str(self._schema)
+
+    def __format__(self, spec='yaml'):
+        return format(self,_schema, spec)
+
+
 class Conditions:
     def __init__(self, observed, response=None):
         self._observed = observed

crossplane/pythonic/function.py

@@ -121,8 +121,13 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         except Exception as e:
             return self.fatal(request, logger, 'Compose', e)
 
-        if requireds := self.get_requireds(step, composite):
-            logger.debug(f"Requireds requested: {','.join(requireds)}")
+        schemas = self.get_schemas(step, composite)
+        requireds = self.get_requireds(step, composite)
+        if schemas or requireds:
+            if schemas:
+                logger.debug(f"Required schemas: {','.join(schemas)}")
+            if requireds:
+                logger.debug(f"Required resources: {','.join(requireds)}")
         else:
             self.process_usages(composite)
             self.process_unknowns(composite)
@@ -155,11 +160,21 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
             ]
         )
 
+    def get_schemas(self, step, composite):
+        schemas = []
+        for name, schema in composite.schemas:
+            if len(schema.kind) and len(schema.apiVersion):
+                s = pythonic.Map(kind=schema.kind, apiVersion=schema.apiVersion)
+                if s != step.schemas[name]:
+                    step.schemas[name] = s
+                    schemas.append(name)
+        return schemas
+
     def get_requireds(self, step, composite):
         requireds = []
         for name, required in composite.requireds:
-            if len(required.apiVersion) and len(required.kind):
-                r = pythonic.Map(apiVersion=required.apiVersion, kind=required.kind)
+            if len(required.kind) and len(required.apiVersion):
+                r = pythonic.Map(kind=required.kind, apiVersion=required.apiVersion)
                 if len(required.namespace):
                     r.namespace = required.namespace
                 if len(required.matchName):

crossplane/pythonic/grpc.py

@@ -45,6 +45,12 @@ class Command(command.Command):
         parser.add_argument(
             '--packages',
             action='store_true',
+            dest='packages_configmaps',
+            help='Discover python packages from function-pythonic ConfigMaps, deprecated use --packages-configmaps'
+        )
+        parser.add_argument(
+            '--packages-configmaps',
+            action='store_true',
             help='Discover python packages from function-pythonic ConfigMaps.'
         )
         parser.add_argument(
@@ -57,7 +63,17 @@ class Command(command.Command):
             action='append',
             default=[],
             metavar='NAMESPACE',
-            help='Namespaces to discover function-pythonic ConfigMaps in, default is cluster wide.',
+            help='Namespaces to discover function-pythonic ConfigMaps and Secrets in, default is cluster wide.',
+        )
+        parser.add_argument(
+            '--packages-environmentconfigs',
+            action='store_true',
+            help='Also Discover python packages from function-pythonic EnvironmentConfigs.'
+        )
+        parser.add_argument(
+            '--packages-compositions',
+            action='store_true',
+            help='Also Discover python packages from function-pythonic Compositions.'
         )
         parser.add_argument(
             '--packages-dir',
@@ -75,7 +91,9 @@ class Command(command.Command):
         if not self.args.tls_certs_dir and not self.args.insecure:
             print('Either --tls-certs-dir or --insecure must be specified', file=sys.stderr)
             sys.exit(1)
-
+        if (self.args.packages_environmentconfigs or self.args.packages_compositions) and self.args.packages_namespace:
+            print('--packages-namespace cannot be used with --packages-environment-configs or --packages-compositions', file=sys.stderr)
+            sys.exit(1)
         if self.args.pip_install:
             import pip._internal.cli.main
             pip._internal.cli.main.main(['install', '--user', *shlex.split(self.args.pip_install)])
@@ -108,15 +126,18 @@ class Command(command.Command):
             )
         await grpc_server.start()
 
-        if self.args.packages:
+        if self.args.packages_configmaps or self.args.packages_secrets or self.args.packages_environmentconfigs or self.args.packages_compositions:
             from . import packages
             async with asyncio.TaskGroup() as tasks:
                 tasks.create_task(grpc_server.wait_for_termination())
                 tasks.create_task(packages.operator(
                     grpc_server,
                     grpc_runner,
+                    self.args.packages_configmaps,
                     self.args.packages_secrets,
                     self.args.packages_namespace,
+                    self.args.packages_environmentconfigs,
+                    self.args.packages_compositions,
                     self.args.packages_dir,
                 ))
         else:

crossplane/pythonic/packages.py

@@ -10,27 +10,38 @@ import kopf
 GRPC_SERVER = None
 GRPC_RUNNER = None
 PACKAGES_DIR = None
-PACKAGE_LABEL = {'function-pythonic.package': kopf.PRESENT}
+PACKAGE_LABEL = 'function-pythonic.package'
+PACKAGE_LABELS = {PACKAGE_LABEL: kopf.PRESENT}
 
 
-def operator(grpc_server, grpc_runner, packages_secrets, packages_namespaces, packages_dir):
+def operator(grpc_server, grpc_runner, packages_configmaps, packages_secrets, packages_namespaces, packages_environmentconfigs, packages_compositions, packages_dir):
     logging.getLogger('kopf.objects').setLevel(logging.INFO)
     global GRPC_SERVER, GRPC_RUNNER, PACKAGES_DIR
     GRPC_SERVER = grpc_server
     GRPC_RUNNER = grpc_runner
     PACKAGES_DIR = pathlib.Path(packages_dir).expanduser().resolve()
     sys.path.insert(0, str(PACKAGES_DIR))
+    if packages_configmaps:
+        on_resource('', 'v1', 'configmaps')
     if packages_secrets:
-        kopf.on.create('', 'v1', 'secrets', labels=PACKAGE_LABEL)(create)
-        kopf.on.resume('', 'v1', 'secrets', labels=PACKAGE_LABEL)(create)
-        kopf.on.update('', 'v1', 'secrets', labels=PACKAGE_LABEL)(update)
-        kopf.on.delete('', 'v1', 'secrets', labels=PACKAGE_LABEL)(delete)
+        on_resource('', 'v1', 'secrets')
+    if not packages_namespaces:
+        if packages_environmentconfigs:
+            on_resource('apiextensions.crossplane.io', 'v1beta1', 'environmentconfigs')
+        if packages_compositions:
+            on_resource('apiextensions.crossplane.io', 'v1', 'compositions')
     return kopf.operator(
         standalone=True,
         clusterwide=not packages_namespaces,
         namespaces=packages_namespaces,
     )
 
+def on_resource(group, version, plural):
+    kopf.on.create(group, version, plural, labels=PACKAGE_LABELS)(create)
+    kopf.on.resume(group, version, plural, labels=PACKAGE_LABELS)(create)
+    kopf.on.update(group, version, plural, labels=PACKAGE_LABELS)(update)
+    kopf.on.delete(group, version, plural, labels=PACKAGE_LABELS)(delete)
+
 
 @kopf.on.startup()
 async def startup(settings, **_):
@@ -42,107 +53,128 @@ async def cleanup(**_):
     await GRPC_SERVER.stop(5)
 
 
-@kopf.on.create('', 'v1', 'configmaps', labels=PACKAGE_LABEL)
-@kopf.on.resume('', 'v1', 'configmaps', labels=PACKAGE_LABEL)
-async def create(body, logger, **_):
-    package_dir = get_package_dir(body, logger)
-    if package_dir:
-        secret = body['kind'] == 'Secret'
-        for name, text in body.get('data', {}).items():
-            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 = get_package_dir(old)
-    if old_package_dir:
-        old_data = old.get('data', {})
-    else:
-        old_data = {}
-    old_names = set(old_data.keys())
-    package_dir = get_package_dir(body, logger)
-    if package_dir:
-        secret = body['kind'] == 'Secret'
-        for name, text in body.get('data', {}).items():
-            if package_dir == old_package_dir and text == old_data.get(name, None):
-                action = 'Unchanged'
-            else:
-                action = 'Updated' if package_dir == old_package_dir and name in old_names else 'Created'
-            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_unlink(old_package_dir, name, 'Removed', logger)
-
-
-@kopf.on.delete('', 'v1', 'configmaps', labels=PACKAGE_LABEL)
-async def delete(old, logger, **_):
-    package_dir = get_package_dir(old)
-    if package_dir:
-        for name in old.get('data', {}).keys():
-            package_file_unlink(package_dir, name, 'Deleted', logger)
-
-
-def get_package_dir(body, logger=None):
-    package = body.get('metadata', {}).get('labels', {}).get('function-pythonic.package', None)
+async def create(resource, labels, body, logger, **_):
+    resource_create(resource, labels, 'Created', body, logger)
+
+
+async def update(resource, labels, body, old, logger, **_):
+    resource_delete(resource, labels, 'Removed', old, logger)
+    resource_create(resource, labels, 'Added', body, logger)
+
+
+async def delete(resource, labels, body, logger, **_):
+    resource_delete(resource, labels, 'Deleted', body, logger)
+
+
+def resource_create(resource, labels, action, body, logger):
+    package_dir = resource_package_dir(resource, labels, logger)
+    if not package_dir:
+        return
+    if resource.plural in ('configmaps', 'secrets', 'environmentconfigs'):
+        package_create(resource, action, package_dir, body.get('data', {}), logger)
+    elif resource.plural == 'compositions':
+        for step in body.get('spec', {}).get('pipeline', []):
+            input = step.get('input')
+            if input and input.get('apiVersion') == 'pythonic.fn.crossplane.io/v1alpha1':
+                package_create(resource, action, package_dir, input.get('packages', {}), logger)
+
+
+def resource_delete(resource, labels, action, body, logger):
+    package_dir = resource_package_dir(resource, labels, logger)
+    if not package_dir:
+        return
+    if resource.plural in ('configmaps', 'secrets', 'environmentconfigs'):
+        package_delete(action, package_dir, body.get('data', {}), logger)
+    elif resource.plural == 'compositions':
+        for step in body.get('spec', {}).get('pipeline', []):
+            input = step.get('input')
+            if input and input.get('apiVersion') == 'pythonic.fn.crossplane.io/v1alpha1':
+                package_delete(action, package_dir, step.get('input', {}).get('packages', {}), logger)
+
+
+def resource_package_dir(resource, labels, logger):
+    package = labels.get(PACKAGE_LABEL)
     if package is None:
         if logger:
-            logger.error('function-pythonic.package label is missing')
+            logger.error(f"{PACKAGE_LABEL} label is missing")
         return None
     package_dir = PACKAGES_DIR
-    if package:
+    if resource.plural in ('configmaps', 'secrets') and package:
         for segment in package.split('.'):
             if not segment.isidentifier():
-                if logger:
-                    logger.error('Package has invalid package name: %s', package)
+                logger.error('Package has invalid package name: %s', package)
                 return None
             package_dir = package_dir / segment
     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))
+def package_create(resource, action, package_dir, package, logger):
+    for name, value in package.items():
+        if validate_entry(name, value, logger):
+            package_name = package_dir / name
+            if isinstance(value, str):
+                package_name.parent.mkdir(parents=True, exist_ok=True)
+                if resource.plural == 'secrets':
+                    package_name.write_bytes(base64.b64decode(value.encode('utf-8')))
+                else:
+                    package_name.write_text(value)
+                module, name = package_file_name(package_name)
+                if module:
+                    GRPC_RUNNER.invalidate_module(name)
+                    logger.info(f"{action} module: {name}")
+                else:
+                    logger.info(f"{action} file: {name}")
+            elif isinstance(value, dict):
+                package_create(resource, action, package_name, value, logger)
+
+
+def package_delete(action, package_dir, package, logger):
+    for name, value in package.items():
+        if validate_entry(name, value, logger):
+            package_name = package_dir / name
+            if isinstance(value, str):
+                package_name.unlink(missing_ok=True)
+                module, name = package_file_name(package_name)
+                if module:
+                    GRPC_RUNNER.invalidate_module(name)
+                    logger.info(f"{action} module: {name}")
+                else:
+                    logger.info(f"{action} file: {name}")
+                parent = package_name.parent
+                while (
+                        parent.is_relative_to(PACKAGES_DIR)
+                        and parent.is_dir()
+                        and not list(parent.iterdir())
+                ):
+                    parent.rmdir()
+                    module = str(parent.relative_to(PACKAGES_DIR)).replace('/', '.')
+                    if module != '.':
+                        GRPC_RUNNER.invalidate_module(module)
+                        logger.info(f"{action} package: {module}")
+                    parent = parent.parent
+            elif isinstance(value, dict):
+                package_delete(action, package_name, value, logger)
+
+
+def validate_entry(name, value, logger):
+    if isinstance(value, str):
+        if not name.endswith('.py'):
+            if '.' in name or '/' in name:
+                logger.error(f"Python package file name is not valid: {name}")
+                return False
+            return True
+        name = name[:-3]
+    elif not isinstance(value, dict):
+        logger.error(f"Python package \"{name}\" value is not a valid type: {value.__class__}")
+        return False
+    if name.isidentifier():
+        return True
+    logger.error(f"Python package name is not an identifier: {name}")
+    return False
+
+
+def package_file_name(package_name):
+    name = str(package_name.relative_to(PACKAGES_DIR))
     if name.endswith('.py'):
         return True, name[:-3].replace('/', '.')
     return False, name

crossplane/pythonic/protobuf.py

@@ -986,6 +986,8 @@ class Value:
         elif len(args):
             for key in range(len(args)):
                 self[key] = args[key]
+        else:
+            self._ensure_map()
         return self
 
     def __setattr__(self, key, value):

crossplane/pythonic/render.py

@@ -3,6 +3,7 @@ import asyncio
 import importlib
 import inflect
 import inspect
+import json
 import kr8s
 import logging
 import pathlib
@@ -12,10 +13,10 @@ from crossplane.function.proto.v1 import run_function_pb2 as fnv1
 
 from . import (
     command,
-    composite,
     function,
     protobuf,
 )
+from .composite import BaseComposite
 
 INFLECT = inflect.engine()
 INFLECT.classical(all=False)
@@ -58,7 +59,7 @@ class Command(command.Command):
             action='append',
             default=[],
             metavar='KEY=VALUE',
-            help='Context key-value pairs to pass to the Function pipeline. Values must be sYAML/JSON. Keys take precedence over --context-files.',
+            help='Context key-value pairs to pass to the Function pipeline. Values must be YAML/JSON. Keys take precedence over --context-files.',
         )
         parser.add_argument(
             '--observed-resources', '-o',
@@ -77,12 +78,12 @@ class Command(command.Command):
             help='A YAML file or directory of YAML files specifying required resources to pass to the Function pipeline.',
         )
         parser.add_argument(
-            '--secret-store', '-s',
+            '--required-schemas', '-s',
             action='append',
             type=pathlib.Path,
             default=[],
             metavar='PATH',
-            help='A YAML file or directory of YAML files specifying Secrets to use to resolve connections and credentials.',
+            help='A JSON file or directory of JSON files specifying required schemas to pass to the Function pipeline.',
         )
         parser.add_argument(
             '--include-full-xr', '-x',
@@ -119,11 +120,10 @@ class Command(command.Command):
         observed = self.collect_resources(self.args.observed_resources)
         composition = await self.setup_composition(composite, api)
         resources = self.collect_resources(self.args.required_resources)
-        resources += self.collect_resources(self.args.secret_store)
-        resources.sort(key=lambda resource: str(resource.metadata.name))
+        schemas = self.collect_schemas(self.args.required_schemas)
         context = self.setup_context()
 
-        render = await self.render(composite, observed, composition, resources, context, api, self.args.render_unknowns, self.args.crossplane_v1)
+        render = await self.render(composite, observed, composition, resources, schemas, context, api, self.args.render_unknowns, self.args.crossplane_v1)
         if not render:
             sys.exit(1)
 
@@ -212,7 +212,7 @@ class Command(command.Command):
         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):
+        if not issubclass(clazz, BaseComposite):
             print(f"Composition class {self.args.composition} is not a subclass of BaseComposite", file=sys.stderr)
             sys.exit(1)
         return self.create_composition(composite, self.args.composition)
@@ -246,8 +246,25 @@ class Command(command.Command):
             else:
                 print(f"Specified resource is not a file or a directory: {entry}", file=sys.stderr)
                 sys.exit(1)
+        resources.sort(key=lambda resource: str(resource.metadata.name))
         return resources
 
+    def collect_schemas(self, entries):
+        schemas = []
+        for entry in entries:
+            if entry.is_file():
+                document = json.loads(entry.read_text())
+                schemas.append(protobuf.Value(None, None, document))
+            elif entry.is_dir():
+                for file in entry.iterdir():
+                    if file.suffix == '.json':
+                        document = json.loads(file.read_text())
+                        schemas.append(protobuf.Value(None, None, document))
+            else:
+                print(f"Specified resource is not a file or a directory: {entry}", file=sys.stderr)
+                sys.exit(1)
+        return schemas
+
     def setup_context(self):
         # Load the request context with any specified command line options.
         context = protobuf.Map()
@@ -269,7 +286,7 @@ class Command(command.Command):
             context[key_value[0]] = protobuf.Yaml(key_value[1])
         return context
 
-    async def render(self, composite, observed=[], composition=None, resources=[], context=None, api=None, render_unknowns=False, crossplane_v1=False, composite_observeds=True):
+    async def render(self, composite, observed=[], composition=None, resources=[], schemas=[], context=None, api=None, render_unknowns=False, crossplane_v1=False, composite_observeds=True):
         # Create the request used when running Composition steps.
         request = protobuf.Message(None, 'request', fnv1.RunFunctionRequest.DESCRIPTOR, fnv1.RunFunctionRequest())
         if context is not None:
@@ -362,6 +379,10 @@ class Command(command.Command):
                 request.extra_resources()
                 for name, selector in requirements.extra_resources:
                     await self.set_required(name, selector, request.extra_resources, resources, api)
+                # Fetch the schemas requested.
+                request.required_schemas()
+                for name, selector in requirements.schemas:
+                    await self.set_schema(name, selector, request.required_schemas, schemas, api)
                 # Run the step using the function-pythonic function runner.
                 response = protobuf.Message(
                     None,
@@ -546,6 +567,81 @@ class Command(command.Command):
                 for key, value in connection.data:
                     destination.connection_details[key] = protobuf.B64Decode(value)
 
+    async def set_schema(self, name, selector, schemas, documents=[], api=None):
+        if not name:
+            return
+        name = str(name)
+        schema = schemas[name].openapi_v3
+        schema() # Force this to get created
+        gvk = protobuf.Map(kind=selector.kind)
+        version = str(selector.api_version)
+        if '/' in version:
+            gvk.group, gvk.version = version.split('/', 1)
+        else:
+            gvk.group = ''
+            gvk.version = version
+        for document in documents:
+            if self.find_schema(gvk, document, schema):
+                return
+        if api:
+            if gvk.group == '':
+                url = f"api/{gvk.version}"
+            else:
+                url = f"apis/{gvk.group}/{gvk.version}"
+            try:
+                async with api.call_api(base='/openapi/v3', version='', url=url) as response:
+                    document = protobuf.Value(None, None, response.json())
+            except kr8s.NotFoundError:
+                return
+            self.find_schema(gvk, document, schema)
+
+    def find_schema(self, gvk, document, schema):
+        for name, s in document.components.schemas:
+            gvks = s['x-kubernetes-group-version-kind']
+            if len(gvks) == 1 and gvks[0] == gvk:
+                self.resolve_ref(document, set(), f"#/components/schemas/{name}", schema)
+                return True
+        return False
+
+    def resolve_ref(self, document, visiting, ref, schema):
+        if not ref:
+            return
+        ref = str(ref)
+        if ref in visiting:
+            return
+        d = None
+        for segment in ref.split('/'):
+            if segment == '#':
+                d = document
+            else:
+                d = d[segment]
+        if not d:
+            return
+        visiting.add(ref)
+        try:
+            for name, value in d:
+                self.copy_schema(document, visiting, name, value, schema)
+        finally:
+            visiting.remove(ref)
+
+    def copy_schema(self, document, visiting, key, value, schema):
+        if key == '$ref':
+            self.resolve_ref(document, visiting, value, schema)
+        elif key == 'allOf':
+            if value._isList and len(value) == 1:
+                self.resolve_ref(document, visiting, value[0]['$ref'], schema)
+        else:
+            if value._isMap:
+                s = schema[key]
+                for n, v in value:
+                    self.copy_schema(document, visiting, n, v, s)
+            elif value._isList:
+                s = schema[key]
+                for ix, v in enumerate(value):
+                    self.copy_schema(document, visiting, ix, v, s)
+            else:
+                schema[key] = value
+
     def copy_resource(self, source, destination):
         destination.resource = source.resource
         destination.connection_details()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crossplane-function-pythonic
-Version: 0.5.0
+Version: 0.6.0
 Summary: A Python centric Crossplane Function
 Project-URL: Documentation, https://github.com/crossplane-contrib/function-pythonic#readme
 Project-URL: Issues, https://github.com/crossplane-contrib/function-pythonic/issues
@@ -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.43.0; extra == 'packages'
+Requires-Dist: kopf==1.44.4; 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.2
+  package: xpkg.crossplane.io/crossplane-contrib/function-pythonic:v0.6.0
 ```
 
 ### Crossplane V1
@@ -95,7 +95,7 @@ kind: Function
 metadata:
   name: function-pythonic
 spec:
-  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.2
+  package: xpkg.crossplane.io/crossplane-contrib/function-pythonic:v0.6.0
   runtimeConfigRef:
     name: function-pythonic
 --
@@ -292,6 +292,7 @@ The BaseComposite class provides the following fields for manipulating the Compo
 | self.metadata | Map | The composite observed metadata |
 | self.spec | Map | The composite observed spec |
 | self.status | Map | The composite desired and observed status, read from observed if not in desired |
+| self.output | Map | The step output, only used during Operations |
 | self.conditions | Conditions | The composite desired and observed conditions, read from observed if not in desired |
 | self.results | Results | Returned results applied to the Composite and optionally on the Claim |
 | self.connectionSecret | Map | The name, namespace, and resourceName to use when generating the connection secret in Crossplane v2 |
@@ -306,17 +307,31 @@ The BaseComposite also provides access to the following Crossplane Function leve
 | self.request | Message | Low level direct access to the RunFunctionRequest message |
 | self.response | Message | Low level direct access to the RunFunctionResponse message |
 | self.logger | Logger | Python logger to log messages to the running function stdout |
+| self.capabilities | Capabilities | This Crossplane version's Capabilities |
 | self.parameters | Map | The configured step parameters |
 | self.ttl | Integer | Get or set the response TTL, in seconds |
 | self.credentials | Credentials | The request credentials |
 | self.context | Map | The response context, initialized from the request context |
 | self.environment | Map | The response environment, initialized from the request context environment |
 | self.requireds | Requireds | Request and read additional local Kubernetes resources |
+| self.schemas | Schemas | Request and read CustomResourceDefinition schemas |
 | self.resources | Resources | Define and process composed resources |
 | self.usages| Boolean | Generate Crossplane Usages for resource dependencies, default False |
 | self.autoReady | Boolean | Perform auto ready processing on all composed resources, default True |
 | self.unknownsFatal | Boolean | Terminate the composition if already created resources are assigned unknown values, default False |
 
+### Capabiities
+
+The Capabilities of the Crossplane version calling function-pythonic.
+
+| Field | Type | Description |
+| ----- | ---- | ----------- |
+| bool(Capabilities) | Boolean | Whether or not the Crossplane version supports Capabilities |
+| Capabiities.requireds | Boolean | Functions can return required resources and Crossplane will fetch the required resources |
+| Capabiities.credentials | Boolean | Functions can receive credentials from secrets specified in the Composition |
+| Capabiities.conditions | Boolean | Functions can return status conditions to be applied to the XR and optionally its claim |
+| Capabiities.schemas | Boolean | Functions can request OpenAPI schemas and Crossplane will return them |
+
 ### Composed Resources
 
 Creating and accessing composed resources is performed using the `BaseComposite.resources` field.
@@ -350,7 +365,7 @@ Resource class:
 
 Creating and accessing required resources is performed using the `BaseComposite.requireds` field.
 `BaseComposite.requireds` is a dictionary of the required resources whose key is the required
-resource name. The value returned when getting a required resource from BaseComposite is the
+schema name. The value returned when getting a required resource from BaseComposite is the
 following RequiredResources class:
 
 | Field | Type | Description |
@@ -363,9 +378,6 @@ following RequiredResources class:
 | RequiredResources.matchName | String | The names to match when returning the required resources |
 | RequiredResources.matchLabels | Map | The labels to match when returning the required resources |
 
-The current version of crossplane-sdk-python used by function-pythonic does not support namespace
-selection. For now, use matchLabels and filter the results if required.
-
 RequiredResources acts like a Python list to provide access to the found required resources.
 Each resource in the list is the following RequiredResource class:
 
@@ -382,6 +394,22 @@ Each resource in the list is the following RequiredResource class:
 | RequiredResource.conditions | Map | The required resource conditions |
 | RequiredResource.connection | Map | The required resource connection details |
 
+### Required Schemas
+
+Creating and accessing required schemas is performed using the `BaseComposite.schemas` field.
+`BaseComposite.schemas` is a dictionary of the required schema whose key is the required
+resource name. The value returned when getting a required resource from BaseComposite is the
+following Schema class:
+
+| Field | Type | Description |
+| ----- | ---- | ----------- |
+| Schema(apiVersion,kind) | Schema | Reset the required schema and set the optional parameters |
+| Schema.name | String | The required schema name |
+| Schema.apiVersion | String | The required schema selector apiVersion |
+| Schema.kind | String | The required schema selector kind |
+| Schema.\_\_getitem\_\_ | Map | The required schema openAPIV3Schema |
+| Schema.\_\_getattr\_\_ | Map | The required schema openAPIV3Schema |
+
 ### Conditions
 
 The `BaseComposite.conditions`, `Resource.conditions`, and `RequiredResource.conditions` fields
@@ -500,7 +528,7 @@ $ function-pythonic render --help
 usage: Crossplane Function Pythonic render [-h] [--debug] [--log-name-width WIDTH] [--logger-level LOGGER=LEVEL] [--python-path DIRECTORY]
                                            [--render-unknowns] [--allow-oversize-protos] [--crossplane-v1] [--kube-context CONTEXT]
                                            [--context-files KEY=PATH] [--context-values KEY=VALUE] [--observed-resources PATH]
-                                           [--required-resources PATH] [--secret-store PATH] [--include-full-xr] [--include-connection-xr]
+                                           [--required-resources PATH] [--required-schemas PATH] [--include-full-xr] [--include-connection-xr]
                                            [--include-function-results] [--include-context]
                                            COMPOSITE [COMPOSITION]
 
@@ -532,8 +560,8 @@ options:
                         A YAML file or directory of YAML files specifying the observed state of composed resources.
   --required-resources, -e PATH
                         A YAML file or directory of YAML files specifying required resources to pass to the Function pipeline.
-  --secret-store, -s PATH
-                        A YAML file or directory of YAML files specifying Secrets to use to resolve connections and credentials.
+  --required-schemas, -s PATH
+                        A JSON file or directory of JSON files specifying required schemas to pass to the Function pipeline.
   --include-full-xr, -x
                         Include a direct copy of the input XR's spedc and metadata fields in the rendered output.
   --include-connection-xr
@@ -602,9 +630,15 @@ status:
 Most of the examples contain a `render.sh` command which uses `function-pythonic render` to
 render the example.
 
-## ConfigMap Packages
+## Shared Python Packages
+
+Python packages and modules can be added to the function-pythonic runtime
+by including the python code in any of the following resources: ConfigMap,
+Secret, EnvironmentConfig, or Composition
+
+### ConfigMap Packages
 
-ConfigMap based python packages are enable using the `--packages` and
+ConfigMap based python packages are enable using the `--packages-configmaps` and
 `--packages-namespace` command line options. ConfigMaps with the label
 `function-pythonic.package` will be incorporated in the python path at
 the location configured in the label value. For example, the following
@@ -666,7 +700,7 @@ data:
       composite: example.pythonic.features.FeatureOneComposite
     ...
 ```
-This requires enabling the the packages support using the `--packages` command
+This requires enabling the the packages support using the `--packages-configmaps` command
 line option in the DeploymentRuntimeConfig and configuring the required
 Kubernetes RBAC permissions. For example:
 ```yaml
@@ -675,7 +709,7 @@ kind: Function
 metadata:
   name: function-pythonic
 spec:
-  package: xpkg.upbound.io/crossplane-contrib/function-pythonic:v0.4.2
+  package: xpkg.crossplane.io/crossplane-contrib/function-pythonic:v0.6.0
   runtimeConfigRef:
     name: function-pythonic
 ---
@@ -737,9 +771,71 @@ ClusterRole permissions. The `--packages-namespace` command line option will res
 to only using the supplied namespace. This option can be invoked multiple times.
 The above RBAC permission can then be per namespace RBAC Role permissions.
 
+### Secret Packages
+
 Secrets can also be used in an identical manner as ConfigMaps by enabling the
 `--packages-secrets` command line option. Secrets permissions need to be
-added to the above RBAC configuration.
+added to the above RBAC configuration. Secret based python packages also enable
+provisioning files with binary data.
+
+### EnvironmentConfig Packages
+
+EnvironmentConfig based provisioning enable an entire package and module
+directory structure. Use the `--packages-environmentconfigs` command line option
+and configure the ClusterRole RBAC access.
+```yaml
+apiVersion: apiextensions.crossplane.io/v1beta1
+kind: EnvironmentConfig
+metadata:
+  name: test
+  labels:
+    function-pythonic.package: 'true'
+data:
+  arootpackage:
+    asubpackage:
+      bmodule.py: |
+        def hello(where):
+          return f"Hello, {where}!"
+    amodule.py: |
+      def goodby(where):
+        return f"Goodby, {where}!"
+```
+### Composition Packages
+
+Composition based provisioning works just like EnvironmentConfig where a
+directory structure is created. Use the `--packages-compositions` command line option
+and configure the ClusterRole RBAC access. The main reason to use Composition
+based provision is because Compositions can be included in a Crossplane
+Configuration Package.
+```yaml
+apiVersion: apiextensions.crossplane.io/v1
+kind: Composition
+metadata:
+  labels:
+    function-pythonic.package: 'true'
+  name: test
+spec:
+  compositeTypeRef:
+    apiVersion: code.pythoni.com/v1alpha1
+    kind: Code
+  mode: Pipeline
+  pipeline:
+  - step: render
+    functionRef:
+      name: function-pythonic
+    input:
+      apiVersion: pythonic.fn.crossplane.io/v1alpha1
+      kind: Composite
+      packages:
+        arootpackage:
+          asubpackage:
+            bmodule.py: |
+              def hello(where):
+                return f"Hello, {where}!"
+          amodule.py: |
+            def goodby(where):
+              return f"Goodby, {where}!"
+```
 
 ## Step Parameters
 

crossplane_function_pythonic-0.6.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+crossplane/pythonic/__about__.py,sha256=v3R2QlL6bK_t2oKW7b96iHro1p7Iag8djZQbp6xQLPE,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=gQ7DzY0kn8J2lUWH9hYVLZB6NYDBo0IJJwUDBooTNsc,34459
+crossplane/pythonic/function.py,sha256=2f8-J5sgDrtn3z6Fxu2JODnr6VsjBESIVSJ5Hd4LssY,18573
+crossplane/pythonic/grpc.py,sha256=WFyxkIh-nNtOswQhtN1V3e-8Qr79fDcNht8OpvihHYM,5694
+crossplane/pythonic/main.py,sha256=ujUa_FYElQSGqnhZ-0NJrD3kSyYjfRbIp79FV2Yl7hs,599
+crossplane/pythonic/packages.py,sha256=cOlF-wo2CzknwFPAfuwgCiwdT5vDE4n7oBMfQErVzbA,7023
+crossplane/pythonic/protobuf.py,sha256=-HFHlGV1zMi5DmTOxe9qcBMJ0bZKH2hEkJH1CF7nvp4,53128
+crossplane/pythonic/render.py,sha256=qIcUsE6iCka6VwUlhpN1BZhHvbl3GL6X3dPepmdlDV8,33822
+crossplane/pythonic/version.py,sha256=-RiB0p146ayqJj0SXfYxTNv49u9Fx9pPgm59Ji2blhc,214
+crossplane_function_pythonic-0.6.0.dist-info/METADATA,sha256=kaKnXE14jueu5X-kf8k2H904NIg9qV-o4WGOJOaUqqs,36678
+crossplane_function_pythonic-0.6.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+crossplane_function_pythonic-0.6.0.dist-info/entry_points.txt,sha256=jJ4baywFDviB9WyAhyhNYF2VOCb6XtbRSjKf7bnBwhg,68
+crossplane_function_pythonic-0.6.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+crossplane_function_pythonic-0.6.0.dist-info/RECORD,,

crossplane_function_pythonic-0.5.0.dist-info/RECORD

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