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

crossplane/pythonic/__about__.py

@@ -1,2 +1,6 @@
-# This is set at build time, using "hatch version"
-__version__ = "0.6.2"
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("crossplane-function-pythonic")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

crossplane/pythonic/__init__.py

@@ -1,17 +1,25 @@
-
-
 from .composite import BaseComposite
-from .protobuf import append, Map, List, Unknown, Yaml, YamlAll, Json, B64Encode, B64Decode
+from .protobuf import (
+    B64Decode,
+    B64Encode,
+    Json,
+    List,
+    Map,
+    Unknown,
+    Yaml,
+    YamlAll,
+    append,
+)
 
 __all__ = [
-    'BaseComposite',
-    'append',
-    'Map',
-    'List',
-    'Unknown',
-    'Yaml',
-    'YamlAll',
-    'Json',
-    'B64Encode',
-    'B64Decode',
+    "B64Decode",
+    "B64Encode",
+    "BaseComposite",
+    "Json",
+    "List",
+    "Map",
+    "Unknown",
+    "Yaml",
+    "YamlAll",
+    "append",
 ]

crossplane/pythonic/__main__.py

@@ -1,2 +1,3 @@
 from . import main
+
 main.main()

crossplane/pythonic/auto_ready.py

@@ -1,14 +1,24 @@
+from typing import TYPE_CHECKING
 
-def resource_ready(resource):
+if TYPE_CHECKING:
+    from . import (
+        composite,
+        protobuf,
+    )
+
+
+def resource_ready(resource: composite.Resource) -> protobuf.Value | None:
     if not resource.observed:
         return None
-    return _checks.get((resource.observed.apiVersion, resource.observed.kind), _check_default).ready(resource)
+    return _checks.get(
+        (resource.observed.apiVersion, resource.observed.kind), _check_default
+    ).ready(resource)
 
 
 class ReadyCondition:
-    def ready(self, resource):
+    def ready(self, resource: composite.Resource) -> protobuf.Value | None:
         ready = resource.conditions.Ready
-        if not ready._find_condition():
+        if not ready._get_condition():
             return None
         if ready.status:
             return resource.observed.metadata.name
@@ -16,36 +26,43 @@ class ReadyCondition:
             return resource.status.notReadyCondition[ready.reason]
         return resource.status.notReadyCondition
 
-_checks = {}
+
+_checks: dict[tuple, Check] = {}
 _check_default = ReadyCondition()
 
+
 class Check:
     @classmethod
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
-        if hasattr(cls, 'apiVersion'):
+        if hasattr(cls, "apiVersion"):
             _checks[(cls.apiVersion, cls.__name__)] = cls()
 
-    def ready(self, resource):
+    def ready(self, resource: composite.Resource) -> protobuf.Value | None:
         raise NotImplementedError()
 
+
 class AlwaysReady(Check):
-    def ready(self, resource):
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
         return resource.observed.metadata.name
 
 
 class ClusterRole(AlwaysReady):
-    apiVersion = 'rbac.authorization.k8s.io/v1'
+    apiVersion = "rbac.authorization.k8s.io/v1"
+
 
 class ClusterRoleBinding(AlwaysReady):
-    apiVersion = 'rbac.authorization.k8s.io/v1'
+    apiVersion = "rbac.authorization.k8s.io/v1"
+
 
 class ConfigMap(AlwaysReady):
-    apiVersion = 'v1'
+    apiVersion = "v1"
+
 
 class CronJob(Check):
-    apiVersion = 'batch/v1'
-    def ready(self, resource):
+    apiVersion = "batch/v1"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
         if resource.observed.spec.suspend and len(resource.observed.spec.suspend):
             return resource.observed.metadata.name
         if not resource.status.lastScheduleTime:
@@ -54,17 +71,21 @@ class CronJob(Check):
             return resource.observed.metadata.name
         if not resource.status.lastSuccessfulTime:
             return resource.status.lastSuccessfulTime
-        if str(resource.status.lastSuccessfulTime) < str(resource.status.lastScheduleTime):
+        if str(resource.status.lastSuccessfulTime) < str(
+            resource.status.lastScheduleTime
+        ):
             return resource.status.successfulBeforeSchedule
         return resource.observed.metadata.name
 
+
 class DaemonSet(Check):
-    apiVersion = 'apps/v1'
-    def ready(self, resource):
+    apiVersion = "apps/v1"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
         scheduled = resource.status.desiredNumberScheduled
         if not scheduled:
             return scheduled
-        for field in ('numberReady', 'updatedNumberScheduled', 'numberAvailable'):
+        for field in ("numberReady", "updatedNumberScheduled", "numberAvailable"):
             value = resource.status[field]
             if not value:
                 return value
@@ -72,16 +93,18 @@ class DaemonSet(Check):
                 return resource.status[f"{field}NotScheduled"]
         return resource.observed.metadata.name
 
+
 class Deployment(Check):
-    apiVersion = 'apps/v1'
-    def ready(self, resource):
+    apiVersion = "apps/v1"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
         replicas = resource.observed.spec.replicas or 1
-        for field in ('updatedReplicas', 'availableReplicas'):
+        for field in ("updatedReplicas", "availableReplicas"):
             value = resource.status[field]
             if not value:
                 return value
             if replicas != value:
-                return resource.status[F"{field}NotReplicas"]
+                return resource.status[f"{field}NotReplicas"]
         available = resource.conditions.Available
         if not available:
             return resource.status.notAvailable
@@ -91,28 +114,39 @@ class Deployment(Check):
             return resource.status.notAvailable
         return resource.observed.metadata.name
 
+
 class HorizontalPodAutoscaler(Check):
-    apiVersion = 'autoscaling/v2'
-    def ready(self, resource):
-        for type in ('FailedGetScale', 'FailedUpdateScale', 'FailedGetResourceMetric', 'InvalidSelector'):
+    apiVersion = "autoscaling/v2"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
+        for type in (
+            "FailedGetScale",
+            "FailedUpdateScale",
+            "FailedGetResourceMetric",
+            "InvalidSelector",
+        ):
             if resource.conditions[type].status:
                 return resource.status[f"is{type}"]
-        for type in ('ScalingActive', 'ScalingLimited'):
+        for type in ("ScalingActive", "ScalingLimited"):
             if resource.conditions[type].status:
                 return resource.observed.metadata.name
-        return resource.status.notScalingActiveOrLimiited
+        return resource.status.notScalingActiveOrLimited
+
 
 class Ingress(Check):
-    apiVersion = 'networking.k8s.io/v1'
-    def ready(self, resource):
+    apiVersion = "networking.k8s.io/v1"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
         if not len(resource.status.loadBalancer.ingress):
-            return resource.status.noLoadBalanceIngresses
+            return resource.status.noLoadBalancerIngresses
         return resource.observed.metadata.name
 
+
 class Job(Check):
-    apiVersion = 'batch/v1'
-    def ready(self, resource):
-        for type in ('Failed', 'Suspended'):
+    apiVersion = "batch/v1"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
+        for type in ("Failed", "Suspended"):
             if resource.conditions[type].status:
                 return resource.status[f"is{type}"]
         complete = resource.conditions.Complete
@@ -124,71 +158,94 @@ class Job(Check):
             return resource.status.notComplete
         return resource.observed.metadata.name
 
+
 class Namespace(AlwaysReady):
-    apiVersion = 'v1'
+    apiVersion = "v1"
+
 
 class PersistentVolumeClaim(Check):
-    apiVersion = 'v1'
-    def ready(self, resource):
-        if resource.status.phase != 'Bound':
+    apiVersion = "v1"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
+        if resource.status.phase != "Bound":
             return resource.status.phaseNotBound
         return resource.observed.metadata.name
 
+
 class Pod(Check):
-    apiVersion = 'v1'
-    def ready(self, resource):
-        if resource.status.phase == 'Succeeded':
+    apiVersion = "v1"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
+        if resource.status.phase == "Succeeded":
+            return resource.observed.metadata.name
+        if (
+            resource.status.phase == "Running"
+            and resource.observed.spec.restartPolicy == "Always"
+            and resource.conditions.Ready.status
+        ):
             return resource.observed.metadata.name
-        if resource.status.phase == 'Running':
-            if resource.observed.spec.restartPolicy == 'Always':
-                if resource.conditions.Ready.status:
-                    return resource.observed.metadata.name
         return resource.status.notSucceededOrRunning
 
+
 class ReplicaSet(Check):
-    apiVersion = 'v1'
-    def ready(self, resource):
-        if int(resource.status.observedGeneration) < int(resource.observed.metadata.generation):
+    apiVersion = "apps/v1"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
+        if int(resource.status.observedGeneration) < int(
+            resource.observed.metadata.generation
+        ):
             return resource.status.priorObservedGeneration
         if resource.conditions.ReplicaFailure.status:
             if resource.conditions.ReplicaFailure.reason:
-                return resource.status.isReplicaFailure[resource.conditions.ReplicaFailure.reason]
+                return resource.status.isReplicaFailure[
+                    resource.conditions.ReplicaFailure.reason
+                ]
             return resource.status.isReplicaFailure
-        if int(resource.status.availableReplicas) < int(resource.observed.spec.replicas or 1):
-            return resource.status.tooFewavailableReplicas
+        if int(resource.status.availableReplicas) < int(
+            resource.observed.spec.replicas or 1
+        ):
+            return resource.status.tooFewAvailableReplicas
         return resource.observed.metadata.name
 
+
 class Role(AlwaysReady):
-    apiVersion = 'rbac.authorization.k8s.io/v1'
+    apiVersion = "rbac.authorization.k8s.io/v1"
+
 
 class RoleBinding(AlwaysReady):
-    apiVersion = 'rbac.authorization.k8s.io/v1'
+    apiVersion = "rbac.authorization.k8s.io/v1"
+
 
 class Secret(AlwaysReady):
-    apiVersion = 'v1'
+    apiVersion = "v1"
+
 
 class Service(Check):
-    apiVersion = 'v1'
-    def ready(self, resource):
-        if resource.observed.spec.type != 'LoadBalancer':
+    apiVersion = "v1"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
+        if resource.observed.spec.type != "LoadBalancer":
             return resource.observed.metadata.name
         if not len(resource.status.loadBalancer.ingress):
             return resource.status.noLoadBalancerIngresses
         return resource.observed.metadata.name
 
+
 class ServiceAccount(AlwaysReady):
-    apiVersion = 'v1'
+    apiVersion = "v1"
+
 
 class StatefulSet(Check):
-    apiVersion = 'apps/v1'
-    def ready(self, resource):
+    apiVersion = "apps/v1"
+
+    def ready(self, resource: composite.Resource) -> protobuf.Value:
         replicas = resource.observed.spec.replicas or 1
-        for field in ('readyReplicas', 'currentReplicas'):
+        for field in ("readyReplicas", "currentReplicas"):
             value = resource.status[field]
             if not value:
                 return value
             if replicas != value:
-                return resource.status[F"{field}NotReplicas"]
+                return resource.status[f"{field}NotReplicas"]
         if resource.status.currentRevision != resource.status.updateRevision:
-            return resource.status.currentRevisionNotUpdateReivsion
+            return resource.status.currentRevisionNotUpdateRevision
         return resource.observed.metadata.name

crossplane/pythonic/command.py

@@ -1,76 +1,84 @@
-
+import argparse
 import logging
 import pathlib
 import sys
 
 
 class Command:
-    name = None
-    command = None
-    description = None
+    name: str | None = None
+    command: str | None = None
+    help: str | None = None
+    description: str | None = None
 
     @classmethod
-    def create(cls, subparsers):
-        parser = subparsers.add_parser(cls.name, help=cls.help, description=cls.description)
-        parser.set_defaults(command=cls)
-        cls.add_parser_arguments(parser)
+    def create(
+        cls, subparsers: argparse._SubParsersAction[argparse.ArgumentParser]
+    ) -> None:
+        if cls.name is not None:
+            parser: argparse.ArgumentParser = subparsers.add_parser(
+                cls.name, help=cls.help, description=cls.description
+            )
+            parser.set_defaults(command=cls)
+            cls.add_parser_arguments(parser)
 
     @classmethod
-    def add_parser_arguments(cls, parser):
+    def add_parser_arguments(cls, parser: argparse.ArgumentParser) -> None:
         pass
 
     @classmethod
-    def add_function_arguments(cls, parser):
+    def add_function_arguments(cls, parser: argparse.ArgumentParser) -> None:
         parser.add_argument(
-            '--debug', '-d',
-            action='store_true',
-            help='Emit debug logs.',
+            "--debug",
+            "-d",
+            action="store_true",
+            help="Emit debug logs.",
         )
         parser.add_argument(
-            '--log-name-width',
+            "--log-name-width",
             type=int,
             default=40,
-            metavar='WIDTH',
-            help='Width of the logger name in the log output, default 40.',
+            metavar="WIDTH",
+            help="Width of the logger name in the log output, default 40.",
         )
         parser.add_argument(
-            '--logger-level',
-            action='append',
+            "--logger-level",
+            action="append",
             default=[],
-            metavar='LOGGER=LEVEL',
-            help='Logger level, for example: botocore.hooks=INFO',
+            metavar="LOGGER=LEVEL",
+            help="Logger level, for example: botocore.hooks=INFO",
         )
         parser.add_argument(
-            '--python-path',
-            action='append',
+            "--python-path",
+            action="append",
             default=[],
-            metavar='DIRECTORY',
-            help='Filing system directories to add to the python path.',
+            metavar="DIRECTORY",
+            help="Filing system directories to add to the python path.",
         )
         parser.add_argument(
-            '--render-unknowns', '-u',
-            action='store_true',
-            help='Render resources with unknowns, useful during local development.'
+            "--render-unknowns",
+            "-u",
+            action="store_true",
+            help="Render resources with unknowns, useful during local development.",
         )
         parser.add_argument(
-            '--allow-oversize-protos',
-            action='store_true',
-            help='Allow oversized protobuf messages',
+            "--allow-oversize-protos",
+            action="store_true",
+            help="Allow oversized protobuf messages",
         )
         parser.add_argument(
-            '--crossplane-v1',
-            action='store_true',
-            help='Enable Crossplane V1 compatibility mode',
+            "--crossplane-v1",
+            action="store_true",
+            help="Enable Crossplane V1 compatibility mode",
         )
 
-    def __init__(self, args=None):
-        self.args = args
+    def __init__(self, args: argparse.Namespace | None = None) -> None:
+        self.args = args if args is not None else argparse.Namespace()
         self.initialize()
 
-    def initialize(self):
+    def initialize(self) -> None:
         pass
 
-    def initialize_function(self):
+    def initialize_function(self) -> None:
         formatter = Formatter(self.args.log_name_width)
         handler = logging.StreamHandler(sys.stdout)
         handler.setFormatter(formatter)
@@ -78,14 +86,14 @@ class Command:
         logger.handlers = [handler]
         logger.setLevel(logging.DEBUG if self.args.debug else logging.INFO)
         # Suppress noisy libraries, these can be overriden using --logger-level
-        logging.getLogger('asyncio').setLevel(logging.INFO)
-        logging.getLogger('grpc').setLevel(logging.INFO)
-        logging.getLogger('httpcore').setLevel(logging.INFO)
-        logging.getLogger('httpx').setLevel(logging.WARNING)
-        logging.getLogger('kr8s').setLevel(logging.INFO)
-        for logger_level in self.args.logger_level:
-            for logger_level in logger_level.split(','):
-                logger_level = logger_level.split('=')
+        logging.getLogger("asyncio").setLevel(logging.INFO)
+        logging.getLogger("grpc").setLevel(logging.INFO)
+        logging.getLogger("httpcore").setLevel(logging.INFO)
+        logging.getLogger("httpx").setLevel(logging.WARNING)
+        logging.getLogger("kr8s").setLevel(logging.INFO)
+        for logger_levels in self.args.logger_level:
+            for logger_level in logger_levels.split(","):
+                logger_level = logger_level.split("=")
                 if len(logger_level) == 2:
                     logging.getLogger(logger_level[0]).setLevel(logger_level[1].upper())
 
@@ -94,32 +102,35 @@ class Command:
 
         if self.args.allow_oversize_protos:
             from google.protobuf.internal import api_implementation
-            if api_implementation._c_module:
-                api_implementation._c_module.SetAllowOversizeProtos(True)
 
-    async def run(self):
+            c_module = getattr(api_implementation, "_c_module", None)
+            if c_module:
+                c_module.SetAllowOversizeProtos(True)
+
+    async def run(self) -> None:
         raise NotImplementedError()
 
 
 class Formatter(logging.Formatter):
-    def __init__(self, name_width):
-        super(Formatter, self).__init__(
+    def __init__(self, name_width: int):
+        super().__init__(
             f"[{{asctime}}.{{msecs:03.0f}}] {{sname:{name_width}.{name_width}}} [{{levelname:8.8}}] {{message}}",
-            '%Y-%m-%d %H:%M:%S',
-            '{',
+            "%Y-%m-%d %H:%M:%S",
+            "{",
         )
         self.name_width = name_width
 
-    def format(self, record):
-        record.sname = record.name
-        extra = len(record.sname) - self.name_width
+    def format(self, record: logging.LogRecord):
+        sname = record.name
+        extra = len(sname) - self.name_width
         if extra > 0:
-            names = record.sname.split('.')
+            names = sname.split(".")
             for ix, name in enumerate(names):
                 if len(name) > extra:
                     names[ix] = name[extra:]
                     break
                 names[ix] = name[:1]
                 extra -= len(name) - 1
-            record.sname = '.'.join(names)
-        return super(Formatter, self).format(record)
+            sname = ".".join(names)
+        record.sname = sname
+        return super().format(record)