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

crossplane/pythonic/proto/v1/run_function_pb2.pyi

@@ -0,0 +1,306 @@
+import datetime
+
+from google.protobuf import duration_pb2 as _duration_pb2
+from google.protobuf import struct_pb2 as _struct_pb2
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Iterable as _Iterable, Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class Capability(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    CAPABILITY_UNSPECIFIED: _ClassVar[Capability]
+    CAPABILITY_CAPABILITIES: _ClassVar[Capability]
+    CAPABILITY_REQUIRED_RESOURCES: _ClassVar[Capability]
+    CAPABILITY_CREDENTIALS: _ClassVar[Capability]
+    CAPABILITY_CONDITIONS: _ClassVar[Capability]
+    CAPABILITY_REQUIRED_SCHEMAS: _ClassVar[Capability]
+
+class Ready(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    READY_UNSPECIFIED: _ClassVar[Ready]
+    READY_TRUE: _ClassVar[Ready]
+    READY_FALSE: _ClassVar[Ready]
+
+class Severity(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    SEVERITY_UNSPECIFIED: _ClassVar[Severity]
+    SEVERITY_FATAL: _ClassVar[Severity]
+    SEVERITY_WARNING: _ClassVar[Severity]
+    SEVERITY_NORMAL: _ClassVar[Severity]
+
+class Target(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    TARGET_UNSPECIFIED: _ClassVar[Target]
+    TARGET_COMPOSITE: _ClassVar[Target]
+    TARGET_COMPOSITE_AND_CLAIM: _ClassVar[Target]
+
+class Status(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    STATUS_CONDITION_UNSPECIFIED: _ClassVar[Status]
+    STATUS_CONDITION_UNKNOWN: _ClassVar[Status]
+    STATUS_CONDITION_TRUE: _ClassVar[Status]
+    STATUS_CONDITION_FALSE: _ClassVar[Status]
+CAPABILITY_UNSPECIFIED: Capability
+CAPABILITY_CAPABILITIES: Capability
+CAPABILITY_REQUIRED_RESOURCES: Capability
+CAPABILITY_CREDENTIALS: Capability
+CAPABILITY_CONDITIONS: Capability
+CAPABILITY_REQUIRED_SCHEMAS: Capability
+READY_UNSPECIFIED: Ready
+READY_TRUE: Ready
+READY_FALSE: Ready
+SEVERITY_UNSPECIFIED: Severity
+SEVERITY_FATAL: Severity
+SEVERITY_WARNING: Severity
+SEVERITY_NORMAL: Severity
+TARGET_UNSPECIFIED: Target
+TARGET_COMPOSITE: Target
+TARGET_COMPOSITE_AND_CLAIM: Target
+STATUS_CONDITION_UNSPECIFIED: Status
+STATUS_CONDITION_UNKNOWN: Status
+STATUS_CONDITION_TRUE: Status
+STATUS_CONDITION_FALSE: Status
+
+class RunFunctionRequest(_message.Message):
+    __slots__ = ("meta", "observed", "desired", "input", "context", "extra_resources", "credentials", "required_resources", "required_schemas")
+    class ExtraResourcesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Resources
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Resources, _Mapping]] = ...) -> None: ...
+    class CredentialsEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Credentials
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Credentials, _Mapping]] = ...) -> None: ...
+    class RequiredResourcesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Resources
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Resources, _Mapping]] = ...) -> None: ...
+    class RequiredSchemasEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Schema
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Schema, _Mapping]] = ...) -> None: ...
+    META_FIELD_NUMBER: _ClassVar[int]
+    OBSERVED_FIELD_NUMBER: _ClassVar[int]
+    DESIRED_FIELD_NUMBER: _ClassVar[int]
+    INPUT_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_FIELD_NUMBER: _ClassVar[int]
+    EXTRA_RESOURCES_FIELD_NUMBER: _ClassVar[int]
+    CREDENTIALS_FIELD_NUMBER: _ClassVar[int]
+    REQUIRED_RESOURCES_FIELD_NUMBER: _ClassVar[int]
+    REQUIRED_SCHEMAS_FIELD_NUMBER: _ClassVar[int]
+    meta: RequestMeta
+    observed: State
+    desired: State
+    input: _struct_pb2.Struct
+    context: _struct_pb2.Struct
+    extra_resources: _containers.MessageMap[str, Resources]
+    credentials: _containers.MessageMap[str, Credentials]
+    required_resources: _containers.MessageMap[str, Resources]
+    required_schemas: _containers.MessageMap[str, Schema]
+    def __init__(self, meta: _Optional[_Union[RequestMeta, _Mapping]] = ..., observed: _Optional[_Union[State, _Mapping]] = ..., desired: _Optional[_Union[State, _Mapping]] = ..., input: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., context: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., extra_resources: _Optional[_Mapping[str, Resources]] = ..., credentials: _Optional[_Mapping[str, Credentials]] = ..., required_resources: _Optional[_Mapping[str, Resources]] = ..., required_schemas: _Optional[_Mapping[str, Schema]] = ...) -> None: ...
+
+class Credentials(_message.Message):
+    __slots__ = ("credential_data",)
+    CREDENTIAL_DATA_FIELD_NUMBER: _ClassVar[int]
+    credential_data: CredentialData
+    def __init__(self, credential_data: _Optional[_Union[CredentialData, _Mapping]] = ...) -> None: ...
+
+class CredentialData(_message.Message):
+    __slots__ = ("data",)
+    class DataEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: bytes
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[bytes] = ...) -> None: ...
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    data: _containers.ScalarMap[str, bytes]
+    def __init__(self, data: _Optional[_Mapping[str, bytes]] = ...) -> None: ...
+
+class Resources(_message.Message):
+    __slots__ = ("items",)
+    ITEMS_FIELD_NUMBER: _ClassVar[int]
+    items: _containers.RepeatedCompositeFieldContainer[Resource]
+    def __init__(self, items: _Optional[_Iterable[_Union[Resource, _Mapping]]] = ...) -> None: ...
+
+class RunFunctionResponse(_message.Message):
+    __slots__ = ("meta", "desired", "results", "context", "requirements", "conditions", "output")
+    META_FIELD_NUMBER: _ClassVar[int]
+    DESIRED_FIELD_NUMBER: _ClassVar[int]
+    RESULTS_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_FIELD_NUMBER: _ClassVar[int]
+    REQUIREMENTS_FIELD_NUMBER: _ClassVar[int]
+    CONDITIONS_FIELD_NUMBER: _ClassVar[int]
+    OUTPUT_FIELD_NUMBER: _ClassVar[int]
+    meta: ResponseMeta
+    desired: State
+    results: _containers.RepeatedCompositeFieldContainer[Result]
+    context: _struct_pb2.Struct
+    requirements: Requirements
+    conditions: _containers.RepeatedCompositeFieldContainer[Condition]
+    output: _struct_pb2.Struct
+    def __init__(self, meta: _Optional[_Union[ResponseMeta, _Mapping]] = ..., desired: _Optional[_Union[State, _Mapping]] = ..., results: _Optional[_Iterable[_Union[Result, _Mapping]]] = ..., context: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., requirements: _Optional[_Union[Requirements, _Mapping]] = ..., conditions: _Optional[_Iterable[_Union[Condition, _Mapping]]] = ..., output: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class RequestMeta(_message.Message):
+    __slots__ = ("tag", "capabilities")
+    TAG_FIELD_NUMBER: _ClassVar[int]
+    CAPABILITIES_FIELD_NUMBER: _ClassVar[int]
+    tag: str
+    capabilities: _containers.RepeatedScalarFieldContainer[Capability]
+    def __init__(self, tag: _Optional[str] = ..., capabilities: _Optional[_Iterable[_Union[Capability, str]]] = ...) -> None: ...
+
+class Requirements(_message.Message):
+    __slots__ = ("extra_resources", "resources", "schemas")
+    class ExtraResourcesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: ResourceSelector
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[ResourceSelector, _Mapping]] = ...) -> None: ...
+    class ResourcesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: ResourceSelector
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[ResourceSelector, _Mapping]] = ...) -> None: ...
+    class SchemasEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: SchemaSelector
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[SchemaSelector, _Mapping]] = ...) -> None: ...
+    EXTRA_RESOURCES_FIELD_NUMBER: _ClassVar[int]
+    RESOURCES_FIELD_NUMBER: _ClassVar[int]
+    SCHEMAS_FIELD_NUMBER: _ClassVar[int]
+    extra_resources: _containers.MessageMap[str, ResourceSelector]
+    resources: _containers.MessageMap[str, ResourceSelector]
+    schemas: _containers.MessageMap[str, SchemaSelector]
+    def __init__(self, extra_resources: _Optional[_Mapping[str, ResourceSelector]] = ..., resources: _Optional[_Mapping[str, ResourceSelector]] = ..., schemas: _Optional[_Mapping[str, SchemaSelector]] = ...) -> None: ...
+
+class SchemaSelector(_message.Message):
+    __slots__ = ("api_version", "kind")
+    API_VERSION_FIELD_NUMBER: _ClassVar[int]
+    KIND_FIELD_NUMBER: _ClassVar[int]
+    api_version: str
+    kind: str
+    def __init__(self, api_version: _Optional[str] = ..., kind: _Optional[str] = ...) -> None: ...
+
+class Schema(_message.Message):
+    __slots__ = ("openapi_v3",)
+    OPENAPI_V3_FIELD_NUMBER: _ClassVar[int]
+    openapi_v3: _struct_pb2.Struct
+    def __init__(self, openapi_v3: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class ResourceSelector(_message.Message):
+    __slots__ = ("api_version", "kind", "match_name", "match_labels", "namespace")
+    API_VERSION_FIELD_NUMBER: _ClassVar[int]
+    KIND_FIELD_NUMBER: _ClassVar[int]
+    MATCH_NAME_FIELD_NUMBER: _ClassVar[int]
+    MATCH_LABELS_FIELD_NUMBER: _ClassVar[int]
+    NAMESPACE_FIELD_NUMBER: _ClassVar[int]
+    api_version: str
+    kind: str
+    match_name: str
+    match_labels: MatchLabels
+    namespace: str
+    def __init__(self, api_version: _Optional[str] = ..., kind: _Optional[str] = ..., match_name: _Optional[str] = ..., match_labels: _Optional[_Union[MatchLabels, _Mapping]] = ..., namespace: _Optional[str] = ...) -> None: ...
+
+class MatchLabels(_message.Message):
+    __slots__ = ("labels",)
+    class LabelsEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    LABELS_FIELD_NUMBER: _ClassVar[int]
+    labels: _containers.ScalarMap[str, str]
+    def __init__(self, labels: _Optional[_Mapping[str, str]] = ...) -> None: ...
+
+class ResponseMeta(_message.Message):
+    __slots__ = ("tag", "ttl")
+    TAG_FIELD_NUMBER: _ClassVar[int]
+    TTL_FIELD_NUMBER: _ClassVar[int]
+    tag: str
+    ttl: _duration_pb2.Duration
+    def __init__(self, tag: _Optional[str] = ..., ttl: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ...) -> None: ...
+
+class State(_message.Message):
+    __slots__ = ("composite", "resources")
+    class ResourcesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Resource
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Resource, _Mapping]] = ...) -> None: ...
+    COMPOSITE_FIELD_NUMBER: _ClassVar[int]
+    RESOURCES_FIELD_NUMBER: _ClassVar[int]
+    composite: Resource
+    resources: _containers.MessageMap[str, Resource]
+    def __init__(self, composite: _Optional[_Union[Resource, _Mapping]] = ..., resources: _Optional[_Mapping[str, Resource]] = ...) -> None: ...
+
+class Resource(_message.Message):
+    __slots__ = ("resource", "connection_details", "ready")
+    class ConnectionDetailsEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: bytes
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[bytes] = ...) -> None: ...
+    RESOURCE_FIELD_NUMBER: _ClassVar[int]
+    CONNECTION_DETAILS_FIELD_NUMBER: _ClassVar[int]
+    READY_FIELD_NUMBER: _ClassVar[int]
+    resource: _struct_pb2.Struct
+    connection_details: _containers.ScalarMap[str, bytes]
+    ready: Ready
+    def __init__(self, resource: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., connection_details: _Optional[_Mapping[str, bytes]] = ..., ready: _Optional[_Union[Ready, str]] = ...) -> None: ...
+
+class Result(_message.Message):
+    __slots__ = ("severity", "message", "reason", "target")
+    SEVERITY_FIELD_NUMBER: _ClassVar[int]
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    REASON_FIELD_NUMBER: _ClassVar[int]
+    TARGET_FIELD_NUMBER: _ClassVar[int]
+    severity: Severity
+    message: str
+    reason: str
+    target: Target
+    def __init__(self, severity: _Optional[_Union[Severity, str]] = ..., message: _Optional[str] = ..., reason: _Optional[str] = ..., target: _Optional[_Union[Target, str]] = ...) -> None: ...
+
+class Condition(_message.Message):
+    __slots__ = ("type", "status", "reason", "message", "target")
+    TYPE_FIELD_NUMBER: _ClassVar[int]
+    STATUS_FIELD_NUMBER: _ClassVar[int]
+    REASON_FIELD_NUMBER: _ClassVar[int]
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    TARGET_FIELD_NUMBER: _ClassVar[int]
+    type: str
+    status: Status
+    reason: str
+    message: str
+    target: Target
+    def __init__(self, type: _Optional[str] = ..., status: _Optional[_Union[Status, str]] = ..., reason: _Optional[str] = ..., message: _Optional[str] = ..., target: _Optional[_Union[Target, str]] = ...) -> None: ...

crossplane/pythonic/proto/v1/run_function_pb2_grpc.py

@@ -0,0 +1,101 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from crossplane.pythonic.proto.v1 import run_function_pb2 as crossplane_dot_pythonic_dot_proto_dot_v1_dot_run__function__pb2
+
+GRPC_GENERATED_VERSION = '1.80.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + ' but the generated code in crossplane/pythonic/proto/v1/run_function_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class FunctionRunnerServiceStub(object):
+    """A FunctionRunnerService is a function.
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.RunFunction = channel.unary_unary(
+                '/apiextensions.fn.proto.v1.FunctionRunnerService/RunFunction',
+                request_serializer=crossplane_dot_pythonic_dot_proto_dot_v1_dot_run__function__pb2.RunFunctionRequest.SerializeToString,
+                response_deserializer=crossplane_dot_pythonic_dot_proto_dot_v1_dot_run__function__pb2.RunFunctionResponse.FromString,
+                _registered_method=True)
+
+
+class FunctionRunnerServiceServicer(object):
+    """A FunctionRunnerService is a function.
+    """
+
+    def RunFunction(self, request, context):
+        """RunFunction runs the function.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_FunctionRunnerServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'RunFunction': grpc.unary_unary_rpc_method_handler(
+                    servicer.RunFunction,
+                    request_deserializer=crossplane_dot_pythonic_dot_proto_dot_v1_dot_run__function__pb2.RunFunctionRequest.FromString,
+                    response_serializer=crossplane_dot_pythonic_dot_proto_dot_v1_dot_run__function__pb2.RunFunctionResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'apiextensions.fn.proto.v1.FunctionRunnerService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('apiextensions.fn.proto.v1.FunctionRunnerService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class FunctionRunnerService(object):
+    """A FunctionRunnerService is a function.
+    """
+
+    @staticmethod
+    def RunFunction(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/apiextensions.fn.proto.v1.FunctionRunnerService/RunFunction',
+            crossplane_dot_pythonic_dot_proto_dot_v1_dot_run__function__pb2.RunFunctionRequest.SerializeToString,
+            crossplane_dot_pythonic_dot_proto_dot_v1_dot_run__function__pb2.RunFunctionResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

crossplane/pythonic/protobuf.py

@@ -897,6 +897,32 @@ class Value:
                 return False
         return False
 
+    def __or__(self, other):
+        kind = self._kind
+        if kind not in ('struct_value', 'Struct'):
+            return NotImplemented
+        if not isinstance(other, (Value, dict)):
+            return NotImplemented
+        result = Map()
+        for key, value in self:
+            result[key] = value
+        items = other.items() if isinstance(other, dict) else iter(other)
+        for key, value in items:
+            result[key] = value
+        return result
+
+    def __ror__(self, other):
+        if not isinstance(other, dict):
+            return NotImplemented
+        result = Map()
+        for key, value in other.items():
+            result[key] = value
+        if self._kind not in ('struct_value', 'Struct'):
+            return NotImplemented
+        for key, value in self:
+            result[key] = value
+        return result
+
     def __str__(self):
         return format(self, '')
 
@@ -986,6 +1012,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,19 +3,21 @@ import asyncio
 import importlib
 import inflect
 import inspect
+import json
 import kr8s
 import logging
 import pathlib
 import sys
 import yaml
-from crossplane.function.proto.v1 import run_function_pb2 as fnv1
 
 from . import (
     command,
-    composite,
     function,
     protobuf,
 )
+from .composite import BaseComposite
+from .proto.v1 import run_function_pb2 as fnv1
+
 
 INFLECT = inflect.engine()
 INFLECT.classical(all=False)
@@ -58,7 +60,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 +79,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 +121,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 +213,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 +247,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 +287,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 +380,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 +568,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()