Merge pull request #80 from nitrictech/develop

Release

Author: tjholm

nitric/application.py

@@ -1,42 +1,45 @@
 import asyncio
 from nitric.faas import FunctionServer
+
 # from nitric.resources.base import BaseResource
 from typing import Dict, List, Type, Any, TypeVar
 
 
-BT = TypeVar('BT')
+BT = TypeVar("BT")
+
 
 class Nitric:
+    """Represents a nitric app."""
+
     _workers: List[FunctionServer] = []
     _cache: Dict[str, Dict[str, Any]] = {
         "api": {},
         "bucket": {},
         "topic": {},
         "secret": {},
         "queue": {},
-        "collection": {}
+        "collection": {},
     }
 
     @classmethod
     def _register_worker(cls, srv: FunctionServer):
-        """
-        Register a worker for this
-        """
+        """Register a worker for this application."""
         cls._workers.append(srv)
 
-    @classmethod 
-    def _create_resource(cls, resource: Type[BT], name: str) -> BT:
+    @classmethod
+    def _create_resource(cls, resource: Type[BT], name: str, *args, **kwargs) -> BT:
         resource_type = resource.__name__.lower()
         if cls._cache.get(resource_type).get(name) is None:
-            cls._cache[resource_type][name] = resource.make(name)
+            cls._cache[resource_type][name] = resource.make(name, *args, **kwargs)
 
         return cls._cache[resource_type][name]
 
-    @classmethod    
+    @classmethod
     def run(cls):
         """
-        Start the nitric application, this will execute in an existing event loop if there is one, otherwise it will
-        attempt to create its own
+        Start the nitric application.
+
+        This will execute in an existing event loop if there is one, otherwise it will attempt to create its own.
         """
         try:
             try:

nitric/faas.py

@@ -383,17 +383,22 @@ def from_str(value: str) -> Frequency:
     @staticmethod
     def as_str_list() -> List[str]:
         """Return all frequency values as a list of strings."""
-        return [frequency.value for frequency in Frequency]
+        return [str(frequency.value) for frequency in Frequency]
 
 
 class MethodOptions:
     """Represents options when defining a method handler."""
 
     security: dict[str, List[str]]
 
+    def __init__(self, security: dict[str, List[str]] = None):
+        """Construct a new HTTP method options object."""
+        self.security = security
+
 
 class FaasWorkerOptions:
     """Empty worker options for generic function handlers."""
+    pass
 
 
 FaasClientOptions = Union[ApiWorkerOptions, RateWorkerOptions, SubscriptionWorkerOptions, FaasWorkerOptions]

nitric/resources/apis.py

@@ -27,7 +27,8 @@
     ApiResource,
     ApiScopes,
     ApiSecurityDefinition,
-    ApiSecurityDefinitionJwt, ResourceDeclareRequest
+    ApiSecurityDefinitionJwt,
+    ResourceDeclareRequest,
 )
 from grpclib import GRPCError
 from nitric.api.exception import exception_from_grpc_error
@@ -55,11 +56,11 @@ class ApiOptions:
     security: Union[dict[str, List[str]], None]
 
     def __init__(
-            self,
-            path: str = "",
-            middleware: List[Middleware] = None,
-            security_definitions: dict[str, SecurityDefinition] = None,
-            security: dict[str, List[str]] = None,
+        self,
+        path: str = "",
+        middleware: List[Middleware] = None,
+        security_definitions: dict[str, SecurityDefinition] = None,
+        security: dict[str, List[str]] = None,
     ):
         """Construct a new API options object."""
         self.middleware = middleware
@@ -82,23 +83,21 @@ def _to_resource(b: Api) -> Resource:
     return Resource(name=b.name, type=ResourceType.Api)
 
 
-def security_definition_to_grpc_declaration(security_definitions: dict[str, SecurityDefinition]) -> Union[
-    dict[str, ApiSecurityDefinition], None]:
+def _security_definition_to_grpc_declaration(
+    security_definitions: dict[str, SecurityDefinition]
+) -> Union[dict[str, ApiSecurityDefinition], None]:
     if security_definitions is None or len(security_definitions) == 0:
         return None
     return {
-        k: ApiSecurityDefinition(
-            jwt=ApiSecurityDefinitionJwt(issuer=v.issuer, audiences=v.audiences)
-        ) for k, v in security_definitions.items()
+        k: ApiSecurityDefinition(jwt=ApiSecurityDefinitionJwt(issuer=v.issuer, audiences=v.audiences))
+        for k, v in security_definitions.items()
     }
 
 
-def security_to_grpc_declaration(security: dict[str, List[str]]) -> dict[str, ApiScopes]:
+def _security_to_grpc_declaration(security: dict[str, List[str]]) -> dict[str, ApiScopes] | None:
     if security is None or len(security) == 0:
         return None
-    return {
-        k: ApiScopes(v) for k, v in security.items()
-    }
+    return {k: ApiScopes(v) for k, v in security.items()}
 
 
 class Api(BaseResource):
@@ -131,9 +130,9 @@ async def _register(self):
                 resource_declare_request=ResourceDeclareRequest(
                     resource=_to_resource(self),
                     api=ApiResource(
-                        security_definitions=security_definition_to_grpc_declaration(self.security_definitions),
-                        security=security_to_grpc_declaration(self.security)
-                    )
+                        security_definitions=_security_definition_to_grpc_declaration(self.security_definitions),
+                        security=_security_to_grpc_declaration(self.security),
+                    ),
                 )
             )
         except GRPCError as grpc_err:
@@ -155,8 +154,18 @@ def all(self, match: str, opts: MethodOptions = None):
 
         def decorator(function: HttpMiddleware):
             r = self._route(match)
-            r.method([HttpMethod.GET, HttpMethod.POST, HttpMethod.PATCH, HttpMethod.PUT, HttpMethod.DELETE,
-                      HttpMethod.OPTIONS], function, opts)
+            r.method(
+                [
+                    HttpMethod.GET,
+                    HttpMethod.POST,
+                    HttpMethod.PATCH,
+                    HttpMethod.PUT,
+                    HttpMethod.DELETE,
+                    HttpMethod.OPTIONS,
+                ],
+                function,
+                opts=opts,
+            )
 
         return decorator
 
@@ -167,7 +176,7 @@ def methods(self, methods: List[HttpMethod], match: str, opts: MethodOptions = N
 
         def decorator(function: HttpMiddleware):
             r = self._route(match)
-            r.method(methods, function, opts)
+            r.method(methods, function, opts=opts)
 
         return decorator
 
@@ -289,7 +298,7 @@ class Method:
     opts: MethodOptions
 
     def __init__(
-            self, route: Route, methods: List[HttpMethod], *middleware: HttpMiddleware, opts: MethodOptions = None
+        self, route: Route, methods: List[HttpMethod], *middleware: HttpMiddleware, opts: MethodOptions = None
     ):
         """Construct a method handler for the specified route."""
         self.route = route
@@ -302,6 +311,6 @@ def start(self):
         Nitric._register_worker(self.server)
 
 
-def api(name: str) -> Api:
-    """Create a new API resource"""
-    return Nitric._create_resource(Api, name)
+def api(name: str, opts: ApiOptions = None) -> Api:
+    """Create a new API resource."""
+    return Nitric._create_resource(Api, name, opts=opts)

nitric/resources/base.py

@@ -56,14 +56,14 @@ async def _register(self):
         pass
 
     @classmethod
-    def make(cls: Type[T], name: str) -> T:
+    def make(cls: Type[T], name: str, *args, **kwargs) -> T:
         """
         Create and register the resource.
 
         The registration process for resources async, so this method should be used instead of __init__.
         """
         # Todo: store the resource reference in a cache to avoid duplicate registrations
-        r = cls(name)
+        r = cls(name, *args, **kwargs)
         try:
             loop = asyncio.get_running_loop()
             r._reg = loop.create_task(r._register())