base-api-utils 1.1.51__tar.gz

base_api_utils-1.1.51/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2025 FNTECH
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

base_api_utils-1.1.51/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: base-api-utils
+Version: 1.1.51
+Summary: Django Rest Framework micro services common utilities
+Author-email: Román Gutierrez <roman@tipit.net>, Sebastian Marcet <sebastian@tipit.net>
+Project-URL: Homepage, https://github.com/fntechgit/base-api-utils
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: boto3
+Requires-Dist: celery
+Requires-Dist: Django
+Requires-Dist: django-celery-results
+Requires-Dist: django_filter
+Requires-Dist: djangorestframework>=3.15.2
+Requires-Dist: drf-spectacular
+Requires-Dist: injector
+Requires-Dist: oauthlib
+Requires-Dist: pika
+Requires-Dist: pybreaker
+Requires-Dist: requests
+Requires-Dist: requests-oauthlib
+Dynamic: license-file
+
+# base-api-utils
+DRF common utilities
+
+## Virtual Env
+
+````bash
+$ python3 -m venv env
+
+$ source env/bin/activate
+````
+
+## python setup
+
+````bash
+sudo add-apt-repository ppa:deadsnakes/ppa -y
+sudo apt-get -y -f install python3.7 python3-pip python3.7-dev python3.7-venv libpython3.7-dev python3-setuptools
+sudo -H pip3 --default-timeout=50 install --upgrade pip
+sudo -H pip3 install virtualenv
+````
+
+## Install reqs
+
+````
+pip install -r requirements.txt 
+````
+
+## Packaging
+
+Create ~/.pypirc:
+
+```bash
+[distutils]
+index-servers =
+    pypi
+
+[pypi]
+username = __token__
+password = pypi-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+
+```
+
+````bash
+python3 -m pip install --upgrade build
+python3 -m build
+````
+## Uploading 
+
+```bash
+python3 -m pip install --upgrade twine
+```
+
+### Test Py Pi
+
+```bash
+python3 -m twine upload --repository testpypi dist/*
+```
+
+## Production PyPi
+
+```bash
+python3 -m twine upload dist/*
+```
+
+## Install from testPyPi.Org
+pip install -i https://test.pypi.org/simple/ base-api-utils --no-deps
+
+## Install from GitHub
+
+pip install git+https://github.com/fntechgit/base-api-utils

base_api_utils-1.1.51/README.md

@@ -0,0 +1,69 @@
+# base-api-utils
+DRF common utilities
+
+## Virtual Env
+
+````bash
+$ python3 -m venv env
+
+$ source env/bin/activate
+````
+
+## python setup
+
+````bash
+sudo add-apt-repository ppa:deadsnakes/ppa -y
+sudo apt-get -y -f install python3.7 python3-pip python3.7-dev python3.7-venv libpython3.7-dev python3-setuptools
+sudo -H pip3 --default-timeout=50 install --upgrade pip
+sudo -H pip3 install virtualenv
+````
+
+## Install reqs
+
+````
+pip install -r requirements.txt 
+````
+
+## Packaging
+
+Create ~/.pypirc:
+
+```bash
+[distutils]
+index-servers =
+    pypi
+
+[pypi]
+username = __token__
+password = pypi-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+
+```
+
+````bash
+python3 -m pip install --upgrade build
+python3 -m build
+````
+## Uploading 
+
+```bash
+python3 -m pip install --upgrade twine
+```
+
+### Test Py Pi
+
+```bash
+python3 -m twine upload --repository testpypi dist/*
+```
+
+## Production PyPi
+
+```bash
+python3 -m twine upload dist/*
+```
+
+## Install from testPyPi.Org
+pip install -i https://test.pypi.org/simple/ base-api-utils --no-deps
+
+## Install from GitHub
+
+pip install git+https://github.com/fntechgit/base-api-utils

base_api_utils-1.1.51/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project]
+name = "base-api-utils"
+version = "1.1.51"
+dependencies = [
+    "boto3",
+    "celery",
+    "Django",
+    "django-celery-results",
+    "django_filter",
+    "djangorestframework>=3.15.2",
+    "drf-spectacular",
+    "injector",
+    "oauthlib",
+    "pika",
+    "pybreaker",
+    "requests",
+    "requests-oauthlib"
+]
+authors = [
+  { name="Román Gutierrez", email="roman@tipit.net" },
+  { name="Sebastian Marcet", email="sebastian@tipit.net" },
+]
+description = "Django Rest Framework micro services common utilities"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/fntechgit/base-api-utils"
+

base_api_utils-1.1.51/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

base_api_utils-1.1.51/src/base_api_utils/__init__.py

@@ -0,0 +1 @@
+from .urls import private_tasks_admin_patterns

base_api_utils-1.1.51/src/base_api_utils/domain/__init__.py

@@ -0,0 +1,3 @@
+from .event_message import EventMessage
+from .event_message_factory import EventMessageFactory
+from .events import DomainEvent

base_api_utils-1.1.51/src/base_api_utils/domain/event_message.py

@@ -0,0 +1,28 @@
+import json
+from typing import Dict, Optional, Any
+
+
+class EventMessage:
+    def __init__(self,
+                 event_type: str,
+                 payload: Dict[str, Any],
+                 routing_key: str,
+                 properties: Optional[Dict[str, Any]] = None) -> None:
+        self.event_type = event_type
+        self.payload = payload
+        self.routing_key = routing_key
+        self.properties = properties
+
+    @staticmethod
+    def from_rabbit(ch, method, properties, body):
+        try:
+            payload = json.loads(body) if isinstance(body, (str, bytes)) else body
+        except json.JSONDecodeError:
+            payload = {"raw_body": str(body)}
+
+        return EventMessage(
+            event_type=method.routing_key,
+            payload=payload,
+            routing_key=method.routing_key,
+            properties=vars(properties) if properties else None
+        )

base_api_utils-1.1.51/src/base_api_utils/domain/event_message_factory.py

@@ -0,0 +1,34 @@
+from typing import Dict, Type
+
+from . import EventMessage
+
+
+class EventMessageFactory:
+    """Factory to create instances based on message type"""
+
+    _message_types: Dict[str, Type[EventMessage]] = {
+        "standard": EventMessage,
+    }
+
+    @classmethod
+    def register_type(cls, name: str, message_class: Type[EventMessage]):
+        cls._message_types[name] = message_class
+
+    @classmethod
+    def create(cls, message_type: str, ch, method, properties, body) -> EventMessage:
+        """
+        Creates an instance of the specified message type
+
+        Args:
+            message_type: Message type name
+            ch, method, properties, body: RabbitMQ params
+
+        Returns:
+            EventMessage instance or its subclass
+        """
+        if message_type is None:
+            message_class = EventMessage
+        else:
+            message_class = cls._message_types.get(message_type, EventMessage)
+
+        return message_class.from_rabbit(ch, method, properties, body)

base_api_utils-1.1.51/src/base_api_utils/domain/events.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class DomainEvent(Enum):
+    AUTH_ACCESS_RIGHT_ADDED = "auth_access_right_added"
+    AUTH_ACCESS_RIGHT_REMOVED = "auth_access_right_removed"
+    AUTH_USER_ADDED_TO_GROUP = "auth_user_added_to_group"
+    AUTH_USER_REMOVED_FROM_GROUP = "auth_user_removed_from_group"
+    AUTH_USER_ADDED_TO_SPONSOR_AND_SUMMIT = "auth_user_added_to_sponsor_and_summit"
+    AUTH_USER_REMOVED_FROM_SPONSOR_AND_SUMMIT = "auth_user_removed_from_sponsor_and_summit"
+    AUTH_USER_REMOVED_FROM_SUMMIT = "auth_user_removed_from_summit"

base_api_utils-1.1.51/src/base_api_utils/dtos/__init__.py

@@ -0,0 +1 @@
+from .authz_user import AuthzUserDTO

base_api_utils-1.1.51/src/base_api_utils/dtos/authz_user.py

@@ -0,0 +1,26 @@
+from ..utils import config
+
+
+class AuthzUserDTO:
+    def __init__(self, token_info=None):
+        if token_info is None:
+            token_info = {}
+        self.id = token_info.get('user_id', None)
+        self.first_name = token_info.get('user_first_name', None)
+        self.last_name = token_info.get('user_last_name', None)
+        self.email = token_info.get('user_email', None)
+        self.groups = token_info.get('user_groups', [])
+
+    def is_admin(self) -> bool:
+        admin_groups = config('OAUTH2.ADMIN_GROUPS', '').split()
+
+        for group in self.groups:
+            if group.get("slug") in admin_groups:
+                return True
+
+        return False
+
+
+
+
+

base_api_utils-1.1.51/src/base_api_utils/fields/__init__.py

@@ -0,0 +1 @@
+from .email_list_field import EmailListField

base_api_utils-1.1.51/src/base_api_utils/fields/email_list_field.py

@@ -0,0 +1,82 @@
+from django.db import models
+from django.core.exceptions import ValidationError
+from django.core.validators import validate_email
+
+class EmailListField(models.CharField):
+    """
+    Custom field that accepts a list of emails or a string with comma-separated emails.
+    Stores them as a SEPARATOR-separated string in the database.
+    """
+    
+    SEPARATOR = ","  # Separator constant for email list
+    
+    def __init__(self, *args, **kwargs):
+        # Set a default max_length if not specified
+        if 'max_length' not in kwargs:
+            kwargs['max_length'] = 1000
+        super().__init__(*args, **kwargs)
+    
+    def deconstruct(self):
+        """Required for Django migrations"""
+        name, path, args, kwargs = super().deconstruct()
+        return name, path, args, kwargs
+    
+    def to_python(self, value):
+        """Converts the value from the database to Python"""
+        if value is None:
+            return value
+        
+        if isinstance(value, list):
+            # If it comes as a list, validate each email and convert to string
+            validated_emails = []
+            for email in value:
+                email = str(email).strip()
+                if email:
+                    try:
+                        validate_email(email)
+                        validated_emails.append(email)
+                    except ValidationError:
+                        raise ValidationError(f"'{email}' is not a valid email")
+            return self.SEPARATOR.join(validated_emails)
+        
+        # If it's already a string, return as is
+        return super().to_python(value)
+    
+    def get_prep_value(self, value):
+        """Prepares the value to be saved to the database"""
+        if value is None:
+            return value
+        
+        if isinstance(value, list):
+            # If it comes as a list, convert to string
+            validated_emails = []
+            for email in value:
+                email = str(email).strip()
+                if email:
+                    validated_emails.append(email)
+            return self.SEPARATOR.join(validated_emails)
+        
+        return super().get_prep_value(value)
+    
+    def validate(self, value, model_instance):
+        """Custom field validation"""
+        # Call parent validation first
+        super().validate(value, model_instance)
+        
+        if value:
+            # If the value is a list, it was already validated in to_python
+            if isinstance(value, str):
+                # Validate each email in the string
+                emails = [email.strip() for email in value.split(self.SEPARATOR)]
+                for email in emails:
+                    if email:  # Avoid empty strings
+                        try:
+                            validate_email(email)
+                        except ValidationError:
+                            raise ValidationError(f"'{email}' is not a valid email")
+    
+    def get_emails_list(self, value):
+        """Helper method to get the list of emails from the stored value"""
+        if not value:
+            return []
+        return [email.strip() for email in value.split(self.SEPARATOR.strip()) if email.strip()]

base_api_utils-1.1.51/src/base_api_utils/filters/__init__.py

@@ -0,0 +1,3 @@
+from .base_filter import BaseFilter
+from .custom_ordering_filter import CustomOrderingFilter
+from .filter_utils_mixin import FilterUtilsMixin

base_api_utils-1.1.51/src/base_api_utils/filters/base_filter.py

@@ -0,0 +1,133 @@
+from .filter_utils_mixin import FilterUtilsMixin
+from ..utils import safe_str_to_number
+from django.db.models import Q
+from django_filters import rest_framework as filters
+
+
+class BaseFilter(FilterUtilsMixin, filters.FilterSet):
+    def parse_list_values(self, value_str):
+        """
+        Parses a string with values separated by && and returns a list.
+        Automatically converts to numbers if possible.
+        """
+        if self.list_separator not in value_str:
+            return None
+
+        values = []
+        for val in value_str.split(self.list_separator):
+            val = val.strip()
+            if self.is_numeric(val):
+                values.append(safe_str_to_number(val))
+            elif self.is_boolean(val):
+                values.append(str(val).lower() == 'true')
+            else:
+                values.append(val)
+        return values
+
+    def filter_field(self, queryset, filter_name, filter_op, filter_value):
+        """
+        Generic method for filtering based on dynamic comparisons.
+        """
+        if filter_op is None:
+            return queryset
+
+        is_exclude_filter = filter_name.endswith('__not_in')
+
+        if is_exclude_filter:
+            # Remove the _not_in suffix to get the actual field name
+            base_field_name = filter_name[:-8]  # Remove '__not_in'
+
+            # Parse the values in the list
+            list_values = self.parse_list_values(filter_value)
+
+            if list_values:
+                # Apply exclusion with __in
+                return queryset.exclude(**{f"{base_field_name}__in": list_values})
+            else:
+                # If not a list, apply simple exclusion
+                value_to_filter = (
+                    safe_str_to_number(filter_value)
+                    if self.is_numeric(filter_value)
+                    else filter_value
+                )
+                return queryset.exclude(**{f"{base_field_name}{filter_op}": value_to_filter})
+
+        value_to_filter = (
+            safe_str_to_number(filter_value)) \
+            if filter_op in ['__gte', '__lte', '__gt', '__lt', ''] and self.is_numeric(filter_value) \
+            else filter_value
+
+        if self.is_boolean(value_to_filter):
+            value_to_filter = str(value_to_filter).lower() == 'true'
+
+        return queryset.filter(**{f"{filter_name}{filter_op}": value_to_filter})
+
+    def apply_or_filters(self, queryset, or_filters):
+        or_filter_subquery = Q()
+        active_filters = self.get_filters()
+        for or_filter in or_filters:
+            filter_name, filter_op, filter_value = self.parse_filter(or_filter)
+            if filter_name in active_filters:
+                filter_name = active_filters[filter_name].field_name
+            or_filter_subquery |= Q(**{f"{filter_name}{filter_op}": filter_value})
+        queryset = queryset.filter(or_filter_subquery)
+        return queryset
+
+    def filter_queryset(self, queryset):
+        """
+        Overrides the `filter_queryset` method to apply filters dynamically.
+        Invoked when Django applies filters to the query.
+
+        Examples of possible filters:
+        - filter[]=field1=@value1,field2>value2                                        (OR filter)
+
+        - filter=field1=@value1,field2>value2                                          (OR filter)
+
+        - filter[]=field1=@value1&filter[]=field2>value2                               (AND filter)
+
+        - filter==field1@@value
+
+        - filter[]=field1_not_in==10&&20&&30                                           (Exclude list)
+
+        - filter[]=field1=@value1,field2=@value2&filter[]=field3=@value3               (OR then AND filter)
+          Generates: ...WHERE (field1 LIKE '%value1%' OR field2 LIKE '%value2%') AND field3 LIKE '%value3%'
+        """
+        and_filter_key = 'and'
+        or_filter_key = 'or'
+
+        filter_without_brackets = self.data.get(self.filter_param, None)
+        filter_with_brackets = self.data.getlist(self.filters_param, [])
+
+        filter_category = {
+            or_filter_key: filter_without_brackets.split(self.filters_separator) if filter_without_brackets else [],
+            and_filter_key: []
+        }
+
+        for item in filter_with_brackets:
+            if "," in item:
+                filter_category[or_filter_key].extend(item.split(self.filters_separator))
+            else:
+                filter_category[and_filter_key].append(item)
+
+        # Apply dynamic filters
+        if filter_category[or_filter_key]:
+            queryset = self.apply_or_filters(queryset, filter_category[or_filter_key])
+
+        if not filter_category[and_filter_key]:
+            return queryset
+
+        # Get filters defined in the FilterSet
+        active_filters = self.get_filters()
+
+        for and_filter in filter_category[and_filter_key]:
+            filter_name, filter_op, filter_value = self.parse_filter(and_filter)
+            if filter_name in active_filters:
+                filter_instance = active_filters[filter_name]
+
+                if filter_instance.method == 'epoch_to_datetime':
+                    queryset = self.filter_by_epoch_timestamp(queryset, filter_instance.field_name, filter_op, filter_value)
+                    continue
+
+                queryset = self.filter_field(queryset, filter_instance.field_name, filter_op, filter_value)
+
+        return queryset

base_api_utils-1.1.51/src/base_api_utils/filters/custom_ordering_filter.py

@@ -0,0 +1,16 @@
+from rest_framework.filters import OrderingFilter
+
+
+class CustomOrderingFilter(OrderingFilter):
+    def get_ordering(self, request, queryset, view):
+        ordering = super().get_ordering(request, queryset, view)
+        if ordering:
+            ordering_map = getattr(view, 'ordering_fields', {})
+
+            mapped_ordering = []
+            for field in ordering:
+                desc = '-' if field.startswith('-') else ''
+                clean_field = field.lstrip('-')
+                mapped_ordering.append(desc + ordering_map.get(clean_field, clean_field))
+            return mapped_ordering
+        return ordering

base_api_utils-1.1.51/src/base_api_utils/filters/filter_utils_mixin.py

@@ -0,0 +1,57 @@
+import re
+from datetime import datetime, timezone
+from rest_framework.exceptions import ValidationError
+
+class FilterUtilsMixin:
+    """Mixin with utilities for filtering and converting values."""
+
+    filter_op = '='
+    filters_separator = ','
+    name_operator_separator = '__'
+    filter_param = 'filter'
+    filters_param = 'filter[]'
+    list_separator = '&&'
+
+    operator_map = {
+        '>=': "__gte",
+        '<=': "__lte",
+        '>': "__gt",
+        '<': "__lt",
+        '==': "",
+        '=@': "__icontains",
+        '@@': "__istartswith"
+    }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.is_number_re = re.compile(r'^-?\d+(\.\d+)?([eE][-+]?\d+)?$')
+        self.split_pattern = '|'.join(map(re.escape, self.operator_map.keys()))
+
+    def is_numeric(self, value):
+        return bool(self.is_number_re.match(str(value)))
+
+    def is_boolean(self, value):
+        return str(value).lower() in ['true', 'false']
+
+    def epoch_to_datetime(self, value):
+        try:
+           return datetime.fromtimestamp(int(value), tz=timezone.utc)
+        except (ValueError, TypeError):
+            return None
+
+    def filter_by_epoch_timestamp(self, queryset, name, op, value):
+        dt = self.epoch_to_datetime(value)
+        if dt is not None:
+            return queryset.filter(**{f"{name}{op}": dt})
+        else:
+            return queryset.none()
+
+    def parse_filter(self, filter_str):
+        try:
+            parts = re.split(f"({self.split_pattern})", filter_str)
+            field_name = parts[0].strip()
+            operator = self.operator_map.get(parts[1].strip())
+            value = parts[2].strip()
+        except ValueError:
+            raise ValidationError("Invalid filter format. Expected 'key=value'.")
+        return field_name, operator, value

base_api_utils-1.1.51/src/base_api_utils/handlers/__init__.py

@@ -0,0 +1 @@
+from .base_event_handler import BaseEventHandler

base_api_utils-1.1.51/src/base_api_utils/handlers/base_event_handler.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+from ..domain import EventMessage
+
+
+class BaseEventHandler(ABC):
+
+    @abstractmethod
+    def can_handle(self, event_type: str) -> bool:
+        pass
+    
+    @abstractmethod
+    def handle(self, event: EventMessage) -> bool:
+        pass

base_api_utils-1.1.51/src/base_api_utils/ioc/__init__.py

@@ -0,0 +1 @@
+from .container import create_container, get_container, set_container

base_api_utils-1.1.51/src/base_api_utils/ioc/container.py

@@ -0,0 +1,14 @@
+from injector import Module, Injector
+from typing import List, Optional
+
+def create_container(modules: List[Module]) -> Injector:
+    return Injector(modules)
+
+_container: Optional[Injector] = None
+
+def get_container() -> Optional[Injector]:
+    return _container
+
+def set_container(container: Injector):
+    global _container
+    _container = container

base_api_utils-1.1.51/src/base_api_utils/models/__init__.py

@@ -0,0 +1 @@
+from .item_image import ItemImage