base-api-utils 1.0.6__tar.gz

base_api_utils-1.0.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 FNTECH
+
+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.

base_api_utils-1.0.6/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.2
+Name: base-api-utils
+Version: 1.0.6
+Summary: Django Rest Framework micro services common utilities
+Author-email: Román Gutierrez <roman@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: djangorestframework>=3.15.2
+Requires-Dist: requests-oauthlib
+Requires-Dist: requests
+Requires-Dist: oauthlib
+Requires-Dist: django_filters
+Requires-Dist: django
+
+# 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
+
+python3 -m pip install --upgrade build
+python3 -m build
+
+## Uploading ( Test Py Pi)
+
+python3 -m pip install --upgrade twine
+python3 -m twine upload --repository testpypi dist/*
+
+## Publish to PyPI
+twine upload dist/*
+
+## Install locally
+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.0.6/README.md

@@ -0,0 +1,44 @@
+# 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
+
+python3 -m pip install --upgrade build
+python3 -m build
+
+## Uploading ( Test Py Pi)
+
+python3 -m pip install --upgrade twine
+python3 -m twine upload --repository testpypi dist/*
+
+## Publish to PyPI
+twine upload dist/*
+
+## Install locally
+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.0.6/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project]
+name = "base-api-utils"
+version = "1.0.6"
+dependencies = [
+    "djangorestframework>=3.15.2",
+    "requests-oauthlib",
+    "requests",
+    "oauthlib",
+    "django_filters",
+    "django"
+]
+authors = [
+  { name="Román Gutierrez", email="roman@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.0.6/setup.cfg

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

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

@@ -0,0 +1 @@
+from .base_filter import BaseFilter

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

@@ -0,0 +1,115 @@
+import re
+
+from django.db.models import Q
+from django_filters import rest_framework as filters
+from rest_framework.exceptions import ValidationError
+
+from utils import safe_str_to_number
+
+class BaseFilter(filters.FilterSet):
+    filter_op = '='
+    filters_separator = ','
+    name_operator_separator = '__'
+    filter_param = 'filter'
+    filters_param = 'filter[]'
+
+    operator_map = {
+        '>=': "__gte",
+        '<=': "__lte",
+        '>': "__gt",
+        '<': "__lt",
+        '==': "",
+        '=@': "__icontains",
+        '@@': "__istartswith"
+    }
+
+    def __init__(self, data=None, queryset=None, *, request=None, prefix=None):
+        super().__init__(data=data, queryset=queryset, request=request, prefix=prefix)
+        self.split_pattern = '|'.join(map(re.escape, self.operator_map.keys()))
+        self.is_number_re = re.compile(r'^-?\d+(\.\d+)?([eE][-+]?\d+)?$')
+
+    def is_numeric(self, value):
+        return bool(self.is_number_re.match(value))
+
+    def parse_filter(self, filter_str):
+        try:
+            parts = re.split(f"({self.split_pattern})", filter_str)
+            field_name = parts[0]
+            operator = self.operator_map.get(parts[1].strip())
+            value = parts[2]
+        except ValueError:
+            raise ValidationError("Invalid filter format. Expected 'key=value'.")
+        return field_name.strip(), operator, value.strip()
+
+    def filter_field(self, queryset, filter_name, filter_op, filter_value):
+        """
+        Generic method for filtering based on dynamic comparisons.
+        """
+        if not filter_op is None:
+            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
+
+            return queryset.filter(**{f"{filter_name}{filter_op}": value_to_filter})
+
+        return queryset
+
+    def apply_or_filters(self, queryset, or_filters):
+        or_filter_subquery = Q()
+        for or_filter in or_filters:
+            filter_name, filter_op, filter_value = self.parse_filter(or_filter)
+            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=@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:
+                queryset = self.filter_field(queryset, filter_name, filter_op, filter_value)
+
+        return queryset

base_api_utils-1.0.6/src/base_api_utils/security/__init__.py

@@ -0,0 +1,3 @@
+from .oauth2_authentication import OAuth2Authentication
+from .oauth2_scope_required import oauth2_scope_required
+from .group_required import group_required

base_api_utils-1.0.6/src/base_api_utils/security/abstract_access_token_service.py

@@ -0,0 +1,11 @@
+from abc import abstractmethod
+
+
+class AbstractAccessTokenService:
+
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def validate(self, access_token:str):
+        pass

base_api_utils-1.0.6/src/base_api_utils/security/abstract_oauth2_api_client.py

@@ -0,0 +1,97 @@
+import logging
+from abc import abstractmethod
+
+from django.core.cache import cache
+from requests_oauthlib import OAuth2Session
+from requests.exceptions import RequestException
+from rest_framework.status import HTTP_404_NOT_FOUND, HTTP_401_UNAUTHORIZED
+
+from security.oauth2_client_factory import OAuth2ClientFactory
+from utils import config
+
+
+class AbstractOAuth2APIClient:
+    MAX_RETRIES = 3
+    SKEW_TIME = 120
+    ACCESS_TOKEN_CACHE_KEY_TEMPLATE = "{}_OAUTH2_ACCESS_TOKEN"
+
+    @abstractmethod
+    def get_app_name(self) -> str:
+        pass
+
+    def get_idp_config(self) -> dict:
+        return {
+            "authorization_endpoint": f'{config('OAUTH2.IDP.BASE_URL')}/{config('OAUTH2.IDP.AUTHORIZATION_ENDPOINT')}',
+            "token_endpoint": f'{config('OAUTH2.IDP.BASE_URL')}/{config('OAUTH2.IDP.TOKEN_ENDPOINT')}',
+        }
+
+    @abstractmethod
+    def get_app_config(self) -> dict:
+        pass
+
+    def get_idp_client(self) -> OAuth2Session:
+        return OAuth2ClientFactory.build(
+            self.get_idp_config(),
+            self.get_app_config()
+        )
+
+    def get_access_token_cache_key(self) -> str:
+        return self.ACCESS_TOKEN_CACHE_KEY_TEMPLATE.format(self.get_app_name())
+
+    def invoke_with_retry(self, callback):
+        retries = 0
+        while retries < self.MAX_RETRIES:
+            try:
+                return callback(self)
+            except RequestException as ex:
+                logging.warning("Retrying due to RequestException...")
+                retries += 1
+                if retries >= self.MAX_RETRIES:
+                    if ex.response and ex.response.status_code == HTTP_404_NOT_FOUND:
+                        return None
+                    raise
+                self.clean_access_token()
+                logging.warning(f"Retry attempt {retries}: {ex}")
+            except Exception as ex:
+                self.clean_access_token()
+                logging.error(f"Unhandled exception: {ex}")
+                raise
+
+    def get_access_token(self) -> str:
+        logging.debug("AbstractOAuth2Api::get_access_token")
+        cache_key = self.get_access_token_cache_key()
+        token = cache.get(cache_key)
+
+        if not token:
+            try:
+                logging.debug("AbstractOAuth2Api::get_access_token - Access token not found in cache, requesting new token...")
+                client = self.get_idp_client()
+                app_config = self.get_app_config()
+                client_secret = app_config.get('client_secret', '')
+
+                token_response = client.fetch_token(
+                    token_url=f'{config('OAUTH2.IDP.BASE_URL')}/{config('OAUTH2.IDP.TOKEN_ENDPOINT')}',
+                    client_secret=client_secret
+                )
+
+                token = token_response["access_token"]
+                expires_in = token_response.get("expires_in", 3600)
+                ttl = max(0, expires_in - self.SKEW_TIME)
+
+                if ttl > 0:
+                    cache.set(cache_key, token, ttl)
+
+                logging.debug(f"AbstractOAuth2Api::get_access_token - New access token obtained: {token}, expires in {ttl} seconds.")
+            except RequestException as ex:
+                logging.warning(f"RequestException: {ex}")
+                if ex.response and ex.response.status_code == HTTP_401_UNAUTHORIZED:
+                    cache.delete(cache_key)
+                raise
+
+        logging.debug(f"AbstractOAuth2Api::Returning cached access token: {token}")
+        return token
+
+    def clean_access_token(self):
+        cache_key = self.get_access_token_cache_key()
+        cache.delete(cache_key)
+

base_api_utils-1.0.6/src/base_api_utils/security/access_token_service.py

@@ -0,0 +1,64 @@
+import logging
+import sys
+
+import requests
+from django.contrib.auth.models import AnonymousUser
+from django.core.cache import cache
+
+from .abstract_access_token_service import AbstractAccessTokenService
+from utils import config
+
+
+class AccessTokenService(AbstractAccessTokenService):
+
+    def validate(self, access_token:str):
+        """
+              Authenticate the request, given the access token.
+        """
+        logging.getLogger('oauth2').debug('AccessTokenService::validate trying to get {access_token} from cache ...'.format(access_token=access_token))
+        # try get access_token from DB and check if not expired
+        cached_token_info = cache.get(access_token)
+
+        if cached_token_info is None:
+            try:
+                logging.getLogger('oauth2').debug(
+                    'AccessTokenService::validate {access_token} is not present on cache, trying to validate from instrospection endpoint'.format(access_token=access_token))
+                response = requests.post(
+                    '{base_url}/{endpoint}'.format
+                        (
+                        base_url=config('OAUTH2.IDP.BASE_URL', None),
+                        endpoint=config('OAUTH2.IDP.INTROSPECTION_ENDPOINT', None)
+                    ),
+                    auth=(config('OAUTH2.CLIENT.ID', None), config('OAUTH2.CLIENT.SECRET', None),),
+                    params={'token': access_token},
+                    verify=False if config('DEBUG', False) else True,
+                    allow_redirects=False
+                )
+
+                if response.status_code == requests.codes.ok:
+                    cached_token_info = response.json()
+                    lifetime = config('OAUTH2.CLIENT.ACCESS_TOKEN_CACHE_LIFETIME', cached_token_info['expires_in'])
+                    logging.getLogger('oauth2').debug(
+                        'AccessTokenService::validate {access_token} storing on cache with lifetime {lifetime}'.format(
+                            access_token=access_token, lifetime=lifetime))
+                    cache.set(access_token, cached_token_info, timeout=int(lifetime))
+                    logging.getLogger('oauth2').warning(
+                        'http code {code} http content {content}'.format(code=response.status_code,
+                                                                         content=response.content))
+                    return AnonymousUser, cached_token_info
+
+                logging.getLogger('oauth2').warning(
+                    'AccessTokenService::validate http code {code} http content {content}'.format(code=response.status_code,
+                                                                     content=response.content))
+                return None
+            except requests.exceptions.RequestException as e:
+                logging.getLogger('oauth2').error(e)
+                return None
+            except:
+                logging.getLogger('oauth2').error(sys.exc_info())
+                return None
+
+        logging.getLogger('oauth2').debug(
+            'AccessTokenService::validate {access_token} cache hit'.format(
+                access_token=access_token))
+        return AnonymousUser, cached_token_info

base_api_utils-1.0.6/src/base_api_utils/security/group_required.py

@@ -0,0 +1,71 @@
+import logging
+import os
+import json
+
+from django.core.exceptions import PermissionDenied
+from django.utils.functional import wraps
+from django.utils.translation import gettext_lazy as _
+
+from security.shared import get_path
+from utils import config, is_empty
+
+
+def group_required():
+    """
+      Decorator to make a view only accept particular groups:
+    """
+    def decorator(func):
+        @wraps(func)
+        def inner(view, *args, **kwargs):
+
+            request = view.request
+            token_info = request.auth
+
+            # shortcircuit
+            if os.getenv("ENV") == 'test':
+               return func(view, *args, **kwargs)
+
+            logger = logging.getLogger('oauth2')
+
+            path = get_path(request)
+            method = str(request.method).lower()
+
+            logger.debug(f'endpoint {method} {path}')
+
+            endpoints = config('OAUTH2.CLIENT.ENDPOINTS')
+
+            if token_info is None:
+                logger.warning('group_required::decorator token info not present')
+                raise PermissionDenied(_("token info not present."))
+
+            logger.debug(f'group_required::decorator token_info {json.dumps(token_info)}')
+
+            endpoint = endpoints[path] if path in endpoints else None
+            if not endpoint:
+                logger.warning('group_required::decorator endpoint info not present')
+                raise PermissionDenied(_("endpoint info not present."))
+
+            endpoint = endpoint[method] if method in endpoint else None
+            if not endpoint:
+                logger.warning('endpoint info not present')
+                raise PermissionDenied(_("endpoint info not present."))
+
+            required_groups = endpoint['groups'] if 'groups' in endpoint else None
+
+            if is_empty(required_groups):
+                return func(view, *args, **kwargs)
+
+            if 'user_groups' in token_info:
+                current_groups = token_info['user_groups']
+                logger.debug(f'current group {current_groups} required groups {required_groups}')
+
+                req_groups = set(required_groups.split())
+                user_groups = set([item['slug'] for item in current_groups])
+
+                if any(group in req_groups for group in user_groups):
+                    return func(view, *args, **kwargs)
+
+            logger.warning('group_required::decorator token groups not present')
+            raise PermissionDenied(_("token groups not present"))
+        return inner
+    return decorator

base_api_utils-1.0.6/src/base_api_utils/security/oauth2_authentication.py

@@ -0,0 +1,35 @@
+import logging
+
+from rest_framework import exceptions
+from rest_framework.authentication import get_authorization_header, BaseAuthentication
+
+from security.access_token_service import AccessTokenService
+
+
+class OAuth2Authentication(BaseAuthentication):
+
+    def __init__(self):
+        self.service = AccessTokenService()
+
+    def authenticate(self, request):
+
+        auth = get_authorization_header(request).split()
+
+        if len(auth) == 1:
+            msg = 'Invalid bearer header. No credentials provided.'
+            raise exceptions.AuthenticationFailed(msg)
+        elif len(auth) > 2:
+            msg = 'Invalid bearer header. Token string should not contain spaces.'
+            raise exceptions.AuthenticationFailed(msg)
+
+        if auth and auth[0].lower() == b'bearer':
+            access_token = auth[1]
+        elif 'access_token' in request.POST:
+            access_token = request.POST['access_token']
+        elif 'access_token' in request.GET:
+            access_token = request.GET['access_token']
+        else:
+            return None
+        logging.getLogger('oauth2').warning(
+            'OAuth2Authentication::authenticate access_token {access_token}'.format(access_token=access_token))
+        return self.service.validate(access_token)

base_api_utils-1.0.6/src/base_api_utils/security/oauth2_client_factory.py

@@ -0,0 +1,42 @@
+import logging
+
+from oauthlib.oauth2 import BackendApplicationClient
+from requests_oauthlib import OAuth2Session
+from requests.adapters import HTTPAdapter
+from urllib3 import Retry
+
+
+class OAuth2ClientFactory:
+    @staticmethod
+    def build(idp_config: dict, app_config: dict) -> OAuth2Session:
+        client_id = app_config.get('client_id', '')
+        client_secret = app_config.get('client_secret', '')
+        scopes = app_config.get('scopes', '').split()
+
+        client = BackendApplicationClient(client_id=client_id, scope=scopes)
+
+        # OAuth2 endpoint urls
+        authorization_endpoint = idp_config.get('authorization_endpoint', '')
+        token_endpoint = idp_config.get('token_endpoint', '')
+
+        session = OAuth2Session(client=client)
+
+        # Retries policy
+        retries = Retry(
+            total=3,
+            backoff_factor=1,
+            status_forcelist=[429, 500, 502, 503, 504]
+        )
+
+        # Retries HTTP adapter
+        http_adapter = HTTPAdapter(max_retries=retries)
+        session.mount('https://', http_adapter)
+        session.mount('http://', http_adapter)
+
+        # Auth and endpoints settings
+        session.auth = (client_id, client_secret)
+        session.authorization_url = authorization_endpoint
+        session.token_url = token_endpoint
+
+        logging.info("OAuth2ClientFactory - OAuth2Session created successfully with client_id: %s", client_id)
+        return session

base_api_utils-1.0.6/src/base_api_utils/security/oauth2_scope_required.py

@@ -0,0 +1,75 @@
+import logging
+import os
+import json
+
+from django.core.exceptions import PermissionDenied
+from django.utils.functional import wraps
+from django.utils.translation import gettext_lazy as _
+
+from security.shared import get_path
+from utils import config, is_empty
+
+
+def oauth2_scope_required():
+    """
+      Decorator to make a view only accept particular scopes:
+    """
+    def decorator(func):
+        @wraps(func)
+        def inner(view, *args, **kwargs):
+
+            request = view.request
+            token_info = request.auth
+
+            # shortcircuit
+            if os.getenv("ENV") == 'test':
+                return func(view, token_info = {}, *args, **kwargs)
+
+            logger = logging.getLogger('oauth2')
+
+            path = get_path(request)
+            method = str(request.method).lower()
+
+            logger.debug('endpoint {method} {path}'.format(method=method, path=path))
+
+            endpoints = config('OAUTH2.CLIENT.ENDPOINTS')
+
+            if token_info is None:
+                logging.getLogger('oauth2').warning(
+                    'oauth2_scope_required::decorator token info not present')
+                raise PermissionDenied(_("token info not present."))
+
+            logger.debug('oauth2_scope_required::decorator token_info {}'.format(
+                json.dumps(token_info)
+            ))
+
+            endpoint = endpoints[path] if path in endpoints else None
+            if not endpoint:
+                logger.warning('oauth2_scope_required::decorator endpoint info not present')
+                raise PermissionDenied(_("endpoint info not present."))
+
+            endpoint = endpoint[method] if method in endpoint else None
+            if not endpoint:
+                logger.warning('endpoint info not present')
+                raise PermissionDenied(_("endpoint info not present."))
+
+            required_scope = endpoint['scopes'] if 'scopes' in endpoint else None
+
+            if is_empty(required_scope):
+                logger.warning('require scope is empty')
+                raise PermissionDenied(_("required scope not present."))
+
+            if 'scope' in token_info:
+                current_scope = token_info['scope']
+
+                logger.debug(f'current scope {current_scope} required scope {required_scope}')
+                # check origins
+                # check scopes
+
+                if len(set.intersection(set(required_scope.split()), set(current_scope.split()))):
+                    return func(view, token_info=token_info, *args, **kwargs)
+
+            logger.warning('oauth2_scope_required::decorator token scopes not present')
+            raise PermissionDenied(_("token scopes not present"))
+        return inner
+    return decorator

base_api_utils-1.0.6/src/base_api_utils/security/shared.py

@@ -0,0 +1,13 @@
+import re
+
+from django.contrib.admindocs.views import simplify_regex
+
+_PATH_PARAMETER_COMPONENT_RE = re.compile(
+    r'<(?:(?P<converter>[^>:]+):)?(?P<parameter>\w+)>'
+)
+
+def get_path(request) -> str:
+    path = simplify_regex(request.resolver_match.route)
+    # Strip Django 2.0 convertors as they are incompatible with uritemplate format
+    path = re.sub(_PATH_PARAMETER_COMPONENT_RE, r'{\g<parameter>}', path)
+    return path.replace('{pk}', '{id}')

base_api_utils-1.0.6/src/base_api_utils/serializers/__init__.py

@@ -0,0 +1 @@
+from .base_model_serializer import BaseModelSerializer

base_api_utils-1.0.6/src/base_api_utils/serializers/base_model_serializer.py

@@ -0,0 +1,96 @@
+from rest_framework import serializers
+
+
+class BaseModelSerializer(serializers.ModelSerializer):
+    PARENT_FIELD_KEY = 'parent_field'
+
+    def __init__(self, *args, **kwargs):
+        context = kwargs.get('context', {})
+        request = context.get('request', None)
+        fields = []
+        relations = []
+
+        if request:
+            fields = request.query_params.get('fields', '').split(',')
+            relations = request.query_params.get('relations', '').split(',')
+
+            kwargs.pop('expand', None)
+            kwargs.pop('fields', None)
+            kwargs.pop('relations', None)
+            kwargs.pop('params', None)
+
+        super().__init__(*args, **kwargs)
+
+        fields_requested = set(fields) if fields else set()
+        relations_requested = set(relations) if relations else set()
+
+        allowed_fields = set(self.get_allowed_fields())
+        allowed_relations = set(self.get_allowed_relations())
+        fields_requested &= allowed_fields
+        relations_requested &= allowed_relations
+
+        if fields_requested or relations_requested:
+            # due to how the DRF serialization mechanism works, both fields and relations are treated the same
+            allowed = fields_requested.union(relations_requested)
+
+            # gets the last key of each requested field (dot notation) to search in the list of fields in the current serializer
+            allowed = {item.split('.')[-1] for item in allowed}
+
+            for field_name in list(self.fields):
+                if field_name not in allowed:
+                    # if the field wasn't specified in request it is removed from the list of fields to serialize
+                    self.fields.pop(field_name)
+
+    def get_allowed_fields(self):
+        # required to know if the serializer was called explicitly from the view or
+        # if it is a delegation from a parent serializer (parent collection field)
+        # - view explicit call -> field_name
+        # - parent serializer delegation -> parent_field_name.field_name
+        parent_field = self.context.get(self.PARENT_FIELD_KEY, None)
+
+        if parent_field:
+            return [f"{parent_field}.{field}" for field in self.fields.keys()]
+
+        return self.fields.keys()
+
+    def get_delegated_allowed_relations(self, allowed_relations):
+        # required to know if the serializer was called explicitly from the view or
+        # if it is a delegation from a parent serializer (parent collection field)
+        # - view explicit call -> field_name
+        # - parent serializer delegation -> parent_field_name.field_name
+        parent_field = self.context.get(self.PARENT_FIELD_KEY, None)
+
+        if parent_field:
+            return [f"{parent_field}.{allowed_relation}" for allowed_relation in allowed_relations]
+
+        return allowed_relations
+
+    def get_allowed_relations(self):
+        return []
+
+    def get_expand(self):
+        request = self.context.get('request', None)
+        str_expand = request.query_params.get('expand', '') if request else None
+        if not str_expand:
+            return []
+
+        expand = str_expand.split(',')
+        parent_field = self.context.get(self.PARENT_FIELD_KEY, None)
+
+        if parent_field:
+            # current serializer related expand
+            pattern = f'{parent_field}.'
+            return [
+                field.split(pattern)[1]
+                for field in expand
+                if pattern in field
+            ]
+
+        return expand
+
+    def get_validation_detail(self, code = 0):
+        errors = [f'{field}: {str(detail)}'
+            for field, details in self.errors.items()
+            for detail in details
+        ]
+        return {'message': 'Validation Failed', 'errors': errors, 'code': code}

base_api_utils-1.0.6/src/base_api_utils/utils/__init__.py

@@ -0,0 +1,5 @@
+from .pagination import LargeResultsSetPagination
+from .config import config
+from .string import is_empty, safe_str_to_number
+from .file_lock import FileLock
+from .exceptions import S3Exception

base_api_utils-1.0.6/src/base_api_utils/utils/config.py

@@ -0,0 +1,18 @@
+from django.conf import settings
+
+
+def config(name: str, default=None):
+    """
+    Helper function to get a Django setting by name. If setting doesn't exists
+    it will return a default.
+    :param name: Name of setting
+    :type name: str
+    :param default: Value if setting is unfound
+    :returns: Setting's value
+    """
+    vars = name.split('.')
+    entry = None
+    for v in vars:
+        entry = getattr(settings, v, default) if entry is None else (entry[v] if v in entry else None)
+
+    return entry

base_api_utils-1.0.6/src/base_api_utils/utils/exceptions.py

@@ -0,0 +1,32 @@
+import logging
+import traceback
+
+from rest_framework.response import Response
+from rest_framework.views import exception_handler
+from rest_framework import status
+from rest_framework.exceptions import ValidationError, NotFound, ErrorDetail
+
+
+def custom_exception_handler(e, context):
+    if isinstance(e, NotFound):
+        return Response({'message': e.__str__()}, status=status.HTTP_404_NOT_FOUND)
+
+    if isinstance(e, ValidationError):
+        errors = [str(error) for error in e.detail]
+        return Response({'message': 'Validation Failed', 'errors': errors, 'code': 0},
+                        status=status.HTTP_412_PRECONDITION_FAILED)
+
+    response = exception_handler(e, context)
+
+    if response is not None:
+        return response
+
+    logging.getLogger('api').error(e)
+    logging.getLogger('api').error(traceback.format_exc())
+    return Response({'message': 'server error'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+class S3Exception(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+

base_api_utils-1.0.6/src/base_api_utils/utils/file_lock.py

@@ -0,0 +1,98 @@
+import os
+import sys
+import errno
+
+from django.conf import settings
+from django.core.files import locks
+
+
+class FileLock:
+
+    class LockFailedException(Exception):
+        pass
+
+    def __init__(self, cron_class, silent, *args, **kwargs):
+        """
+        This method inits the class.
+        You should take care of getting all
+        nessesary thing from input parameters here
+        Base class processes
+            * self.job_name
+            * self.job_code
+            * self.parallel
+            * self.silent
+        for you. The rest is backend-specific.
+        """
+        self.job_name = cron_class.code
+        self.job_code = cron_class.code
+        self.parallel = getattr(cron_class, 'ALLOW_PARALLEL_RUNS', False)
+        self.silent = silent
+
+    def lock(self):
+        try:
+            lock_name = self.get_lock_name()
+            # need loop to avoid races on file unlinking
+            while True:
+                f = open(lock_name, 'wb+', 0)
+                locks.lock(f, locks.LOCK_EX | locks.LOCK_NB)
+                # Here is the Race:
+                # Previous process "A" is still running. Process "B" opens
+                # the file and then the process "A" finishes and deletes it.
+                # "B" locks the deleted file (by fd it already have) and runs,
+                # then the next process "C" creates _new_ file and locks it
+                # successfully while "B" is still running.
+                # We just need to check that "B" didn't lock a deleted file
+                # to avoid any problems. If process "C" have locked
+                # a new file wile "B" stats it then ok, let "B" quit and "C"
+                # run. We can still meet an attacker that permanently
+                # creates and deletes our file but we can't avoid problems
+                # in that case.
+                if os.path.isfile(lock_name):
+                    st1 = os.fstat(f.fileno())
+                    st2 = os.stat(lock_name)
+                    if st1.st_ino == st2.st_ino:
+                        f.write(bytes(str(os.getpid()).encode('utf-8')))
+                        self.lockfile = f
+                        return True
+                # else:
+                # retry. Don't unlink, next process might already use it.
+                f.close()
+
+        except IOError as e:
+            if e.errno in (errno.EACCES, errno.EAGAIN):
+                return False
+            else:
+                e = sys.exc_info()[1]
+                raise e
+        # TODO: perhaps on windows I need to catch different exception type
+
+    def release(self):
+        f = self.lockfile
+        # unlink before release lock to avoid race
+        # see comment in self.lock for description
+        os.unlink(f.name)
+        f.close()
+
+    def get_lock_name(self):
+        default_path = '/tmp'
+        path = getattr(settings, 'DJANGO_CRON_LOCKFILE_PATH', default_path)
+        if not os.path.isdir(path):
+            # let it die if failed, can't run further anyway
+            os.makedirs(path)
+
+        filename = self.job_name + '.lock'
+        return os.path.join(path, filename)
+
+    def lock_failed_message(self):
+        return "%s: lock found. Will try later." % self.job_name
+
+    def __enter__(self):
+        if self.parallel:
+            return
+        else:
+            if not self.lock():
+                raise self.LockFailedException(self.lock_failed_message())
+
+    def __exit__(self, type, value, traceback):
+        if not self.parallel:
+            self.release()

base_api_utils-1.0.6/src/base_api_utils/utils/pagination.py

@@ -0,0 +1,43 @@
+from rest_framework.pagination import PageNumberPagination
+from rest_framework.response import Response
+from collections import OrderedDict
+
+
+class LargeResultsSetPagination(PageNumberPagination):
+    page_size = 10
+    page_size_query_param = 'per_page'
+    max_page_size = 100
+
+    def get_paginated_response(self, data):
+        return Response(OrderedDict([
+            ('total', self.page.paginator.count),
+            ('per_page', self.page.paginator.per_page),
+            ('current_page', self.page.number),
+            ('last_page', self.page.paginator.num_pages),
+            ('data', data)
+        ]))
+
+    def get_paginated_response_schema(self, schema):
+        return {
+            'type': 'object',
+            'properties': {
+                'total': {
+                    'type': 'integer',
+                    'example': 123,
+                },
+                'per_page': {
+                    'type': 'integer',
+                    'example': 123,
+                },
+                'current_page': {
+                    'type': 'integer',
+                    'example': 123,
+                },
+                'last_page': {
+                    'type': 'integer',
+                    'example': 123,
+                },
+                'data': schema,
+            },
+        }
+

base_api_utils-1.0.6/src/base_api_utils/utils/string.py

@@ -0,0 +1,15 @@
+def is_empty(str_val: str) -> bool:
+    return not str_val or not (str_val and str_val.strip())
+
+def safe_str_to_number(value):
+    try:
+        return int(value)
+    except ValueError:
+        pass
+
+    try:
+        return float(value)
+    except ValueError:
+        pass
+
+    raise ValueError(f"'{value}' is not a valid number.")

base_api_utils-1.0.6/src/base_api_utils.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.2
+Name: base-api-utils
+Version: 1.0.6
+Summary: Django Rest Framework micro services common utilities
+Author-email: Román Gutierrez <roman@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: djangorestframework>=3.15.2
+Requires-Dist: requests-oauthlib
+Requires-Dist: requests
+Requires-Dist: oauthlib
+Requires-Dist: django_filters
+Requires-Dist: django
+
+# 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
+
+python3 -m pip install --upgrade build
+python3 -m build
+
+## Uploading ( Test Py Pi)
+
+python3 -m pip install --upgrade twine
+python3 -m twine upload --repository testpypi dist/*
+
+## Publish to PyPI
+twine upload dist/*
+
+## Install locally
+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.0.6/src/base_api_utils.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+LICENSE
+README.md
+pyproject.toml
+src/base_api_utils/__init__.py
+src/base_api_utils.egg-info/PKG-INFO
+src/base_api_utils.egg-info/SOURCES.txt
+src/base_api_utils.egg-info/dependency_links.txt
+src/base_api_utils.egg-info/requires.txt
+src/base_api_utils.egg-info/top_level.txt
+src/base_api_utils/filters/__init__.py
+src/base_api_utils/filters/base_filter.py
+src/base_api_utils/security/__init__.py
+src/base_api_utils/security/abstract_access_token_service.py
+src/base_api_utils/security/abstract_oauth2_api_client.py
+src/base_api_utils/security/access_token_service.py
+src/base_api_utils/security/group_required.py
+src/base_api_utils/security/oauth2_authentication.py
+src/base_api_utils/security/oauth2_client_factory.py
+src/base_api_utils/security/oauth2_scope_required.py
+src/base_api_utils/security/shared.py
+src/base_api_utils/serializers/__init__.py
+src/base_api_utils/serializers/base_model_serializer.py
+src/base_api_utils/utils/__init__.py
+src/base_api_utils/utils/config.py
+src/base_api_utils/utils/exceptions.py
+src/base_api_utils/utils/file_lock.py
+src/base_api_utils/utils/pagination.py
+src/base_api_utils/utils/string.py

base_api_utils-1.0.6/src/base_api_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

base_api_utils-1.0.6/src/base_api_utils.egg-info/requires.txt

@@ -0,0 +1,6 @@
+djangorestframework>=3.15.2
+requests-oauthlib
+requests
+oauthlib
+django_filters
+django

base_api_utils-1.0.6/src/base_api_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+base_api_utils