aws-lambda-env-modeler 1.0.5__tar.gz → 1.0.7__tar.gz

{aws_lambda_env_modeler-1.0.5 → aws_lambda_env_modeler-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws_lambda_env_modeler
-Version: 1.0.5
+Version: 1.0.7
 Summary: AWS-Lambda-Env-Modeler is a Python library designed to simplify the process of managing and validating environment variables in your AWS Lambda functions.
 Home-page: https://github.com/ran-isenberg/aws-lambda-env-modeler
 License: MIT-0
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.8
 Requires-Dist: pydantic (>=2.0.0,<3.0.0)
 Project-URL: Issue tracker, https://github.com/ran-isenberg/aws-lambda-env-modeler/issues
@@ -27,7 +28,7 @@ Description-Content-Type: text/markdown
 # AWS Lambda Environment Variables Modeler (Python)
 
 [![license](https://img.shields.io/github/license/ran-isenberg/aws-lambda-env-modeler)](https://github.com/ran-isenberg/aws-lambda-env-modeler/blob/master/LICENSE)
-![PythonSupport](https://img.shields.io/static/v1?label=python&message=%203.8.17|%203.9|%203.10|%203.11&color=blue?style=flat-square&logo=python)
+![PythonSupport](https://img.shields.io/static/v1?label=python&message=%203.8.17|%203.9|%203.10|%203.11|%203.12&color=blue?style=flat-square&logo=python)
 ![PyPI version](https://badge.fury.io/py/aws-lambda-env-modeler.svg)
 ![PyPi monthly downloads](https://img.shields.io/pypi/dm/aws-lambda-env-modeler)
 [![codecov](https://codecov.io/gh/ran-isenberg/aws-lambda-env-modeler/branch/main/graph/badge.svg?token=P2K7K4KICF)](https://codecov.io/gh/ran-isenberg/aws-lambda-env-modeler)
@@ -98,7 +99,11 @@ class MyEnvVariables(BaseModel):
     API_URL: HttpUrl
 ```
 
-You must first use the `@init_environment_variables` decorator to automatically validate and initialize the environment variables before executing a function:
+Before executing a function, you must use the `@init_environment_variables` decorator to validate and initialize the environment variables automatically.
+
+The decorator guarantees that the function will run with the correct variable configuration.
+
+Then, you can fetch the environment variables using the global getter function, 'get_environment_variables,' and use them just like a data class. At this point, they are parsed and validated.
 
 ```python
 from aws_lambda_env_modeler import init_environment_variables
@@ -118,6 +123,51 @@ env_vars = get_environment_variables(MyEnvVariables)
 print(env_vars.DB_HOST)
 ```
 
+## Disabling Cache for Testing
+
+By default, the modeler uses cache - the parsed model is cached for performance improvement for multiple 'get' calls.
+
+In some cases, such as during testing, you may want to turn off the cache. You can do this by setting the `LAMBDA_ENV_MODELER_DISABLE_CACHE` environment variable to 'True.'
+
+This is especially useful in tests where you want to run multiple tests concurrently, each with a different set of environment variables.
+
+Here's an example of how you can use this in a pytest test:
+
+```python
+import json
+from http import HTTPStatus
+from typing import Any, Dict
+from unittest.mock import patch
+
+from pydantic import BaseModel
+from typing_extensions import Literal
+
+from aws_lambda_env_modeler import LAMBDA_ENV_MODELER_DISABLE_CACHE, get_environment_variables, init_environment_variables
+
+
+class MyHandlerEnvVars(BaseModel):
+    LOG_LEVEL: Literal['DEBUG', 'INFO', 'ERROR', 'CRITICAL', 'WARNING', 'EXCEPTION']
+
+
+@init_environment_variables(model=MyHandlerEnvVars)
+def my_handler(event: Dict[str, Any], context) -> Dict[str, Any]:
+    env_vars = get_environment_variables(model=MyHandlerEnvVars)  # noqa: F841
+    # can access directly env_vars.LOG_LEVEL as dataclass
+    return {
+        'statusCode': HTTPStatus.OK,
+        'headers': {'Content-Type': 'application/json'},
+        'body': json.dumps({'message': 'success'}),
+    }
+
+
+@patch.dict('os.environ', {LAMBDA_ENV_MODELER_DISABLE_CACHE: 'true', 'LOG_LEVEL': 'DEBUG'})
+def test_my_handler():
+    response = my_handler({}, None)
+    assert response['statusCode'] == HTTPStatus.OK
+    assert response['headers'] == {'Content-Type': 'application/json'}
+    assert json.loads(response['body']) == {'message': 'success'}
+```
+
 ## Code Contributions
 Code contributions are welcomed. Read this [guide.](https://github.com/ran-isenberg/aws-lambda-env-modeler/blob/main/CONTRIBUTING.md)
 

{aws_lambda_env_modeler-1.0.5 → aws_lambda_env_modeler-1.0.7}/README.md

@@ -2,7 +2,7 @@
 # AWS Lambda Environment Variables Modeler (Python)
 
 [![license](https://img.shields.io/github/license/ran-isenberg/aws-lambda-env-modeler)](https://github.com/ran-isenberg/aws-lambda-env-modeler/blob/master/LICENSE)
-![PythonSupport](https://img.shields.io/static/v1?label=python&message=%203.8.17|%203.9|%203.10|%203.11&color=blue?style=flat-square&logo=python)
+![PythonSupport](https://img.shields.io/static/v1?label=python&message=%203.8.17|%203.9|%203.10|%203.11|%203.12&color=blue?style=flat-square&logo=python)
 ![PyPI version](https://badge.fury.io/py/aws-lambda-env-modeler.svg)
 ![PyPi monthly downloads](https://img.shields.io/pypi/dm/aws-lambda-env-modeler)
 [![codecov](https://codecov.io/gh/ran-isenberg/aws-lambda-env-modeler/branch/main/graph/badge.svg?token=P2K7K4KICF)](https://codecov.io/gh/ran-isenberg/aws-lambda-env-modeler)
@@ -73,7 +73,11 @@ class MyEnvVariables(BaseModel):
     API_URL: HttpUrl
 ```
 
-You must first use the `@init_environment_variables` decorator to automatically validate and initialize the environment variables before executing a function:
+Before executing a function, you must use the `@init_environment_variables` decorator to validate and initialize the environment variables automatically.
+
+The decorator guarantees that the function will run with the correct variable configuration.
+
+Then, you can fetch the environment variables using the global getter function, 'get_environment_variables,' and use them just like a data class. At this point, they are parsed and validated.
 
 ```python
 from aws_lambda_env_modeler import init_environment_variables
@@ -93,6 +97,51 @@ env_vars = get_environment_variables(MyEnvVariables)
 print(env_vars.DB_HOST)
 ```
 
+## Disabling Cache for Testing
+
+By default, the modeler uses cache - the parsed model is cached for performance improvement for multiple 'get' calls.
+
+In some cases, such as during testing, you may want to turn off the cache. You can do this by setting the `LAMBDA_ENV_MODELER_DISABLE_CACHE` environment variable to 'True.'
+
+This is especially useful in tests where you want to run multiple tests concurrently, each with a different set of environment variables.
+
+Here's an example of how you can use this in a pytest test:
+
+```python
+import json
+from http import HTTPStatus
+from typing import Any, Dict
+from unittest.mock import patch
+
+from pydantic import BaseModel
+from typing_extensions import Literal
+
+from aws_lambda_env_modeler import LAMBDA_ENV_MODELER_DISABLE_CACHE, get_environment_variables, init_environment_variables
+
+
+class MyHandlerEnvVars(BaseModel):
+    LOG_LEVEL: Literal['DEBUG', 'INFO', 'ERROR', 'CRITICAL', 'WARNING', 'EXCEPTION']
+
+
+@init_environment_variables(model=MyHandlerEnvVars)
+def my_handler(event: Dict[str, Any], context) -> Dict[str, Any]:
+    env_vars = get_environment_variables(model=MyHandlerEnvVars)  # noqa: F841
+    # can access directly env_vars.LOG_LEVEL as dataclass
+    return {
+        'statusCode': HTTPStatus.OK,
+        'headers': {'Content-Type': 'application/json'},
+        'body': json.dumps({'message': 'success'}),
+    }
+
+
+@patch.dict('os.environ', {LAMBDA_ENV_MODELER_DISABLE_CACHE: 'true', 'LOG_LEVEL': 'DEBUG'})
+def test_my_handler():
+    response = my_handler({}, None)
+    assert response['statusCode'] == HTTPStatus.OK
+    assert response['headers'] == {'Content-Type': 'application/json'}
+    assert json.loads(response['body']) == {'message': 'success'}
+```
+
 ## Code Contributions
 Code contributions are welcomed. Read this [guide.](https://github.com/ran-isenberg/aws-lambda-env-modeler/blob/main/CONTRIBUTING.md)
 

aws_lambda_env_modeler-1.0.7/aws_lambda_env_modeler/__init__.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+from aws_lambda_env_modeler.modeler import get_environment_variables, init_environment_variables
+from aws_lambda_env_modeler.modeler_impl import LAMBDA_ENV_MODELER_DISABLE_CACHE
+from aws_lambda_env_modeler.types import Annotated, Model
+
+__all__ = ['Model', 'BaseModel', 'init_environment_variables', 'get_environment_variables', 'LAMBDA_ENV_MODELER_DISABLE_CACHE', 'Annotated']

aws_lambda_env_modeler-1.0.7/aws_lambda_env_modeler/modeler.py

@@ -0,0 +1,50 @@
+from functools import wraps
+from typing import Any, Callable, Dict, Type
+
+from aws_lambda_env_modeler.modeler_impl import __get_environment_variables_impl
+from aws_lambda_env_modeler.types import Model
+
+
+def init_environment_variables(model: Type[Model]):
+    """
+    A decorator for AWS Lambda handler functions. It initializes and validates environment variables based on the provided Pydantic model before the execution of the decorated function.
+    It uses LRU Cache by model class type to optimize parsing time. Cache can be disabled by setting the environment variable 'LAMBDA_ENV_MODELER_DISABLE_CACHE' to FALSE (default: cache is enabled)
+
+    Args:
+        model (Type[Model]): A Pydantic model that outlines the structure and types of the expected environment variables.
+
+    Returns:
+        Callable: A decorated function that first initializes and validates the environment variables, then executes the original function.
+
+    Raises:
+        ValueError: If the environment variables do not align with the model's structure or fail validation.
+    """
+
+    def decorator(lambda_handler_function: Callable):
+        @wraps(lambda_handler_function)
+        def wrapper(event: Dict[str, Any], context, **kwargs):
+            # Initialize and validate environment variables before executing the lambda handler function
+            __get_environment_variables_impl(model)
+            return lambda_handler_function(event, context, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def get_environment_variables(model: Type[Model]) -> Model:
+    """
+    Retrieves and validates environment variables based on the provided Pydantic model.
+    It uses LRU Cache by model class type to optimize parsing time. Cache can be disabled by setting the environment variable 'LAMBDA_ENV_MODELER_DISABLE_CACHE' to FALSE (default: cache is enabled)
+    It's recommended to use anywhere in the function's after init_environment_variables decorator was used on the handler function.
+
+    Args:
+        model (Type[Model]): A Pydantic model that outlines the structure and types of the expected environment variables.
+
+    Returns:
+        Model: An instance of the provided model populated with the values of the validated environment variables.
+
+    Raises:
+        ValueError: If the environment variables do not align with the model's structure or fail validation.
+    """
+    return __get_environment_variables_impl(model)

aws_lambda_env_modeler-1.0.7/aws_lambda_env_modeler/modeler_impl.py

@@ -0,0 +1,33 @@
+import os
+from functools import lru_cache
+from typing import Type
+
+from aws_lambda_env_modeler.types import Model
+
+# Environment variable to control caching
+LAMBDA_ENV_MODELER_DISABLE_CACHE = 'LAMBDA_ENV_MODELER_DISABLE_CACHE'
+
+
+def __get_environment_variables_impl(model: Type[Model]) -> Model:
+    # Check if the environment variable for disabling cache is set to true
+    disable_cache = True if os.getenv(LAMBDA_ENV_MODELER_DISABLE_CACHE, 'false').lower() == 'true' else False
+    if disable_cache:
+        # If LAMBDA_ENV_MODELER_DISABLE_CACHE is true, parse the model without cache
+        return __parse_model_impl(model)
+    # If LAMBDA_ENV_MODELER_DISABLE_CACHE is not true, parse the model with cache
+    return __parse_model_with_cache(model)
+
+
+@lru_cache
+def __parse_model_with_cache(model: Type[Model]) -> Model:
+    # Parse the model with cache enabled
+    return __parse_model_impl(model)
+
+
+def __parse_model_impl(model: Type[Model]) -> Model:
+    try:
+        # Validate the model with the environment variables
+        return model.model_validate(os.environ)
+    except Exception as exc:
+        # If validation fails, raise an exception with the error message
+        raise ValueError(f'failed to load environment variables, exception={str(exc)}') from exc

aws_lambda_env_modeler-1.0.7/aws_lambda_env_modeler/types.py

@@ -0,0 +1,14 @@
+import sys
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+Model = TypeVar('Model', bound=BaseModel)
+
+
+if sys.version_info >= (3, 9):
+    from typing import Annotated
+else:
+    from typing_extensions import Annotated
+
+__all__ = ['Model', 'BaseModel', 'Annotated']

{aws_lambda_env_modeler-1.0.5 → aws_lambda_env_modeler-1.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "aws_lambda_env_modeler"
-version = "1.0.5"
+version = "1.0.7"
 description = "AWS-Lambda-Env-Modeler is a Python library designed to simplify the process of managing and validating environment variables in your AWS Lambda functions."
 authors = ["Ran Isenberg"]
 classifiers=[
@@ -12,6 +12,7 @@ classifiers=[
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
 ]
 repository="https://github.com/ran-isenberg/aws-lambda-env-modeler"
 readme = "README.md"
@@ -26,7 +27,7 @@ packages = [
 
 
 [tool.poetry.dependencies]
-python = "^3.8.17 || ^3.9.0 || ^3.10.0 || ^3.11.0"
+python = "^3.8.17 || ^3.9.0 || ^3.10.0 || ^3.11.0 || ^3.12.0"
 pydantic = {version = "^2.0.0"}
 
 [tool.poetry.dev-dependencies]
@@ -38,12 +39,10 @@ pytest-html = "*"
 python-dateutil = "*"
 python-dotenv = "*"
 GitPython = "*"
-yapf = "*"
 radon = "*"
 xenon = "*"
 pre-commit = "*"
-flake8 = "*"
-isort = "*"
+ruff = "*"
 mkdocs-material = "*"
 mkdocs-git-revision-date-plugin = "*"
 types-cachetools = "*"
@@ -52,3 +51,66 @@ types-requests = "*"
 toml = "*"
 wheel = "*"
 setuptools = "*"
+
+[tool.ruff]
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+    "cdk.out",
+    ".vscode",
+    ".pytest_cache",
+    ".build",
+    ".mypy_cache",
+    ".github"
+]
+
+# Same as Black.
+line-length = 150
+indent-width = 4
+
+# Assume Python 3.12
+target-version = "py312"
+
+[tool.ruff.lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "C",  # flake8-comprehensions
+    "B",  # flake8-bugbear
+]
+ignore = [ "E203", "E266", "E501", "W191"]
+
+[tool.ruff.format]
+quote-style = "single"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+[tool.ruff.lint.isort]
+known-third-party = ["pydantic", "aws_lambda_powertools"]

aws_lambda_env_modeler-1.0.5/aws_lambda_env_modeler/__init__.py

@@ -1,13 +0,0 @@
-"""Advanced event_parser utility
-"""
-from pydantic import BaseModel
-
-from .modeler import get_environment_variables, init_environment_variables
-from .types import Model
-
-__all__ = [
-    'Model',
-    'BaseModel',
-    'init_environment_variables',
-    'get_environment_variables',
-]

aws_lambda_env_modeler-1.0.5/aws_lambda_env_modeler/modeler.py

@@ -1,65 +0,0 @@
-import os
-from functools import lru_cache, wraps
-from typing import Any, Callable, Dict, Type
-
-from aws_lambda_env_modeler.types import Model
-
-
-def get_environment_variables(model: Type[Model]) -> Model:
-    """
-    This function receives a model of type Model, uses it to validate the environment variables, and returns the
-    validated model.
-
-    Args:
-        model (Type[Model]): A Pydantic model that defines the structure and types of the expected environment variables.
-
-    Returns:
-        Model: An instance of the provided model filled with the values of the validated environment variables.
-    """
-    return __parse_model(model)
-
-
-def init_environment_variables(model: Type[Model]):
-    """
-    A decorator function for AWS Lambda handler functions that initializes environment variables based on the given Pydantic model before executing
-    the decorated function. The decorator validates the environment variables according to the model structure before
-    running the handler.
-
-    Args:
-        model (Type[Model]): A Pydantic model that defines the structure and types of the expected environment variables.
-
-    Returns:
-        Callable: A decorated function that first initializes the environment variables and then runs the function.
-    """
-
-    def decorator(lambda_handler_function: Callable):
-
-        @wraps(lambda_handler_function)
-        def wrapper(event: Dict[str, Any], context, **kwargs):
-            __parse_model(model)
-            return lambda_handler_function(event, context, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
-@lru_cache
-def __parse_model(model: Type[Model]) -> Model:
-    """
-    A helper function to validate and parse environment variables based on a given Pydantic model. This function is
-    also cached to improve performance in successive calls.
-
-    Args:
-        model (Type[Model]): A Pydantic model that defines the structure and types of the expected environment variables.
-
-    Returns:
-        Model: An instance of the provided model filled with the values of the validated environment variables.
-
-    Raises:
-        ValueError: If the environment variables do not match the structure of the model or cannot be validated.
-    """
-    try:
-        return model.model_validate(os.environ)
-    except Exception as exc:
-        raise ValueError(f'failed to load environment variables, exception={str(exc)}') from exc

aws_lambda_env_modeler-1.0.5/aws_lambda_env_modeler/types.py

@@ -1,7 +0,0 @@
-from typing import TypeVar
-
-from pydantic import BaseModel
-
-Model = TypeVar('Model', bound=BaseModel)
-
-__all__ = ['Model', 'BaseModel']