clear-skies 0.0.3a0__tar.gz

clear_skies-0.0.3a0/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2021 Conor Mancone
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

clear_skies-0.0.3a0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.3
+Name: clear-skies
+Version: 0.0.3a0
+Summary: A framework for building backends in the cloud
+License: MIT
+Author: Conor Mancone
+Author-email: cmancone@gmail.com
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Provides-Extra: jwcrypto
+Provides-Extra: mysql
+Provides-Extra: secrets
+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.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/cmancone/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
+
+To install:
+
+```bash
+pip3 install clear-skies
+```
+
+Documentation is under construction here:
+
+[https://clearskies.info](https://clearskies.info)
+

clear_skies-0.0.3a0/README.md

@@ -0,0 +1,15 @@
+# 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
+
+To install:
+
+```bash
+pip3 install clear-skies
+```
+
+Documentation is under construction here:
+
+[https://clearskies.info](https://clearskies.info)

clear_skies-0.0.3a0/pyproject.toml

@@ -0,0 +1,73 @@
+[project]
+name = "clear-skies"
+description = "A framework for building backends in the cloud"
+version = "v0.0.3-alpha"
+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/cmancone/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/*"
+]
+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$"
+]
+

clear_skies-0.0.3a0/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-0.0.3a0/src/clearskies/action.py

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

clear_skies-0.0.3a0/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-0.0.3a0/src/clearskies/authentication/authentication.py

@@ -0,0 +1,42 @@
+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):
+    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-0.0.3a0/src/clearskies/authentication/authorization.py

@@ -0,0 +1,12 @@
+class 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-0.0.3a0/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-0.0.3a0/src/clearskies/authentication/jwks.py

@@ -0,0 +1,158 @@
+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):
+    """The URL where the JWKS can be found."""
+
+    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-0.0.3a0/src/clearskies/authentication/public.py

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