clear-skies 1.22.31__tar.gz → 2.0.1__tar.gz

{clear_skies-1.22.31 → clear_skies-2.0.1}/PKG-INFO

@@ -1,44 +1,42 @@
 Metadata-Version: 2.3
 Name: clear-skies
-Version: 1.22.31
+Version: 2.0.1
 Summary: A framework for building backends in the cloud
 License: MIT
 Author: Conor Mancone
 Author-email: cmancone@gmail.com
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.11,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Provides-Extra: jose
 Provides-Extra: jwcrypto
 Provides-Extra: mysql
 Provides-Extra: secrets
-Requires-Dist: akeyless (>=5.0.4,<6.0.0) ; extra == "secrets"
-Requires-Dist: akeyless-cloud-id (>=0.3.0,<0.4.0) ; extra == "secrets"
-Requires-Dist: dateparser (>=1.2.2,<2.0.0)
-Requires-Dist: jose (>=1.0.0,<2.0.0) ; extra == "jose"
+Requires-Dist: akeyless (>=4.0.0,<5.0.0) ; extra == "secrets"
+Requires-Dist: akeyless-cloud-id (>=0.2.3,<0.3.0) ; extra == "secrets"
+Requires-Dist: dateparser (>=1.1.8,<2.0.0)
 Requires-Dist: jwcrypto (>=1.5.6,<2.0.0) ; extra == "jwcrypto"
-Requires-Dist: pymysql (>=1.1.1,<2.0.0) ; extra == "mysql"
-Requires-Dist: requests (>=2.32.4,<3.0.0)
-Requires-Dist: typing-extensions (>=4.14.0,<5.0.0) ; python_version == "3.10"
-Project-URL: Repository, https://github.com/cmancone/clearskies
+Requires-Dist: pymysql (>=1.1.0,<2.0.0) ; extra == "mysql"
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: typing-extensions (>=4.12.0,<5.0.0) ; python_version == "3.10"
+Requires-Dist: wrapt (>=1.16.0,<2.0.0)
+Project-URL: Repository, https://github.com/clearskies-py/clearskies
 Description-Content-Type: text/markdown
 
 # clearskies
 
 clearskies is a very opinionated Python framework intended for developing microservices in the cloud via declarative programming principles.  It is mainly intended for backend services and so is designed for RESTful API endpoints, queue listeners, scheduled tasks, and the like.
 
-# Installation, Documentation, and Usage
+## Installation, Documentation, and Usage
 
 To install:
 
-```
+```bash
 pip3 install clear-skies
 ```
 

{clear_skies-1.22.31 → clear_skies-2.0.1}/README.md

@@ -2,11 +2,11 @@
 
 clearskies is a very opinionated Python framework intended for developing microservices in the cloud via declarative programming principles.  It is mainly intended for backend services and so is designed for RESTful API endpoints, queue listeners, scheduled tasks, and the like.
 
-# Installation, Documentation, and Usage
+## Installation, Documentation, and Usage
 
 To install:
 
-```
+```bash
 pip3 install clear-skies
 ```
 

clear_skies-2.0.1/pyproject.toml

@@ -0,0 +1,77 @@
+[project]
+name = "clear-skies"
+description = "A framework for building backends in the cloud"
+version = "v0.0.0-dev"
+license = "MIT"
+dynamic = ["classifiers"]
+readme = "./README.md"
+authors = [{name = "Conor Mancone", email = "cmancone@gmail.com"}]
+requires-python = '>=3.11,<4.0'
+dependencies = ['dateparser (>=1.1.8,<2.0.0)', 'requests (>=2.31.0,<3.0.0)', 'typing-extensions (>=4.12.0,<5.0.0) ; python_version >= "3.10" and python_version < "3.11"', 'wrapt (>=1.16.0,<2.0.0)']
+
+[project.urls]
+repository = "https://github.com/clearskies-py/clearskies"
+
+[project.optional-dependencies]
+secrets = ['akeyless (>=4.0.0,<5.0.0)', 'akeyless-cloud-id (>=0.2.3,<0.3.0)']
+mysql = ['pymysql (>=1.1.0,<2.0.0)']
+jwcrypto = ['jwcrypto (>=1.5.6,<2.0.0)']
+
+[tool.poetry]
+packages = [
+    { include = "clearskies", from = "src" }
+]
+exclude = [
+    "src/clearskies/*_test.py",
+    "src/clearskies/**/*_test.py",
+    "src/clearskies/integration_tests/*",
+    "docs/**"
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Application Frameworks"
+]
+requires-poetry = '>=2.0,<3.0'
+
+[[tool.poetry.source]]
+name = "PyPI"
+priority = "primary"
+
+[tool.poetry.group.dev.dependencies]
+black = "^25.1.0"
+mypy = "^1.16.1"
+pre-commit = "^3.8.0"
+pytest = "^8.4.1"
+ruff = "^0.12.1"
+types-dateparser = "^1.2.2.20250627"
+types-jwcrypto = "^1.5.0.20250516"
+types-pymysql = "^1.1.0.20250516"
+types-requests = "^2.32.4.20250611"
+
+[tool.pytest]
+addopts = "--ignore=src/clearskies/contexts/test.py --cache-clear"
+
+[build-system]
+requires = ['poetry-core (>=2.0,<3.0)']
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 120
+# The following is Black's default, but it's good to be explicit
+# to match your Ruff config.
+skip-magic-trailing-comma = false
+preview = true
+
+[tool.mypy]
+python_version = "3.11"
+
+exclude = [
+ ".*_test\\.py$",
+ "docs/.*"
+]
+
+[tool.poetry-git-version-plugin]
+release_type = "tag"

clear_skies-2.0.1/src/clearskies/__init__.py

@@ -0,0 +1,62 @@
+from . import (
+    authentication,
+    autodoc,
+    backends,
+    columns,
+    configs,
+    contexts,
+    di,
+    endpoints,
+    exceptions,
+    functional,
+    query,
+    # secrets,
+    security_headers,
+    typing,
+    validators,
+)
+from . import parameters_to_properties as parameters_to_properties_module
+from .column import Column
+from .configurable import Configurable
+from .end import End  # type: ignore
+from .endpoint import Endpoint
+from .endpoint_group import EndpointGroup
+from .schema import Schema
+
+parameters_to_properties = parameters_to_properties_module.parameters_to_properties
+
+from .action import Action
+from .environment import Environment
+from .model import Model
+from .security_header import SecurityHeader
+from .validator import Validator
+
+__all__ = [
+    "Action",
+    "Authentication",
+    "autodoc",
+    "backends",
+    "Column",
+    "columns",
+    "configs",
+    "Configurable",
+    "contexts",
+    "di",
+    "End",
+    "Endpoint",
+    "EndpointGroup",
+    "endpoints",
+    "Environment",
+    "exceptions",
+    "functional",
+    "Model",
+    "parameters_to_properties",
+    "Schema",
+    "typing",
+    "Validator",
+    "query",
+    # "secrets",
+    "SecurityHeader",
+    "security_headers",
+    "validators",
+]

clear_skies-2.0.1/src/clearskies/action.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class Action(ABC):
+    @abstractmethod
+    def __call__(self, model):
+        pass

clear_skies-2.0.1/src/clearskies/authentication/__init__.py

@@ -0,0 +1,15 @@
+from clearskies.authentication.authentication import Authentication
+from clearskies.authentication.authorization import Authorization
+from clearskies.authentication.authorization_pass_through import AuthorizationPassThrough
+from clearskies.authentication.jwks import Jwks
+from clearskies.authentication.public import Public
+from clearskies.authentication.secret_bearer import SecretBearer
+
+__all__ = [
+    "Authentication",
+    "Authorization",
+    "AuthorizationPassThrough",
+    "Jwks",
+    "Public",
+    "SecretBearer",
+]

clear_skies-2.0.1/src/clearskies/authentication/authentication.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import requests
+
+import clearskies.configurable
+from clearskies.authentication.authorization import Authorization
+
+if TYPE_CHECKING:
+    from clearskies.security_headers.cors import Cors
+
+
+class Authentication(clearskies.configurable.Configurable, requests.auth.AuthBase):
+    """
+    Authentication!
+    """
+
+    is_public = True
+    can_authorize = False
+    has_dynamic_credentials = False
+
+    def clear_credential_cache(self) -> None:
+        pass
+
+    def headers(self, retry_auth: bool = False) -> dict[str, str]:
+        return {}
+
+    def authenticate(self, input_output) -> bool:
+        return True
+
+    def authorize(self, authorization: Authorization):
+        raise ValueError("Public endpoints do not support authorization")
+
+    def set_headers_for_cors(self, cors: Cors):
+        pass
+
+    def documentation_security_scheme(self) -> dict[str, Any]:
+        return {}
+
+    def documentation_security_scheme_name(self) -> str:
+        return ""
+
+    def __call__(self, request: requests.models.PreparedRequest) -> requests.models.PreparedRequest:
+        request.headers = {**request.headers, **self.headers()}  # type: ignore
+        return request

clear_skies-2.0.1/src/clearskies/authentication/authorization.py

@@ -0,0 +1,16 @@
+class Authorization:
+    """
+    Authorization!
+    """
+
+    def gate(self, authorization_data, input_output):
+        """
+        Return True/False to denote if the given user, as represented by the authorization data, should be allowed access.
+
+        Raise clearskies.exceptions.ClientError if you want to raise a specific error message.
+        """
+        return True
+
+    def filter_model(self, model, authorization_data, input_output):
+        """Return a models object with additional filters applied to account for authorization needs."""
+        return model

clear_skies-2.0.1/src/clearskies/authentication/authorization_pass_through.py

@@ -0,0 +1,20 @@
+import clearskies.di
+
+from .jwks import Jwks
+
+
+class AuthorizationPassThrough(Jwks):
+    """
+    Authentication class with pass through.
+
+    This authentication class takes the authentication header from the incoming request and reflects
+    it on outgoing requests.
+    """
+
+    """
+    The input output helper
+    """
+    input_output = clearskies.di.inject.InputOutput()
+
+    def headers(self, retry_auth=False):
+        return {"Authorization": self.input_output.request_headers.get("authorization", True)}

clear_skies-2.0.1/src/clearskies/authentication/jwks.py

@@ -0,0 +1,163 @@
+import json
+from typing import Any
+
+import clearskies.configs
+import clearskies.di
+import clearskies.parameters_to_properties
+from clearskies.authentication.authentication import Authentication
+from clearskies.exceptions import ClientError
+from clearskies.security_headers.cors import Cors
+
+
+class Jwks(Authentication, clearskies.di.InjectableProperties):
+    """
+    Validate a JWT against a JWKS (JSON Web Key Set)
+    """
+
+    """
+    The URL of the JWKS
+    """
+    jwks_url = clearskies.configs.String(required=True)
+
+    """
+    The audience to accept JWTs for.
+    """
+    audience = clearskies.configs.StringList(default=[])
+
+    """
+    The expected issuer of the JWTs.
+    """
+    issuer = clearskies.configs.String(default="")
+
+    """
+    The allowed algorithms
+    """
+    algorithms = clearskies.configs.StringList(default=["RS256"])
+
+    """
+    The number of seconds for which the JWKS URL contents can be cached
+    """
+    jwks_cache_time = clearskies.configs.Integer(default=86400)
+
+    """
+    The Authorization URL (used in the auto-generated documentation)
+    """
+    authorization_url = clearskies.configs.String()
+
+    """
+    The name of the security scheme in the auto-generated documentation.
+    """
+    documentation_security_name = clearskies.configs.String(default="jwt")
+
+    """
+    The environment helper.
+    """
+    environment = clearskies.di.inject.Environment()
+
+    """
+    The requests object.
+    """
+    requests = clearskies.di.inject.Requests()
+
+    """
+    The JoseJwt library
+    """
+    jose_jwt = clearskies.di.inject.ByName("jose_jwt")
+
+    """
+    The current time
+    """
+    now = clearskies.di.inject.Now()
+
+    """
+    Local cache of the JWKS
+    """
+    _jwks = None
+
+    """
+    The time when the JWKS was last fetched
+    """
+    _jwks_fetched = None
+
+    @clearskies.parameters_to_properties.parameters_to_properties
+    def __init__(
+        self,
+        jwks_url: str,
+        audience: str = "",
+        issuer: str = "",
+        algorithms: list[str] = ["RS256"],
+        jwks_cache_time: int = 86400,
+        authorization_url: str = "",
+        documentation_security_name: str = "jwt",
+    ):
+        self.finalize_and_validate_configuration()
+
+    def authenticate(self, input_output) -> bool:
+        auth_header = input_output.get_request_header("authorization", True)
+        if not auth_header:
+            raise ClientError("Missing 'Authorization' header in request")
+        if auth_header[:7].lower() != "bearer ":
+            raise ClientError("Missing 'Bearer ' prefix in authorization header")
+        self.validate_jwt(auth_header[7:])
+        input_output.authorization_data = self.jwt_claims
+        return True
+
+    def validate_jwt(self, raw_jwt):
+        try:
+            from jwcrypto import jwk, jws, jwt  # type: ignore
+            from jwcrypto.common import JWException  # type: ignore
+        except:
+            raise ValueError(
+                "The JWKS authentication method requires the jwcrypto libraries to be installed.  These are optional dependencies of clearskies, so to include them do a `pip install 'clear-skies[jwcrypto]'`"
+            )
+
+        keys = jwk.JWKSet()
+        keys.import_keyset(json.dumps(self._get_jwks()))
+
+        client_jwt = jwt.JWT()
+        try:
+            client_jwt.deserialize(raw_jwt)
+        except Exception as e:
+            raise ClientError(str(e))
+
+        try:
+            client_jwt.validate(keys)
+            self.jwt_claims = json.loads(client_jwt.claims)
+        except JWException as e:
+            raise ClientError(str(e))
+
+        if self.issuer and self.jwt_claims.get("iss") != self.issuer:
+            raise ClientError("Issuer does not match")
+
+        if self.audience:
+            jwt_audience = self.jwt_claims.get("aud")
+            if not jwt_audience:
+                raise ClientError("Audience required, but missing in JWT")
+            has_match = False
+            for audience in jwt_audience:
+                if audience == self.audience:
+                    has_match = True
+            if not has_match:
+                raise ClientError("Audience does not match")
+
+        return True
+
+    def _get_jwks(self):
+        if self._jwks is None or ((self.now - self._jwks_fetched).total_seconds() > self.jwks_cache_time):
+            self._jwks = self.requests.get(self.jwks_url).json()
+            self._jwks_fetched = self.now
+
+        return self._jwks
+
+    def documentation_security_scheme(self) -> dict[str, Any]:
+        return {
+            "type": "oauth2",
+            "description": "JWT based authentication",
+            "flows": {"implicit": {"authorizationUrl": self.authorization_url, "scopes": {}}},
+        }
+
+    def documentation_security_scheme_name(self) -> str:
+        return self.documentation_security_name
+
+    def set_headers_for_cors(self, cors: Cors):
+        cors.add_header("Authorization")

clear_skies-2.0.1/src/clearskies/authentication/public.py

@@ -0,0 +1,5 @@
+from .authentication import Authentication
+
+
+class Public(Authentication):
+    pass