crossplane-function-pythonic 0.6.3__py3-none-any.whl → 0.7.0__py3-none-any.whl

crossplane/pythonic/function.py

@@ -5,26 +5,31 @@ import importlib
 import inspect
 import logging
 import sys
+import typing
 
 import grpc
+from google.protobuf.struct_pb2 import Struct
+
+from crossplane.pythonic.composite import BaseComposite
 
 from .. import pythonic
+from . import protobuf
 from .proto.v1 import run_function_pb2 as fnv1
 from .proto.v1 import run_function_pb2_grpc as grpcv1
 
 logger = logging.getLogger(__name__)
 
 
-class FunctionRunner(grpcv1.FunctionRunnerService):
+class FunctionRunner(grpcv1.FunctionRunnerServiceServicer):
     """A FunctionRunner handles gRPC RunFunctionRequests."""
 
-    def __init__(self, renderUnknowns=False, crossplane_v1=False):
+    def __init__(self, renderUnknowns: bool = False, crossplane_v1: bool = False):
         """Create a new FunctionRunner."""
-        self.renderUnknowns = renderUnknowns
-        self.crossplane_v1 = crossplane_v1
-        self.clazzes = {}
+        self.renderUnknowns: bool = renderUnknowns
+        self.crossplane_v1: bool = crossplane_v1
+        self.clazzes: dict[str, type[pythonic.BaseComposite]] = {}
 
-    def invalidate_module(self, module):
+    def invalidate_module(self, module: str) -> None:
         ix = len(module)
         while ix > 0:
             module = module[:ix]
@@ -35,37 +40,46 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         self.clazzes.clear()
 
     async def RunFunction(
-        self, request: fnv1.RunFunctionRequest, _: grpc.aio.ServicerContext
+        self,
+        request: fnv1.RunFunctionRequest,
+        context: grpc.aio.ServicerContext | None = None,
     ) -> fnv1.RunFunctionResponse:
         try:
             return await self.run_function(request)
         except Exception as e:  # noqa: BLE001
             return self.fatal(request, logger, "RunFunction", e)
 
-    async def run_function(self, request):
-        composite = request.observed.composite.resource
+    async def run_function(
+        self, request: fnv1.RunFunctionRequest
+    ) -> fnv1.RunFunctionResponse:
+        composite: Struct = request.observed.composite.resource
         if composite and composite.fields:
-            name = list(reversed(composite["apiVersion"].split("/")[0].split(".")))
-            name.append(composite["kind"])
-            name.append(composite["metadata"]["name"])
+            name: list[str] = list(
+                reversed(str(composite["apiVersion"]).split("/")[0].split("."))
+            )
+            name.append(str(composite["kind"]))
+            name.append(str(typing.cast(Struct, composite["metadata"])["name"]))
             logger = logging.getLogger(".".join(name))
             if "inlined" in request.input and request.input["inlined"]:  # noqa: RUF019
-                if (
-                    "spec" not in composite
-                    or request.input["inlined"] not in composite["spec"]
-                ):
+                if "spec" not in composite or str(
+                    request.input["inlined"]
+                ) not in typing.cast(Struct, composite["spec"]):
                     return self.fatal(
                         request,
                         logger,
                         f"Missing inlined spec.{request.input['inlined']}",
                     )
-                composite = composite["spec"][request.input["inlined"]]
+                composite: str = str(
+                    typing.cast(Struct, composite["spec"])[
+                        str(request.input["inlined"])
+                    ],
+                )
             else:
                 if "composite" not in request.input:
                     return self.fatal(
                         request, logger, 'Missing composition input "composite"'
                     )
-                composite = request.input["composite"]
+                composite: str = str(request.input["composite"])
             operation = False
         else:
             logger = logging.getLogger("operation")
@@ -73,7 +87,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                 return self.fatal(
                     request, logger, 'Missing operation input "composite"'
                 )
-            composite = request.input["composite"]
+            composite: str = str(request.input["composite"])
             operation = True
 
         # Ideally this is something the Function API provides
@@ -111,7 +125,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                         "Composite script does not have a BaseComposite class",
                     )
             else:
-                composite = composite.rsplit(".", 1)
+                composite: list[str] = composite.rsplit(".", 1)
                 if len(composite) == 1:
                     return self.fatal(
                         request,
@@ -129,7 +143,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                         logger,
                         f"{composite[0]} does not define: {composite[1]}",
                     )
-                composite = ".".join(composite)
+                composite: str = ".".join(composite)
                 if not inspect.isclass(clazz):
                     return self.fatal(request, logger, f"{composite} is not a class")
                 if not issubclass(clazz, pythonic.BaseComposite):
@@ -147,7 +161,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                 logger = logging.getLogger(f"operation.{composite}")
 
         try:
-            composite = clazz(self.crossplane_v1, request, logger)
+            composite: BaseComposite = clazz(self.crossplane_v1, request, logger)
         except Exception as e:  # noqa: BLE001
             return self.fatal(request, logger, "Instantiate", e)
 
@@ -185,13 +199,19 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
             self.process_usages(composite)
             self.process_unknowns(composite)
             # Perform auto ready on all resources.
-            for name, resource in composite.resources:
+            for _, resource in composite.resources:
                 resource.ready  # noqa: B018
             logger.info("Completed compose")
 
-        return composite.response._message
+        return typing.cast(fnv1.RunFunctionResponse, composite.response._message)
 
-    def fatal(self, request, logger, message, exception=None):
+    def fatal(
+        self,
+        request: fnv1.RunFunctionRequest,
+        logger: logging.Logger,
+        message: str,
+        exception: Exception | None = None,
+    ) -> fnv1.RunFunctionResponse:
         if exception:
             message += " exception"
             logger.exception(message)
@@ -213,8 +233,8 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
             ],
         )
 
-    def get_schemas(self, step, composite):
-        schemas = []
+    def get_schemas(self, step: protobuf.Value, composite: BaseComposite) -> list[str]:
+        schemas: list[str] = []
         for name, schema in composite.schemas:
             if len(schema.kind) and len(schema.apiVersion):
                 s = pythonic.Map(kind=schema.kind, apiVersion=schema.apiVersion)
@@ -223,8 +243,10 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                     schemas.append(name)
         return schemas
 
-    def get_requireds(self, step, composite):
-        requireds = []
+    def get_requireds(
+        self, step: protobuf.Value, composite: BaseComposite
+    ) -> list[str]:
+        requireds: list[str] = []
         for name, required in composite.requireds:
             if len(required.kind) and len(required.apiVersion):
                 r = pythonic.Map(kind=required.kind, apiVersion=required.apiVersion)
@@ -239,7 +261,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                     requireds.append(name)
         return requireds
 
-    def process_usages(self, composite):
+    def process_usages(self, composite: BaseComposite) -> None:
         if self.crossplane_v1:
             apiVersion = "apiextensions.crossplane.io/v1beta1"
         else:
@@ -285,7 +307,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                             )
                     for name, dependencies in resources.items():
                         source = composite.resources[name]
-                        name = [resource.name, str(source.kind)]
+                        name: list[str] = [str(resource.name), str(source.kind)]
                         if source.metadata.namespace:
                             name.append(str(source.metadata.namespace))
                         name.append(str(source.observed.metadata.name))
@@ -322,7 +344,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                                 usage.kind = "ClusterUsage"
                     for key, dependencies in requireds.items():
                         source = composite.requireds[key[0]][key[1]]
-                        name = [resource.name, str(source.kind)]
+                        name: list[str] = [str(resource.name), str(source.kind)]
                         if source.metadata.namespace:
                             name.append(str(source.metadata.namespace))
                         name.append(str(source.metadata.name))
@@ -358,10 +380,10 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                             else:
                                 usage.kind = "ClusterUsage"
 
-    def process_unknowns(self, composite):
-        unknownResources = []
-        warningResources = []
-        fatalResources = []
+    def process_unknowns(self, composite: BaseComposite) -> None:
+        unknownResources: list[str] = []
+        warningResources: list[str] = []
+        fatalResources: list[str] = []
         for name, resource in sorted(entry for entry in composite.resources):
             unknowns = resource.desired._getUnknowns
             if unknowns:
@@ -429,8 +451,8 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         if result:
             result(reason, message)
 
-    def trimFullName(self, name):
-        name = name.split(".")
+    def trimFullName(self, name: str) -> str:
+        name: list[str] = name.split(".")
         for values in (
             ("request", "observed", "composite", "resource"),
             ("response", "desired", "composite", "resource"),
@@ -468,8 +490,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         return ".".join(name)
 
 
-def ordinal(ix):
-    ix = int(ix)
+def ordinal(ix: int) -> str:
     if 11 <= (ix % 100) <= 13:
         suffix = "th"
     else:

crossplane/pythonic/grpc.py

@@ -1,3 +1,4 @@
+import argparse
 import asyncio
 import logging
 import os
@@ -23,7 +24,7 @@ class Command(command.Command):
     help = "Run function-pythonic gRPC server"
 
     @classmethod
-    def add_parser_arguments(cls, parser):
+    def add_parser_arguments(cls, parser: argparse.ArgumentParser) -> None:
         cls.add_function_arguments(parser)
         parser.add_argument(
             "--address",
@@ -86,7 +87,7 @@ class Command(command.Command):
             help="Pip install command to install additional Python packages.",
         )
 
-    def initialize(self):
+    def initialize(self) -> None:
         if not self.args.tls_certs_dir and not self.args.insecure:
             print(
                 "Either --tls-certs-dir or --insecure must be specified",
@@ -114,7 +115,7 @@ class Command(command.Command):
         # enables read only volumes or mismatched uid volumes
         sys.dont_write_bytecode = True
 
-    async def run(self):
+    async def run(self) -> None:
         grpc.aio.init_grpc_aio()
         grpc_runner = function.FunctionRunner(
             self.args.render_unknowns, self.args.crossplane_v1

crossplane/pythonic/main.py

@@ -21,12 +21,16 @@ from . import (
 
 
 def main():
-    parser = argparse.ArgumentParser("Crossplane Function Pythonic")
-    subparsers = parser.add_subparsers(title="Command", metavar="")
+    parser: argparse.ArgumentParser = argparse.ArgumentParser(
+        "Crossplane Function Pythonic"
+    )
+    subparsers: argparse._SubParsersAction[argparse.ArgumentParser] = (
+        parser.add_subparsers(title="Command", metavar="")
+    )
     grpc.Command.create(subparsers)
     render.Command.create(subparsers)
     version.Command.create(subparsers)
-    args = parser.parse_args()
+    args: argparse.Namespace = parser.parse_args()
     if not hasattr(args, "command"):
         parser.print_help()
         sys.exit(1)

crossplane/pythonic/packages.py

@@ -2,9 +2,13 @@ import base64
 import logging
 import pathlib
 import sys
+import typing
 
+import grpc
 import kopf
 
+from . import function
+
 GRPC_SERVER = None
 GRPC_RUNNER = None
 PACKAGES_DIR = None
@@ -13,15 +17,15 @@ PACKAGE_LABELS = {PACKAGE_LABEL: kopf.PRESENT}
 
 
 def operator(
-    grpc_server,
-    grpc_runner,
-    packages_configmaps,
-    packages_secrets,
-    packages_namespaces,
-    packages_environmentconfigs,
-    packages_compositions,
-    packages_dir,
-):
+    grpc_server: grpc.aio.Server,
+    grpc_runner: function.FunctionRunner,
+    packages_configmaps: bool,
+    packages_secrets: bool,
+    packages_namespaces: list[str],
+    packages_environmentconfigs: bool,
+    packages_compositions: bool,
+    packages_dir: str,
+) -> typing.Coroutine:
     logging.getLogger("kopf.objects").setLevel(logging.INFO)
     global GRPC_SERVER, GRPC_RUNNER, PACKAGES_DIR
     GRPC_SERVER = grpc_server
@@ -44,7 +48,7 @@ def operator(
     )
 
 
-def on_resource(group, version, plural):
+def on_resource(group: str, version: str, plural: str):
     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)
@@ -52,25 +56,26 @@ def on_resource(group, version, plural):
 
 
 @kopf.on.startup()
-async def startup(settings, **_):
+async def startup(settings: kopf.OperatorSettings, **_: typing.Any) -> None:
     settings.scanning.disabled = True
 
 
 @kopf.on.cleanup()
-async def cleanup(**_):
-    await GRPC_SERVER.stop(5)
+async def cleanup(**_: typing.Any) -> None:
+    if GRPC_SERVER:
+        await GRPC_SERVER.stop(5)
 
 
-async def create(resource, labels, body, logger, **_):
+async def create(resource, labels, body, logger, **_: typing.Any):
     resource_create(resource, labels, "Created", body, logger)
 
 
-async def update(resource, labels, body, old, logger, **_):
+async def update(resource, labels, body, old, logger, **_: typing.Any):
     resource_delete(resource, labels, "Removed", old, logger)
     resource_create(resource, labels, "Added", body, logger)
 
 
-async def delete(resource, labels, body, logger, **_):
+async def delete(resource, labels, body, logger, **_: typing.Any):
     resource_delete(resource, labels, "Deleted", body, logger)
 
 
@@ -141,7 +146,8 @@ def package_create(resource, action, package_dir, package, logger):
                     package_name.write_text(value)
                 module, name = package_file_name(package_name)
                 if module:
-                    GRPC_RUNNER.invalidate_module(name)
+                    if GRPC_RUNNER:
+                        GRPC_RUNNER.invalidate_module(name)
                     logger.info(f"{action} module: {name}")
                 else:
                     logger.info(f"{action} file: {name}")
@@ -157,7 +163,8 @@ def package_delete(action, package_dir, package, logger):
                 package_name.unlink(missing_ok=True)
                 module, name = package_file_name(package_name)
                 if module:
-                    GRPC_RUNNER.invalidate_module(name)
+                    if GRPC_RUNNER:
+                        GRPC_RUNNER.invalidate_module(name)
                     logger.info(f"{action} module: {name}")
                 else:
                     logger.info(f"{action} file: {name}")
@@ -170,7 +177,8 @@ def package_delete(action, package_dir, package, logger):
                     parent.rmdir()
                     module = str(parent.relative_to(PACKAGES_DIR)).replace("/", ".")
                     if module != ".":
-                        GRPC_RUNNER.invalidate_module(module)
+                        if GRPC_RUNNER:
+                            GRPC_RUNNER.invalidate_module(module)
                         logger.info(f"{action} package: {module}")
                     parent = parent.parent
             elif isinstance(value, dict):