crossplane-function-pythonic 0.6.0__tar.gz → 0.6.2__tar.gz

{crossplane_function_pythonic-0.6.0 → crossplane_function_pythonic-0.6.2}/.gitignore

@@ -212,6 +212,7 @@ __marimo__/
 
 # function-pythonic
 crossplane/pythonic/__version__.py
+crossplane/pythonic/proto/v1/run_function_pb2*
 pocs/
 pythonic-packages/
 tests/protobuf/pytest_pb2*

{crossplane_function_pythonic-0.6.0 → crossplane_function_pythonic-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: crossplane-function-pythonic
-Version: 0.6.0
+Version: 0.6.2
 Summary: A Python centric Crossplane Function
 Project-URL: Documentation, https://github.com/crossplane-contrib/function-pythonic#readme
 Project-URL: Issues, https://github.com/crossplane-contrib/function-pythonic/issues
@@ -14,14 +14,15 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: <3.15,>=3.12
-Requires-Dist: crossplane-function-sdk-python==0.11.0
+Requires-Dist: grpcio==1.83.0
 Requires-Dist: inflect==7.5.0
 Requires-Dist: kr8s==0.20.15
+Requires-Dist: protobuf==7.35.1
 Requires-Dist: pyyaml==6.0.3
 Provides-Extra: packages
-Requires-Dist: kopf==1.44.4; extra == 'packages'
+Requires-Dist: kopf==1.44.6; extra == 'packages'
 Provides-Extra: pip-install
-Requires-Dist: pip==26.0.1; extra == 'pip-install'
+Requires-Dist: pip==26.2.1; extra == 'pip-install'
 Description-Content-Type: text/markdown
 
 # function-pythonic
@@ -314,6 +315,7 @@ The BaseComposite also provides access to the following Crossplane Function leve
 | 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.watched | RequiredResource | THe WatchOperation's changed resource |
 | 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 |

{crossplane_function_pythonic-0.6.0 → crossplane_function_pythonic-0.6.2}/README.md

@@ -288,6 +288,7 @@ The BaseComposite also provides access to the following Crossplane Function leve
 | 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.watched | RequiredResource | THe WatchOperation's changed resource |
 | 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 |

{crossplane_function_pythonic-0.6.0 → crossplane_function_pythonic-0.6.2}/crossplane/pythonic/__about__.py

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

{crossplane_function_pythonic-0.6.0 → crossplane_function_pythonic-0.6.2}/crossplane/pythonic/composite.py

@@ -1,10 +1,12 @@
 
 import datetime
 from google.protobuf.duration_pb2 import Duration
-from crossplane.function.proto.v1 import run_function_pb2 as fnv1
 
-from . import auto_ready
-from . import protobuf
+from . import (
+    auto_ready,
+    protobuf,
+)
+from .proto.v1 import run_function_pb2 as fnv1
 
 
 _notset = object()
@@ -110,6 +112,7 @@ class BaseComposite:
         self.context = self.response.context
         self.environment = self.context['apiextensions.crossplane.io/environment']
         self.requireds = Requireds(self)
+        self.watched = self.requireds['ops.crossplane.io/watched-resource'][0]
         self.schemas = Schemas(self)
         self.resources = Resources(self)
         self.autoReady = True

{crossplane_function_pythonic-0.6.0 → crossplane_function_pythonic-0.6.2}/crossplane/pythonic/function.py

@@ -7,8 +7,8 @@ import logging
 import sys
 
 import grpc
-from crossplane.function.proto.v1 import run_function_pb2 as fnv1
-from crossplane.function.proto.v1 import run_function_pb2_grpc as grpcv1
+from .proto.v1 import run_function_pb2 as fnv1
+from .proto.v1 import run_function_pb2_grpc as grpcv1
 from .. import pythonic
 
 logger = logging.getLogger(__name__)
@@ -43,19 +43,26 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
 
     async def run_function(self, request):
         composite = request.observed.composite.resource
-        name = list(reversed(composite['apiVersion'].split('/')[0].split('.')))
-        name.append(composite['kind'])
-        name.append(composite['metadata']['name'])
-        logger = logging.getLogger('.'.join(name))
-
-        if 'inlined' in request.input and request.input['inlined']:
-            if 'spec' not in composite or request.input['inlined'] not in composite['spec']:
-                return self.fatal(request, logger, f"Missing inlined spec.{request.input['inlined']}")
-            composite = composite['spec'][request.input['inlined']]
+        if composite and composite.fields:
+            name = list(reversed(composite['apiVersion'].split('/')[0].split('.')))
+            name.append(composite['kind'])
+            name.append(composite['metadata']['name'])
+            logger = logging.getLogger('.'.join(name))
+            if 'inlined' in request.input and request.input['inlined']:
+                if 'spec' not in composite or request.input['inlined'] not in composite['spec']:
+                    return self.fatal(request, logger, f"Missing inlined spec.{request.input['inlined']}")
+                composite = composite['spec'][request.input['inlined']]
+            else:
+                if 'composite' not in request.input:
+                    return self.fatal(request, logger, 'Missing composition input "composite"')
+                composite = request.input['composite']
+            operation = False
         else:
+            logger = logging.getLogger('operation')
             if 'composite' not in request.input:
-                return self.fatal(request, logger, 'Missing input "composite"')
+                return self.fatal(request, logger, 'Missing operation input "composite"')
             composite = request.input['composite']
+            operation = True
 
         # Ideally this is something the Function API provides
         if 'step' in request.input:
@@ -97,6 +104,12 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                     return self.fatal(request, logger, f"{composite} is not a subclass of BaseComposite")
             self.clazzes[composite] = clazz
 
+        if operation:
+            if '\n' in composite:
+                logger = logging.getLogger(f"operation.{clazz.__name__}")
+            else:
+                logger = logging.getLogger(f"operation.{composite}")
+
         try:
             composite = clazz(self.crossplane_v1, request, logger)
         except Exception as e:

{crossplane_function_pythonic-0.6.0 → crossplane_function_pythonic-0.6.2}/crossplane/pythonic/grpc.py

@@ -7,7 +7,6 @@ import shlex
 import signal
 import sys
 
-import crossplane.function.proto.v1.run_function_pb2_grpc as grpcv1
 import grpc
 
 from . import (
@@ -15,6 +14,8 @@ from . import (
     command,
     function,
 )
+from .proto.v1 import run_function_pb2_grpc as grpcv1
+
 
 logger = logging.getLogger(__name__)
 

{crossplane_function_pythonic-0.6.0 → crossplane_function_pythonic-0.6.2}/crossplane/pythonic/packages.py

@@ -158,19 +158,23 @@ def package_delete(action, package_dir, package, 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}")
+        if name.endswith('.py'):
+            name = name[:-3]
+            if not name.isidentifier():
+                logger.error(f"Python module name is not an identifier: {name}")
                 return False
-            return True
-        name = name[:-3]
-    elif not isinstance(value, dict):
+        else:
+            if '/' in name:
+                logger.error(f"Python file name is not valid: {name}")
+                return False
+    elif isinstance(value, dict):
+        if not name.isidentifier():
+            logger.error(f"Python package name is not an identifier: {name}")
+            return False
+    else:
         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
+    return True
 
 
 def package_file_name(package_name):

crossplane_function_pythonic-0.6.2/crossplane/pythonic/proto/v1/run_function.proto

@@ -0,0 +1,436 @@
+/*
+   Copyright 2022 The Crossplane Authors.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+syntax = "proto3";
+
+// This package defines the RPC for both composition and operation functions.
+// Only composition functions are part of the 'apiextensions' API group. In
+// retrospect this package should've been crossplane.proto.fn.v1, but it's too
+// late to change it now.
+
+//buf:lint:ignore PACKAGE_DIRECTORY_MATCH
+package apiextensions.fn.proto.v1;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/struct.proto";
+
+option go_package = "github.com/crossplane/crossplane/v2/proto/fn/v1";
+
+// A FunctionRunnerService is a function.
+service FunctionRunnerService {
+  // RunFunction runs the function.
+  rpc RunFunction(RunFunctionRequest) returns (RunFunctionResponse) {}
+}
+
+// A RunFunctionRequest requests that the function be run.
+message RunFunctionRequest {
+  // Metadata pertaining to this request.
+  RequestMeta meta = 1;
+
+  // The observed state prior to invocation of a function pipeline. State passed
+  // to each function is fresh as of the time the pipeline was invoked, not as
+  // of the time each function was invoked.
+  State observed = 2;
+
+  // Desired state according to a function pipeline. The state passed to a
+  // particular function may have been accumulated by previous functions in the
+  // pipeline.
+  //
+  // Note that the desired state must be a partial object with only the fields
+  // that this function (and its predecessors in the pipeline) wants to have set
+  // in the object. Copying a non-partial observed state to desired is most
+  // likely not what you want to do. Leaving out fields that had been returned
+  // as desired before will result in them being deleted from the objects in the
+  // cluster.
+  State desired = 3;
+
+  // Optional input specific to this function invocation. A JSON representation
+  // of the 'input' block of the relevant entry in a function pipeline.
+  optional google.protobuf.Struct input = 4;
+
+  // Optional context. Crossplane may pass arbitrary contextual information to a
+  // function. A function may also return context in its RunFunctionResponse,
+  // and that context will be passed to subsequent functions. Crossplane
+  // discards all context returned by the last function in the pipeline.
+  optional google.protobuf.Struct context = 5;
+
+  // Optional resources that the function specified in its requirements. Note
+  // that resources is a map to Resources, plural. The map key corresponds to
+  // the key in a RunFunctionResponse's requirements.extra_resources field. If a
+  // function requested extra resources that did not exist, Crossplane sets
+  // the map key to an empty Resources message to indicate that it attempted to
+  // satisfy the request. This field is only populated when the function uses
+  // extra_resources in its requirements.
+  //
+  // Deprecated: Use required_resources instead.
+  map<string, Resources> extra_resources = 6 [deprecated = true];
+
+  // Optional credentials that this function may use to communicate with an
+  // external system.
+  map<string, Credentials> credentials = 7;
+
+  // Optional resources that the function specified in its requirements. Note
+  // that resources is a map to Resources, plural. The map key corresponds to
+  // the key in a RunFunctionResponse's requirements.resources field. If a
+  // function requested required resources that did not exist, Crossplane sets
+  // the map key to an empty Resources message to indicate that it attempted to
+  // satisfy the request. This field is only populated when the function uses
+  // resources in its requirements.
+  map<string, Resources> required_resources = 8;
+
+  // Optional schemas that the function specified in its requirements. The map
+  // key corresponds to the key in a RunFunctionResponse's requirements.schemas
+  // field. If a function requested a schema that could not be found, Crossplane
+  // sets the map key to an empty Schema message to indicate that it attempted
+  // to satisfy the request.
+  map<string, Schema> required_schemas = 9;
+}
+
+// Credentials that a function may use to communicate with an external system.
+message Credentials {
+  // Source of the credentials.
+  oneof source {
+    // Credential data loaded by Crossplane, for example from a Secret.
+    CredentialData credential_data = 1;
+  }
+}
+
+// CredentialData loaded by Crossplane, for example from a Secret.
+message CredentialData {
+  map<string, bytes> data = 1;
+}
+
+// Resources represents the state of several Crossplane resources.
+message Resources {
+  repeated Resource items = 1;
+}
+
+// A RunFunctionResponse contains the result of a function run.
+message RunFunctionResponse {
+  // Metadata pertaining to this response.
+  ResponseMeta meta = 1;
+
+  // Desired state according to a function pipeline. functions may add desired
+  // state, and may mutate or delete any part of the desired state they are
+  // concerned with. A function must pass through any part of the desired state
+  // that it is not concerned with.
+  //
+  // Note that the desired state must be a partial object with only the fields
+  // that this function (and its predecessors in the pipeline) wants to have set
+  // in the object. Copying a non-partial observed state to desired is most
+  // likely not what you want to do. Leaving out fields that had been returned
+  // as desired before will result in them being deleted from the objects in the
+  // cluster.
+  State desired = 2;
+
+  // Results of the function run. Results are used for observability purposes.
+  repeated Result results = 3;
+
+  // Optional context to be passed to the next function in the pipeline as part
+  // of the RunFunctionRequest. Dropped on the last function in the pipeline.
+  optional google.protobuf.Struct context = 4;
+
+  // Requirements that must be satisfied for this function to run successfully.
+  Requirements requirements = 5;
+
+  // Status conditions to be applied to the XR. Conditions may also optionally
+  // be applied to the XR's associated claim.
+  //
+  // Conditions are only used for composition. They're ignored by Operations.
+  repeated Condition conditions = 6;
+
+  // Optional output specific to this function invocation.
+  //
+  // Only Operations use function output. XRs will discard any function output.
+  optional google.protobuf.Struct output = 7;
+}
+
+// RequestMeta contains metadata pertaining to a RunFunctionRequest.
+message RequestMeta {
+  // An opaque string identifying a request. Requests with identical tags will
+  // be otherwise identical.
+  string tag = 1;
+
+  // Capabilities supported by this version of Crossplane. Functions may use
+  // this to determine whether Crossplane will honor certain fields in their
+  // response, or populate certain fields in their request.
+  repeated Capability capabilities = 2;
+}
+
+// Capability indicates that Crossplane supports a particular feature.
+// Functions can check for capabilities to determine whether Crossplane will
+// honor a particular request or response field.
+enum Capability {
+  CAPABILITY_UNSPECIFIED = 0;
+
+  // Crossplane sends capabilities in RequestMeta. If this capability is
+  // present, the function knows that if another capability is absent, it's
+  // because Crossplane doesn't support it (not because Crossplane predates
+  // capability advertisement). Added in Crossplane v2.2.
+  CAPABILITY_CAPABILITIES = 1;
+
+  // Crossplane supports the requirements.resources field. Functions can return
+  // resource requirements and Crossplane will fetch the requested resources and
+  // return them in required_resources. Added in Crossplane v1.15.
+  CAPABILITY_REQUIRED_RESOURCES = 2;
+
+  // Crossplane supports the credentials field. Functions can receive
+  // credentials from secrets specified in the Composition. Added in Crossplane
+  // v1.16.
+  CAPABILITY_CREDENTIALS = 3;
+
+  // Crossplane supports the conditions field. Functions can return status
+  // conditions to be applied to the XR and optionally its claim. Added in
+  // Crossplane v1.17.
+  CAPABILITY_CONDITIONS = 4;
+
+  // Crossplane supports the requirements.schemas field. Functions can request
+  // OpenAPI schemas and Crossplane will return them in required_schemas. Added
+  // in Crossplane v2.2.
+  CAPABILITY_REQUIRED_SCHEMAS = 5;
+}
+
+// Requirements that must be satisfied for a function to run successfully.
+message Requirements {
+  // Resources that this function requires. The map key uniquely identifies the
+  // group of resources.
+  //
+  // Deprecated: Use resources instead.
+  map<string, ResourceSelector> extra_resources = 1 [deprecated = true];
+
+  // Resources that this function requires. The map key uniquely identifies the
+  // group of resources.
+  map<string, ResourceSelector> resources = 2;
+
+  // Schemas that this function requires. The map key uniquely identifies the
+  // schema request.
+  map<string, SchemaSelector> schemas = 3;
+}
+
+// SchemaSelector identifies a resource kind whose OpenAPI schema is requested.
+message SchemaSelector {
+  // API version of the resource kind, e.g. "example.org/v1".
+  string api_version = 1;
+
+  // Kind of resource, e.g. "MyResource".
+  string kind = 2;
+}
+
+// Schema represents the OpenAPI schema for a resource kind.
+message Schema {
+  // The OpenAPI v3 schema of the resource kind as unstructured JSON.
+  // For CRDs this is the spec.versions[].schema.openAPIV3Schema field.
+  // Empty if Crossplane could not find a schema for the requested kind.
+  optional google.protobuf.Struct openapi_v3 = 1;
+}
+
+// ResourceSelector selects a group of resources, either by name or by label.
+message ResourceSelector {
+  // API version of resources to select.
+  string api_version = 1;
+
+  // Kind of resources to select.
+  string kind = 2;
+
+  // Resources to match.
+  oneof match {
+    // Match the resource with this name.
+    string match_name = 3;
+
+    // Match all resources with these labels.
+    MatchLabels match_labels = 4;
+  }
+
+  // Match resources in this namespace. Omit namespace to match cluster scoped
+  // resources, or to match namespaced resources by labels across all
+  // namespaces.
+  optional string namespace = 5;
+}
+
+// MatchLabels defines a set of labels to match resources against.
+message MatchLabels {
+  map<string, string> labels = 1;
+}
+
+// ResponseMeta contains metadata pertaining to a RunFunctionResponse.
+message ResponseMeta {
+  // An opaque string identifying the content of the request. Must match the
+  // meta.tag of the corresponding RunFunctionRequest.
+  string tag = 1;
+
+  // Time-to-live of this response. Crossplane will call the function again when
+  // the TTL expires. Crossplane may cache the response to avoid calling the
+  // function again until the TTL expires.
+  optional google.protobuf.Duration ttl = 2;
+}
+
+// State of the XR (XR) and any resources.
+message State {
+  // The state of the XR (XR).
+  Resource composite = 1;
+
+  // The state of any other resources. In composition functions these are the
+  // composed resources. In operation functions they're arbitrary resources that
+  // the operation wants to create or update.
+  map<string, Resource> resources = 2;
+}
+
+// A Resource represents the state of a Kubernetes resource.
+message Resource {
+  // The JSON representation of the resource.
+  //
+  // * Crossplane will set this field in a RunFunctionRequest to the entire
+  // observed state of a resource - including its metadata, spec, and status.
+  //
+  // * A function should set this field in a RunFunctionRequest to communicate
+  // the desired state of the resource.
+  //
+  // * A function may only specify the desired status of a XR - not its metadata
+  // or spec. A function should not return desired metadata or spec for a XR.
+  // This will be ignored.
+  //
+  // * A function may not specify the desired status of any other resource -
+  // e.g. composed resources. It may only specify their metadata and spec.
+  // Status will be ignored.
+  google.protobuf.Struct resource = 1;
+
+  // The resource's connection details.
+  //
+  // * Crossplane will set this field in a RunFunctionRequest to communicate the
+  // the observed connection details of a composite or composed resource.
+  //
+  // * A function should set this field in a RunFunctionResponse to indicate the
+  // desired connection details of legacy XRs. For modern XRs, this will be ignored.
+  //
+  // * A function should not set this field in a RunFunctionResponse to indicate
+  // the desired connection details of a composed resource. This will be
+  // ignored.
+  //
+  // Connection details are only used for composition. They're ignored by
+  // Operations.
+  map<string, bytes> connection_details = 2;
+
+  // Ready indicates whether the resource should be considered ready.
+  //
+  // * Crossplane will never set this field in a RunFunctionRequest.
+  //
+  // * A function should set this field to READY_TRUE in a RunFunctionResponse
+  // to indicate that a desired resource is ready.
+  //
+  // * A function should set this field to READY_TRUE in a RunFunctionResponse
+  // to indicate that a desired XR is ready. This overwrites the standard
+  // readiness detection that determines the ready state of the composite by the
+  // ready state of the composed resources.
+  //
+  // Ready is only used for composition. It's ignored by Operations.
+  Ready ready = 3;
+}
+
+// Ready indicates whether a resource should be considered ready.
+enum Ready {
+  READY_UNSPECIFIED = 0;
+
+  // True means the resource has been observed to be ready.
+  READY_TRUE = 1;
+
+  // False means the resource has not been observed to be ready.
+  READY_FALSE = 2;
+}
+
+// A Result of running a function.
+message Result {
+  // Severity of this result.
+  Severity severity = 1;
+
+  // Human-readable details about the result.
+  string message = 2;
+
+  // Optional PascalCase, machine-readable reason for this result. If omitted,
+  // the value will be ComposeResources.
+  optional string reason = 3;
+
+  // The resources this result targets.
+  optional Target target = 4;
+}
+
+// Severity of function results.
+enum Severity {
+  SEVERITY_UNSPECIFIED = 0;
+
+  // Fatal results are fatal; subsequent functions may run, but the function
+  // pipeline run will be considered a failure and the first fatal result will
+  // be returned as an error.
+  SEVERITY_FATAL = 1;
+
+  // Warning results are non-fatal; the entire pipeline will run to completion
+  // but warning events and debug logs associated with the XR or Operation will
+  // be emitted.
+  SEVERITY_WARNING = 2;
+
+  // Normal results are emitted as normal events and debug logs associated with
+  // the XR or operation.
+  SEVERITY_NORMAL = 3;
+}
+
+// Target of function results and conditions.
+enum Target {
+  // If the target is unspecified, the result targets the XR.
+  TARGET_UNSPECIFIED = 0;
+
+  // Target the XR. Results that target the XR should include detailed, advanced
+  // information.
+  TARGET_COMPOSITE = 1;
+
+  // Target the XR and the claim. Results that target the XR and the claim
+  // should include only end-user friendly information.
+  TARGET_COMPOSITE_AND_CLAIM = 2;
+}
+
+// Status condition to be applied to the XR. Condition may also optionally be
+// applied to the XR's associated claim. For detailed information on proper
+// usage of status conditions, please see
+// https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md#typical-status-properties.
+message Condition {
+  // Type of condition in PascalCase.
+  string type = 1;
+
+  // Status of the condition.
+  Status status = 2;
+
+  // Reason contains a programmatic identifier indicating the reason for the
+  // condition's last transition. Producers of specific condition types may
+  // define expected values and meanings for this field, and whether the values
+  // are considered a guaranteed API. The value should be a PascalCase string.
+  // This field may not be empty.
+  string reason = 3;
+
+  // Message is a human readable message indicating details about the
+  // transition. This may be an empty string.
+  optional string message = 4;
+
+  // The resources this condition targets.
+  optional Target target = 5;
+}
+
+enum Status {
+  STATUS_CONDITION_UNSPECIFIED = 0;
+
+  STATUS_CONDITION_UNKNOWN = 1;
+
+  STATUS_CONDITION_TRUE = 2;
+
+  STATUS_CONDITION_FALSE = 3;
+}