laibon 0.0.12__tar.gz

laibon-0.0.12/.gitignore

@@ -0,0 +1,4 @@
+*.pyc
+.idea/
+.DS_Store
+dist*

laibon-0.0.12/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2023 Wenceslaus Mumala
+
+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.

laibon-0.0.12/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: laibon
+Version: 0.0.12
+Summary: Common library for django development
+Author-email: Wenceslaus Mumala <info@dvectors.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: django>=4.2
+Requires-Dist: jsonschema>=4.0.0
+Description-Content-Type: text/markdown
+
+# Laibon
+
+Laibon is a collection of useful common classes that can go a long way to help in developing a django based web application.
+
+## Features
+
+- **Database Access**: Abstract adapter pattern for clean separation between business logic and Django models
+- **Flow Management**: Activity-based workflow execution with conditional jumps and error handling  
+- **Container Pattern**: Thread-safe key-value storage for passing data between activities
+- **JSON Validation**: Schema-based request validation with caching for performance
+- **Exception Handling**: Comprehensive exception hierarchy for different error scenarios
+
+## Installation
+
+From PyPI:
+```bash
+python3 -m pip install laibon
+```
+
+From TestPyPI:
+```bash
+pip install --extra-index-url https://testpypi.python.org/pypi laibon
+```
+
+## Quick Examples
+
+### Database Adapter Pattern
+```python
+from laibon.db import Adapter, BaseModel
+
+class UserAdapter(Adapter):
+    def __init__(self, entity_id=None, name=None, email=None):
+        super().__init__(entity_id)
+        self.name = name
+        self.email = email
+    
+    def to_model(self, existing=None):
+        if existing:
+            existing.name = self.name
+            return existing
+        return UserModel(name=self.name, email=self.email)
+```
+
+### Flow Management
+```python
+from laibon.rtf import FlowDefinition, FlowRunner
+
+flow = FlowDefinition("User Registration")
+flow.add(ValidateInputActivity) \
+    .jump_if(ValidationResult.INVALID, ErrorActivity) \
+    .jump_default(CreateUserActivity)
+
+runner = FlowRunner(data_container)
+runner.run_flow(flow)
+```
+
+### JSON Validation
+```python
+from laibon.rest import JSONSchemaValidator
+
+try:
+    JSONSchemaValidator.validate_schema(
+        {"name": "John", "age": 30}, 
+        "user/create_request.json"
+    )
+except JSONValidationException:
+    # Handle validation error
+    pass
+```
+
+## Requirements
+
+- Python >= 3.8
+- Django >= 4.2
+- jsonschema >= 4.0.0

laibon-0.0.12/README.md

@@ -0,0 +1,75 @@
+# Laibon
+
+Laibon is a collection of useful common classes that can go a long way to help in developing a django based web application.
+
+## Features
+
+- **Database Access**: Abstract adapter pattern for clean separation between business logic and Django models
+- **Flow Management**: Activity-based workflow execution with conditional jumps and error handling  
+- **Container Pattern**: Thread-safe key-value storage for passing data between activities
+- **JSON Validation**: Schema-based request validation with caching for performance
+- **Exception Handling**: Comprehensive exception hierarchy for different error scenarios
+
+## Installation
+
+From PyPI:
+```bash
+python3 -m pip install laibon
+```
+
+From TestPyPI:
+```bash
+pip install --extra-index-url https://testpypi.python.org/pypi laibon
+```
+
+## Quick Examples
+
+### Database Adapter Pattern
+```python
+from laibon.db import Adapter, BaseModel
+
+class UserAdapter(Adapter):
+    def __init__(self, entity_id=None, name=None, email=None):
+        super().__init__(entity_id)
+        self.name = name
+        self.email = email
+    
+    def to_model(self, existing=None):
+        if existing:
+            existing.name = self.name
+            return existing
+        return UserModel(name=self.name, email=self.email)
+```
+
+### Flow Management
+```python
+from laibon.rtf import FlowDefinition, FlowRunner
+
+flow = FlowDefinition("User Registration")
+flow.add(ValidateInputActivity) \
+    .jump_if(ValidationResult.INVALID, ErrorActivity) \
+    .jump_default(CreateUserActivity)
+
+runner = FlowRunner(data_container)
+runner.run_flow(flow)
+```
+
+### JSON Validation
+```python
+from laibon.rest import JSONSchemaValidator
+
+try:
+    JSONSchemaValidator.validate_schema(
+        {"name": "John", "age": 30}, 
+        "user/create_request.json"
+    )
+except JSONValidationException:
+    # Handle validation error
+    pass
+```
+
+## Requirements
+
+- Python >= 3.8
+- Django >= 4.2
+- jsonschema >= 4.0.0

laibon-0.0.12/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "laibon"
+dependencies = [
+    "django>=4.2",
+    "jsonschema>=4.0.0"
+]
+
+version = "0.0.12"
+authors = [
+    { name = "Wenceslaus Mumala", email = "info@dvectors.com" },
+]
+description = "Common library for django development"
+readme = "README.md"
+requires-python = ">=3.8"
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+#"Homepage" = "http://"
+#"Bug Tracker" = "http://"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

laibon-0.0.12/src/laibon/accessor.py

@@ -0,0 +1,18 @@
+# Copyright Wenceslaus Mumala 2023. See LICENSE file.
+
+from laibon import common
+from laibon import exception
+
+
+class DelayedExceptionAccessor:
+    _KEY = common.ContainerKey("DelayedException")
+
+    @staticmethod
+    def set(data, data_container: common.Container):
+        if data is None:
+            raise exception.InvalidArgumentException("Cannot set a null object")
+        data_container.put(DelayedExceptionAccessor._KEY, data)
+
+    @staticmethod
+    def get(data_container: common.Container):
+        return data_container.get(DelayedExceptionAccessor._KEY)

laibon-0.0.12/src/laibon/activity.py

@@ -0,0 +1,102 @@
+#  Copyright (c) 2023 Wenceslaus Mumala
+
+import logging
+
+from django.db import transaction
+
+from laibon import accessor
+from laibon import common
+from laibon import db
+from laibon import exception
+
+
+class PersistentDataAccessor:
+    _KEY = common.ContainerKey("PersistentData")
+
+    @staticmethod
+    def set(data, data_container: common.Container):
+        raise exception.InvalidArgumentException("Please use PersistentData#add")
+
+    @staticmethod
+    def get(data_container: common.Container) -> db.PersistentData:
+        res = data_container.get(PersistentDataAccessor._KEY)
+        if res is None:
+            res = db.PersistentData()
+            data_container.put(PersistentDataAccessor._KEY, res)
+        return res
+
+
+class WriteDataActivity(common.Activity):
+    LOGGER = logging.getLogger(__name__)
+
+    def __init__(self):
+        super().__init__()
+
+    class Result(common.ActivityResult):
+        SUCCESS = "Success"
+        WRITE_ERROR = "Failed"
+
+    def get_result_codes(self):
+        return [self.Result.SUCCESS, self.Result.WRITE_ERROR]
+
+    def create_entity(self, entity_adapter: db.Adapter):
+        try:
+            entity = entity_adapter.to_model()
+            entity.save()
+            return entity
+        except Exception as e:
+            self.LOGGER.debug("Failed to store new data because of ", exc_info=True)
+            raise exception.PersistenceException(cause=e)
+
+    def update_entity(self, delta: db.Adapter):
+        try:
+            existing = delta.get_model_class().objects.get(id=delta.id)
+            delta.to_model(existing).save()
+        except Exception as e:
+            self.LOGGER.debug("Failed to update data because of ", exc_info=True)
+            raise exception.PersistenceException(cause=e)
+
+    def delete_entity(self, delta: db.Adapter):
+        # Should be discouraged - also prone to error
+        try:
+            existing = delta.get_model_class().objects.get(id=delta.id)
+            return existing.delete()
+        except Exception as e:
+            self.LOGGER.debug("Error removing data because of ", exc_info=True)
+            raise exception.PersistenceException(cause=e)
+
+    def get_changes(self, data_container: common.Container) -> db.PersistentData:
+        changes: db.PersistentData = PersistentDataAccessor.get(data_container)
+        return changes
+
+    def process(self, data_container: common.Container):
+        WriteDataActivity.LOGGER.debug("Writing flow data to database")
+        try:
+            changes = self.get_changes(data_container)
+            if changes.get_size() > 0:
+                self._write_changes(changes)
+            else:
+                WriteDataActivity.LOGGER.debug("No changes to write")
+        except Exception as e:
+            accessor.DelayedExceptionAccessor.set(e, data_container)
+            WriteDataActivity.LOGGER.debug("Failed to write data because of ", exc_info=True)
+            return self.Result.WRITE_ERROR
+        return common.goto_next()
+
+    @transaction.atomic
+    def _write_changes(self, changes: db.PersistentData):
+        for change in changes.iterator():
+            try:
+                if not change.is_valid():
+                    continue
+                change_type: db.PersistentChange.ChangeType = change.get_change_type()
+                if db.PersistentChange.ChangeType.CREATE == change_type:
+                    self.create_entity(change.get_data())
+                elif db.PersistentChange.ChangeType.UPDATE == change_type:
+                    self.update_entity(change.get_data())
+                elif db.PersistentChange.ChangeType.DELETE == change_type:
+                    self.delete_entity(change.get_data())
+            except Exception as e:
+                self.LOGGER.debug("Failed to write {}".format(change.__class__))
+                raise e
+        WriteDataActivity.LOGGER.debug("Done writing data")

laibon-0.0.12/src/laibon/common.py

@@ -0,0 +1,189 @@
+# Copyright Wenceslaus Mumala 2023. See LICENSE file.
+
+import datetime
+import enum
+import json
+from abc import abstractmethod
+
+from laibon import exception
+
+
+class AbstractEnum(enum.Enum):
+    """Base class for enums with value conversion capabilities."""
+    
+    def __init__(self, value):
+        self._value = value
+
+    def to_value(self):
+        """Return the underlying value of this enum."""
+        return self._value
+
+    @classmethod
+    def from_value(cls, val):
+        """Create enum instance from value, returns None if not found."""
+        for v in cls:
+            if v.to_value() == val:
+                return v
+        return None
+
+
+class ContainerKey:
+    """Hashable key for Container storage with string-based equality."""
+    
+    def __init__(self, key):
+        self.key = key
+
+    def __eq__(self, other):
+        return isinstance(other, ContainerKey) and self.key == other.key
+
+    def __hash__(self):
+        return hash(self.key)
+
+
+class Container:
+    """Generic key-value storage for passing data between activities.
+    
+    Used throughout flows to store and retrieve data. Accessors provide
+    type-safe access patterns for specific data types.
+    """
+
+    def __init__(self):
+        self._container = {}
+
+    def get(self, key):
+        """Retrieve value by key, returns None if not found."""
+        return self._container.get(key)
+
+    def put(self, key, value):
+        """Store value with given key."""
+        self._container[key] = value
+
+
+class FlowRequest:
+    pass
+
+
+class ContainerDataAccessor:
+    def __init__(self, key: ContainerKey):
+        self._key = key
+
+    def set(self, data, data_container: Container):
+        if not isinstance(data, self.get_data_type()):
+            raise exception.InvalidArgumentException()
+        data_container.put(self._key, data)
+
+    def get(self, data_container: Container):
+        return data_container.get(self._key)
+
+    def get_or_raise(self, data_container: Container):
+        v = data_container.get(self._key)
+        if v is None:
+            raise exception.MissingContainerValueException()
+        return v
+
+    @abstractmethod
+    def get_data_type(self) -> type:
+        raise NotImplementedError
+
+
+class ActivityResult(enum.Enum):
+    def __init__(self, value):
+        self._value = value
+
+    def to_value(self):
+        return self._value
+
+    @classmethod
+    def from_value(cls, val):
+        for v in cls:
+            if v.to_value() == val:
+                return v
+        return None
+
+
+class DefaultActivityResult(ActivityResult):
+    # Reserved result codes
+    NEXT = "next"
+
+
+def goto_next() -> ActivityResult:
+    return DefaultActivityResult.NEXT
+
+
+class Activity:
+    """
+    Sub classes must contain methods with a prededifined name and each must return a Result object.
+    Result code 0 should mean completed ok and should proceed normally
+    """
+
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def process(self, container: Container) -> ActivityResult:
+        raise NotImplementedError
+
+    def get_result_codes(self):
+        raise NotImplementedError
+
+
+class JSONObject(object):
+    JSON_DATE_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
+
+    def date_to_json_format(self, dt):
+        return dt.strftime(self.JSON_DATE_TIME_FORMAT)
+
+    def default_parser(self, o):
+        """
+        Default public parser for json
+        """
+        if isinstance(o, datetime.datetime):
+            return self.date_to_json_format(o)
+        if isinstance(o, enum.Enum):
+            return o.name
+        return o.__dict__
+
+    def get_parser(self):
+        return self.default_parser
+
+    def toJSON(self):
+        return json.dumps(self, default=self.get_parser(), sort_keys=True, indent=4)
+
+
+class ListData(JSONObject):
+    def __init__(self):
+        self._data = []
+
+    def add(self, entry):
+        if isinstance(entry, self.get_data_class()):
+            self._data.append(entry)
+        else:
+            raise exception.InvalidArgumentException("Instance does not match expected class.")
+
+    def is_empty(self):
+        return self.get_size() == 0
+
+    @abstractmethod
+    def get_data_class(self) -> type:
+        raise NotImplementedError
+
+    def iterator(self):
+        return iter(self._data)
+
+    def get_item_at(self, index: int):
+        return self._data[index]
+
+    def get_first(self):
+        return self.get_item_at(0)
+
+    def get_size(self):
+        return len(self._data)
+
+    def sort_data(self, sorter_lamda):  # e.g. f = lambda h: h.name
+        sort_list = list(self._data)
+        sort_list.sort(key=sorter_lamda)
+        return iter(sort_list)
+
+    def map_to_list(self, map_function):
+        list_data = list(self._data)
+        return list(map(map_function, list_data))