adjango 0.0.1__tar.gz

adjango-0.0.1/LICENSE

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

adjango-0.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+include README.md

adjango-0.0.1/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.1
+Name: adjango
+Version: 0.0.1
+Summary: A library with many features for interacting with Django
+Home-page: https://github.com/Artasov/adjango
+Author: xlartas
+Author-email: ivanhvalevskey@gmail.com
+Project-URL: Source, https://github.com/Artasov/adjango
+Project-URL: Tracker, https://github.com/Artasov/adjango/issues
+Keywords: adjango django utils funcs features async
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.0
+Classifier: Programming Language :: Python :: 3.8
+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: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django<5.3,>=4.0
+Requires-Dist: pyperclip>=1.8.0
+Requires-Dist: aiohttp>=3.8.0
+
+# ADjango 
+
+**ADjango** 
+> Sometimes I use this in different projects, so I decided to put it on pypi
+
+## Installation
+```bash
+pip install adjango
+```
+
+## Settings
+
+* ### Add the application to the project.
+    ```python
+    INSTALLED_APPS = [
+        #...
+        'adjango',
+    ]
+    ```
+* ### In `settings.py` set the params
+    ```python
+    ADJANGO_BACKENDS_APPS = BASE_DIR / 'apps'
+    ADJANGO_FRONTEND_APPS = BASE_DIR.parent / 'frontend' / 'src' / 'apps'
+    ADJANGO_APPS_PREPATH = 'apps.'
+    ADJANGO_EXCEPTION_REPORT_EMAIL = ('ivanhvalevskey@gmail.com',)
+    ADJANGO_EXCEPTION_REPORT_TEMPLATE = 'core/error_report.html'
+    ADJANGO_LOGGER_NAME = 'global'
+    ADJANGO_EMAIL_LOGGER_NAME = 'email'
+    ```
+    ```python
+    MIDDLEWARE = [
+        ...
+        # add request.ip in views
+        'adjango.middleware.IPAddressMiddleware',  
+        ...
+    ]
+    ```

adjango-0.0.1/README.md

@@ -0,0 +1,37 @@
+# ADjango 
+
+**ADjango** 
+> Sometimes I use this in different projects, so I decided to put it on pypi
+
+## Installation
+```bash
+pip install adjango
+```
+
+## Settings
+
+* ### Add the application to the project.
+    ```python
+    INSTALLED_APPS = [
+        #...
+        'adjango',
+    ]
+    ```
+* ### In `settings.py` set the params
+    ```python
+    ADJANGO_BACKENDS_APPS = BASE_DIR / 'apps'
+    ADJANGO_FRONTEND_APPS = BASE_DIR.parent / 'frontend' / 'src' / 'apps'
+    ADJANGO_APPS_PREPATH = 'apps.'
+    ADJANGO_EXCEPTION_REPORT_EMAIL = ('ivanhvalevskey@gmail.com',)
+    ADJANGO_EXCEPTION_REPORT_TEMPLATE = 'core/error_report.html'
+    ADJANGO_LOGGER_NAME = 'global'
+    ADJANGO_EMAIL_LOGGER_NAME = 'email'
+    ```
+    ```python
+    MIDDLEWARE = [
+        ...
+        # add request.ip in views
+        'adjango.middleware.IPAddressMiddleware',  
+        ...
+    ]
+    ```

adjango-0.0.1/adjango/apps.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class ADjangoConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'adjango'
+    verbose_name = _('ADjango')

adjango-0.0.1/adjango/management/commands/add_paths.py

@@ -0,0 +1,137 @@
+import os
+
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    """
+    Adds a file path comment at the top of each .py and frontend file in the specified app(s).
+
+    @usage:
+      python manage.py add_paths [app_name] [--exclude name1 name2 ...]
+
+    @arg app_name: (optional) Name of the app to process. If not specified, all apps will be processed.
+    @arg --exclude: (optional) List of folder or file names to exclude from processing.
+                      Defaults to excluding 'migrations' folders and '__init__.py' files.
+
+    @behavior:
+      - Process all backend and frontend apps (with default exclusions):
+          python manage.py add_paths
+
+      - Process a specific app (e.g., 'social_oauth'):
+          python manage.py add_paths social_oauth
+
+      - Process all apps, excluding additional folders or files:
+          python manage.py add_paths --exclude migrations __init__.py tests
+
+      - Process a specific app with specified exclusions:
+          python manage.py add_paths social_oauth --exclude migrations __init__.py tests
+    """
+
+    help = 'Adds a file path comment at the top of .py and frontend files in the specified app(s).'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'app_name',
+            nargs='?',
+            default=None,
+            help='(Optional) Name of the app to process. If not specified, all apps will be processed.'
+        )
+        parser.add_argument(
+            '--exclude',
+            nargs='*',
+            default=['migrations', '__init__.py'],
+            help="List of folder or file names to exclude. Defaults to 'migrations' and '__init__.py'."
+        )
+
+    def handle(self, *args, **options):
+        app_name = options['app_name']
+        exclude_names = options['exclude']
+        backend_apps_dir = os.path.join(settings.BASE_DIR, 'apps')
+        frontend_apps_dir = os.path.join(settings.FRONTEND_DIR, 'src', 'apps')
+
+        # Process backend apps
+        self.process_apps(app_name, exclude_names, backend_apps_dir, '.py')
+
+        # Process frontend apps
+        self.process_apps(app_name, exclude_names, frontend_apps_dir, ('.ts', '.tsx', '.js', '.jsx'))
+
+    def process_apps(self, app_name, exclude_names, apps_dir, file_extensions):
+        if app_name:
+            app_paths = [os.path.join(apps_dir, app_name)]
+            if not os.path.exists(app_paths[0]):
+                self.stderr.write(f"App '{app_name}' does not exist in the specified directory.")
+                return
+        else:
+            # Process all apps in the directory
+            app_paths = [
+                os.path.join(apps_dir, name) for name in os.listdir(apps_dir)
+                if os.path.isdir(os.path.join(apps_dir, name)) and not name.startswith('__')
+            ]
+
+        for app_path in app_paths:
+            current_app = os.path.basename(app_path)
+            self.stdout.write(f"Processing app '{current_app}'...")
+            for root, dirs, files in os.walk(app_path):
+                # Exclude specified directories
+                dirs[:] = [d for d in dirs if d not in exclude_names]
+                for file_name in files:
+                    if file_name.endswith(file_extensions) and file_name not in exclude_names:
+                        file_path = os.path.join(root, file_name)
+                        relative_path = os.path.relpath(file_path, apps_dir)
+                        self.check_and_fix_file(file_path, relative_path, file_extensions)
+
+    def check_and_fix_file(self, file_path, relative_path, file_extensions):
+        """
+        Checks and updates the file by adding or correcting the file path comment at the top.
+
+        @param file_path: Full path to the file.
+        @param relative_path: Relative path of the file from the apps directory.
+        @param file_extensions: List of valid file extensions to determine comment type.
+        """
+        with open(file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+
+        # Determine comment style based on file extension
+        if file_path.endswith('.py'):
+            expected_comment = f'# {relative_path.replace(os.sep, "/")}\n'
+            comment_prefix = '#'
+        else:
+            expected_comment = f'// {relative_path.replace(os.sep, "/")}\n'
+            comment_prefix = '//'
+
+        if lines:
+            first_line = lines[0].strip()
+            if first_line == expected_comment.strip():
+                # The file already has the correct comment
+                # self.stdout.write(f"{file_path}: OK")
+                return
+            elif first_line.startswith(('#', '//')):
+                # The file has a comment, but it's incorrect
+                if first_line != expected_comment.strip():
+                    # Update the comment
+                    lines[0] = expected_comment
+                    self.write_file(file_path, lines)
+                    self.stdout.write(f"{file_path}: Updated comment")
+            else:
+                # The first line is not a comment, insert the correct comment at the top
+                lines.insert(0, expected_comment)
+                self.write_file(file_path, lines)
+                self.stdout.write(f"{file_path}: Added missing comment")
+        else:
+            # File is empty, write the comment
+            lines = [expected_comment]
+            self.write_file(file_path, lines)
+            self.stdout.write(f"{file_path}: Added missing comment to empty file")
+
+    @staticmethod
+    def write_file(file_path, lines):
+        """
+        Writes the updated lines back to the file.
+
+        @param file_path: Full path to the file.
+        @param lines: List of lines to write to the file.
+        """
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.writelines(lines)

adjango-0.0.1/adjango/management/commands/copy_proj.py

@@ -0,0 +1,146 @@
+# core/management/commands/copy_proj.py
+import os
+
+import pyperclip
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+TARGET_ALL = [
+    'controllers',
+    'serializers',
+    # 'exceptions',
+    'tests',
+    'models',
+    'routes',
+    'classes',
+    'urls',
+    'service',
+    'services',
+    # 'decorators',
+    # 'permissions',
+    # 'tasks',
+    # 'middleware',
+    # 'forms',
+    # 'components',
+    # 'pages',
+]
+
+
+class Command(BaseCommand):
+    """
+    @behavior:
+        Handles copying the project structure and
+        contents of specified files and directories.
+    @usage:
+        manage.py copy_proj [target_names] --apps [apps] [-b/--backend] [-f/--frontend]
+    @flags:
+        -b, --backend: Include backend files.
+        -f, --frontend: Include frontend files.
+    @args:
+        target_names: list of target directory/file names to collect. Defaults to all if not provided.
+        backend: flag to include backend files.
+        frontend: flag to include frontend files.
+        apps: list of app names to collect from. Defaults to all if not provided.
+    @raise CommandError:
+        If a specified app doesn't exist in backend/frontend.
+    """
+
+    help = 'Copy project structure and contents of specific files and directories.'
+
+    IGNORE_FILES = ['__init__.py']
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'target_names', nargs='*', type=str,
+            help='List of target names to collect. Defaults to all if not provided.'
+        )
+        parser.add_argument(
+            '--apps', nargs='+', type=str,
+            help='List of apps to collect from. Defaults to all if not provided.'
+        )
+        parser.add_argument(
+            '-b', '--backend', action='store_true',
+            help='Include backend files.'
+        )
+        parser.add_argument(
+            '-f', '--frontend', action='store_true',
+            help='Include frontend files.'
+        )
+
+    def handle(self, *args, **options):
+        target_names = options['target_names']
+        include_backend = options['backend']
+        include_frontend = options['frontend']
+
+        # Если флаги не указаны, по умолчанию копируем только backend
+        if not include_backend and not include_frontend:
+            include_backend = True
+
+        if not target_names or target_names[0] == 'all':
+            target_names = TARGET_ALL
+
+        apps_to_include = options['apps'] or self.get_all_apps()
+
+        result = []
+        collected_files = {name: [] for name in target_names}
+
+        if include_backend:
+            for app in apps_to_include:
+                app_path = os.path.join(settings.ADJANGO_APPS_PATH, app)
+                if not os.path.exists(app_path):
+                    self.stdout.write(self.style.ERROR(f"App {app} does not exist in backend. Skipping."))
+                    continue
+                for root, dirs, files in os.walk(app_path):
+                    for name in target_names:
+                        if name in dirs:
+                            dir_path = os.path.join(root, name)
+                            self.collect_directory_contents(dir_path, collected_files[name], settings.BASE_DIR)
+                        if name + '.py' in files:
+                            file_path = os.path.join(root, name + '.py')
+                            self.collect_file_contents(file_path, collected_files[name], settings.BASE_DIR)
+
+        if include_frontend:
+            for app in apps_to_include:
+                app_path = os.path.join(settings.ADJANGO_FRONTEND_DIR, app)
+                if not os.path.exists(app_path):
+                    self.stdout.write(self.style.ERROR(f"App {app} does not exist in frontend. Skipping."))
+                    continue
+                for root, dirs, files in os.walk(app_path):
+                    for name in target_names:
+                        if name in dirs:
+                            dir_path = os.path.join(root, name)
+                            self.collect_directory_contents(dir_path, collected_files[name], settings.FRONTEND_DIR)
+                        # Проверяем файлы с расширениями фронтенда
+                        for ext in ['.ts', '.tsx', '.js', '.jsx']:
+                            file_name = name + ext
+                            if file_name in files:
+                                file_path = os.path.join(root, file_name)
+                                self.collect_file_contents(file_path, collected_files[name], settings.FRONTEND_DIR)
+
+        for name in target_names:
+            if collected_files[name]:
+                result.append(f'\n# {name.capitalize()}\n')
+                result.extend(collected_files[name])
+
+        final_text = '\n'.join(result)
+        pyperclip.copy(final_text)
+        self.stdout.write(self.style.SUCCESS('Project structure and contents copied to clipboard.'))
+        print(final_text)
+
+    def collect_directory_contents(self, dir_path, result, base_dir):
+        for sub_root, sub_dirs, sub_files in os.walk(dir_path):
+            for file in sub_files:
+                if (file.endswith('.py') or file.endswith('.ts') or file.endswith('.tsx') or file.endswith(
+                        '.js') or file.endswith('.jsx')) and file not in self.IGNORE_FILES:
+                    file_path = os.path.join(sub_root, file)
+                    self.collect_file_contents(file_path, result, base_dir)
+
+    def collect_file_contents(self, file_path, result, base_dir):
+        relative_path = os.path.relpath(file_path, base_dir)
+        result.append(f'\n# {relative_path}\n')
+        with open(file_path, 'r', encoding='utf-8') as f:
+            result.append(f.read())
+
+    def get_all_apps(self):
+        apps_path = os.path.join(settings.ADJANGO_BACKENDS_APPS)
+        return [name for name in os.listdir(apps_path) if os.path.isdir(os.path.join(apps_path, name))]

adjango-0.0.1/adjango/management/commands/dumpdata_to_dir.py

@@ -0,0 +1,33 @@
+import os
+
+from django.apps import apps
+from django.core.management import BaseCommand, call_command
+
+
+class Command(BaseCommand):
+    """
+    Dumps data from all models into separate JSON files within a specified directory.
+
+    @usage: python manage.py <command> <directory>
+    """
+
+    help = 'Dumps data from all models into separate files within a specified directory'
+
+    def add_arguments(self, parser) -> None:
+        parser.add_argument('directory', type=str, help='Directory where data files will be saved')
+
+    def handle(self, *args: tuple, **options: dict) -> None:
+        directory: str = options['directory']
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+
+        for app in apps.get_app_configs():
+            for model in app.get_models():
+                model_label = f"{app.label}_{model._meta.model_name}"
+                output_file_path = os.path.join(directory, f"{model_label}.json")
+                self.stdout.write(f"Dumping data for {model_label} into {output_file_path}")
+                try:
+                    with open(output_file_path, 'w', encoding='utf-8') as output_file:
+                        call_command('dumpdata', f'{app.label}.{model._meta.model_name}', stdout=output_file)
+                except Exception:
+                    print(f'{model._meta.model_name} Not Loaded')

adjango-0.0.1/adjango/management/commands/loaddata_from_dir.py

@@ -0,0 +1,53 @@
+import os
+
+from django.core.management import call_command
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    """
+    Loads data from all JSON files within a specified directory into the corresponding models.
+
+    @usage: python manage.py loaddata_from_dir <directory>
+    """
+
+    help = 'Loads data from all files within a specified directory into the corresponding models'
+
+    def add_arguments(self, parser) -> None:
+        parser.add_argument('directory', type=str, help='Directory from which data files will be loaded')
+
+    def handle(self, *args: tuple, **options: dict) -> None:
+        directory: str = options['directory']
+        if not os.path.exists(directory):
+            self.stdout.write(self.style.ERROR(f'Directory {directory} does not exist'))
+            return
+
+        total_files: int = 0
+        loaded_files: int = 0
+        failed_files: list = []
+        successful_files: list = []
+
+        for filename in os.listdir(directory):
+            if filename.endswith('.json'):
+                total_files += 1
+                self.stdout.write(f'Loading data from {filename}')
+                try:
+                    call_command('loaddata', os.path.join(directory, filename))
+                    loaded_files += 1
+                    successful_files.append(filename)
+                except Exception as e:
+                    self.stdout.write(self.style.ERROR(f'{filename} Not Loaded'))
+                    self.stdout.write(self.style.ERROR(str(e)))
+                    failed_files.append(filename)
+
+        self.stdout.write(self.style.SUCCESS(f'Successfully loaded {loaded_files}/{total_files} files.'))
+
+        if successful_files:
+            self.stdout.write(self.style.SUCCESS('Successfully loaded the following files:'))
+            for successful_file in successful_files:
+                self.stdout.write(self.style.SUCCESS(f'- {successful_file}'))
+
+        if failed_files:
+            self.stdout.write(self.style.ERROR('Failed to load the following files:'))
+            for failed_file in failed_files:
+                self.stdout.write(self.style.ERROR(f'- {failed_file}'))

adjango-0.0.1/adjango/management/commands/remakemigrations.py

@@ -0,0 +1,42 @@
+# core/management/commands/remakemigrations.py
+import glob
+import os
+from time import sleep
+
+from django.conf import settings
+from django.core.management import BaseCommand, call_command
+
+
+class Command(BaseCommand):
+    help = ('Delete all migration files from apps in the "apps." namespace, '
+            'delete SQLite database file if used, and run makemigrations and migrate')
+
+    def handle(self, *args, **kwargs):
+        apps_prepath = settings.ADJANGO_APPS_PREPATH
+        base_dir = settings.BASE_DIR
+
+        # Delete migration files
+        for app in settings.INSTALLED_APPS:
+            if apps_prepath is None or app.startswith(apps_prepath):
+                app_path = os.path.join(base_dir, app.replace('.', '/'))
+                migrations_path = os.path.join(app_path, 'migrations')
+                if os.path.exists(migrations_path):
+                    files = glob.glob(os.path.join(migrations_path, '*.py'))
+                    for file in files:
+                        if os.path.basename(file) != '__init__.py':
+                            os.remove(file)
+                            self.stdout.write(f'Deleted {file}')
+
+                    pyc_files = glob.glob(os.path.join(migrations_path, '*.pyc'))
+                    for file in pyc_files:
+                        os.remove(file)
+                        self.stdout.write(f'Deleted {file}')
+
+        self.stdout.write('All migration files in apps.* deleted')
+        sleep(1)
+
+        # Run makemigrations
+        self.stdout.write('Running makemigrations...')
+        call_command('makemigrations')
+        self.stdout.write('Makemigrations completed')
+        sleep(1)

adjango-0.0.1/adjango/middleware.py

@@ -0,0 +1,18 @@
+class IPAddressMiddleware:
+    """
+    Позволяет легко получать IP-адрес через `request.ip`.
+    """
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        if request.META.get('HTTP_X_FORWARDED_FOR'):
+            request.ip = request.META.get('HTTP_X_FORWARDED_FOR')
+        elif request.META.get("HTTP_X_REAL_IP"):
+            request.ip = request.META.get("HTTP_X_REAL_IP")
+        elif request.META.get("REMOTE_ADDR"):
+            request.ip = request.META.get("REMOTE_ADDR")
+        else:
+            request.ip = None
+        return self.get_response(request)

adjango-0.0.1/adjango/utils/base.py

@@ -0,0 +1,200 @@
+import asyncio
+import functools
+import json
+import logging
+import time
+from pprint import pprint
+from time import time
+
+import aiohttp
+from asgiref.sync import sync_to_async
+from django.conf import settings
+from django.contrib.auth.models import Group
+from django.core.files.base import ContentFile
+from django.core.handlers.asgi import ASGIRequest
+from django.core.handlers.wsgi import WSGIRequest
+from django.db import transaction
+from django.http import HttpResponseNotAllowed, HttpResponse, QueryDict, RawPostDataException
+from django.shortcuts import redirect
+
+from adjango.utils.common import traceback_str
+from adjango.utils.mail import send_emails
+
+
+async def download_file_to_temp(url: str) -> ContentFile:
+    """
+    Скачивает файл с URL и сохраняет его в объект ContentFile, не сохраняя на диск.
+
+    @param url: URL файла, который нужно скачать.
+    @return: Временный файл в памяти.
+    """
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as response:
+            if response.status == 200:
+                file_content = await response.read()
+                file_name = url.split('/')[-1]
+                return ContentFile(file_content, name=file_name)
+            raise ValueError(f"Failed to download image from {url}, status code: {response.status}")
+
+
+def add_user_to_group(user, group_name):
+    group, created = Group.objects.get_or_create(name=group_name)
+    if user not in group.user_set.all():
+        group.user_set.add(user)
+
+
+def allowed_only(allowed_methods):
+    def decorator(view_func):
+        def wrapped_view(request, *args, **kwargs):
+            if request.method in allowed_methods:
+                return view_func(request, *args, **kwargs)
+            else:
+                return HttpResponseNotAllowed(allowed_methods)
+
+        return wrapped_view
+
+    return decorator
+
+
+def aallowed_only(allowed_methods) -> callable:
+    def decorator(view_func) -> callable:
+        async def wrapped_view(request, *args, **kwargs) -> HttpResponse:
+            if request.method in allowed_methods:
+                if asyncio.iscoroutinefunction(view_func):
+                    return await view_func(request, *args, **kwargs)
+                else:
+                    return view_func(request, *args, **kwargs)
+            else:
+                return HttpResponseNotAllowed(allowed_methods)
+
+        return wrapped_view
+
+    return decorator
+
+
+async def apprint(*args, **kwargs):
+    await sync_to_async(pprint)(*args, **kwargs)
+
+
+def force_data(fn):
+    @functools.wraps(fn)
+    def _wrapped_view(request, *args, **kwargs):
+        data = {}
+
+        if isinstance(request.POST, QueryDict):  # Объединяем данные из request.POST
+            data.update(request.POST.dict())
+        else:
+            data.update(request.POST)
+
+        if isinstance(request.GET, QueryDict):  # Объединяем данные из request.GET
+            data.update(request.GET.dict())
+        else:
+            data.update(request.GET)
+
+        try:  # Обрабатываем JSON-тело запроса, если оно есть
+            json_data = json.loads(request.body)
+            if isinstance(json_data, dict):
+                data.update(json_data)
+        except (ValueError, TypeError, RawPostDataException):
+            pass
+
+        setattr(request, 'get_data', lambda: data)
+        return fn(request, *args, **kwargs)
+
+    return _wrapped_view
+
+
+def aforce_data(fn):
+    @functools.wraps(fn)
+    async def _wrapped_view(request, *args, **kwargs):
+        if isinstance(request.POST, QueryDict):  # Объединяем данные из request.POST
+            request.data.update(request.POST.dict())
+        else:
+            request.data.update(request.POST)
+
+        if isinstance(request.GET, QueryDict):  # Объединяем данные из request.GET
+            request.data.update(request.GET.dict())
+        else:
+            request.data.update(request.GET)
+
+        try:  # Обрабатываем JSON-тело запроса, если оно есть
+            json_data = json.loads(request.body.decode('utf-8'))
+            if isinstance(json_data, dict):
+                request.data.update(json_data)
+        except (ValueError, TypeError, UnicodeDecodeError, RawPostDataException):
+            pass
+
+        return await fn(request, *args, **kwargs)
+
+    return _wrapped_view
+
+
+def acontroller(name=None, logger=settings.ADJANGO_LOGGER_NAME, log_name=True, log_time=False) -> callable:
+    def decorator(fn) -> callable:
+        @functools.wraps(fn)
+        async def inner(request: ASGIRequest, *args, **kwargs):
+            log = logging.getLogger(logger)
+            fn_name = name or fn.__name__
+            if log_name: log.info(f'ACtrl: {request.method} | {fn_name}')
+            if log_time:
+                start_time = time()
+
+            if settings.DEBUG:
+                return await fn(request, *args, **kwargs)
+            else:
+                try:
+                    if log_time:
+                        end_time = time()
+                        elapsed_time = end_time - start_time
+                        log.info(f"Execution time of {fn_name}: {elapsed_time:.2f} seconds")
+                    return await fn(request, *args, **kwargs)
+                except Exception as e:
+                    log.critical(f"ERROR in {fn_name}: {traceback_str(e)}", exc_info=True)
+                    send_emails(
+                        subject='SERVER ERROR',
+                        emails=settings.ADJANGO_EXCEPTION_REPORT_EMAILS,
+                        template=settings.ADJANGO_EXCEPTION_REPORT_TEMPLATE,
+                        context={'traceback': traceback_str(e), }
+                    )
+                    raise e
+
+        return inner
+
+    return decorator
+
+
+def controller(name=None, logger=settings.ADJANGO_LOGGER_NAME, log_name=True, log_time=False,
+               auth_required=False, not_auth_redirect=settings.LOGIN_URL) -> callable:
+    def decorator(fn) -> callable:
+        @functools.wraps(fn)
+        def inner(request: WSGIRequest, *args, **kwargs):
+            log = logging.getLogger(logger)
+            fn_name = name or fn.__name__
+            if log_name: log.info(f'Ctrl: {request.method} | {fn_name}')
+            if log_time: start_time = time()
+            if auth_required:
+                if not request.user.is_authenticated: return redirect(not_auth_redirect)
+            if settings.DEBUG:
+                with transaction.atomic():
+                    return fn(request, *args, **kwargs)
+            else:
+                try:
+                    if log_time:
+                        end_time = time()
+                        elapsed_time = end_time - start_time
+                        log.info(f"Execution time of {fn_name}: {elapsed_time:.2f} seconds")
+                    with transaction.atomic():
+                        return fn(request, *args, **kwargs)
+                except Exception as e:
+                    log.critical(f"ERROR in {fn_name}: {traceback_str(e)}", exc_info=True)
+                    send_emails(
+                        subject='SERVER ERROR',
+                        emails=settings.ADJANGO_EXCEPTION_REPORT_EMAILS,
+                        template=settings.ADJANGO_EXCEPTION_REPORT_TEMPLATE,
+                        context={'traceback': traceback_str(e), }
+                    )
+                    raise e
+
+        return inner
+
+    return decorator

adjango-0.0.1/adjango/utils/common.py

@@ -0,0 +1,5 @@
+import traceback
+
+
+def traceback_str(error: BaseException) -> str:
+    return ''.join(traceback.format_exception(type(error), error, error.__traceback__))

adjango-0.0.1/adjango/utils/funcs.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from functools import wraps
+from typing import Any, Type
+from urllib.parse import urlparse
+
+from asgiref.sync import sync_to_async
+from django.conf import settings
+from django.contrib.auth import REDIRECT_FIELD_NAME
+from django.core.files.base import ContentFile
+from django.db.models import QuerySet, Model, Manager
+from django.db.transaction import Atomic
+from django.shortcuts import resolve_url, redirect
+
+from adjango.utils import download_file_to_temp
+
+
+class AsyncAtomicContextManager(Atomic):
+    def __init__(self, using=None, savepoint=True, durable=False):
+        super().__init__(using, savepoint, durable)
+
+    async def __aenter__(self):
+        await sync_to_async(super().__enter__)()
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await sync_to_async(super().__exit__)(exc_type, exc_value, traceback)
+
+
+def aatomic(view_func):
+    @wraps(view_func)
+    async def _wrapped_view(request, *args, **kwargs):
+        async with AsyncAtomicContextManager():
+            return await view_func(request, *args, **kwargs)
+
+    return _wrapped_view
+
+
+async def aget(
+        queryset: QuerySet,
+        exception: Type[Exception] | None = None,
+        *args: Any,
+        **kwargs: Any,
+
+) -> Model | None:
+    """
+    Асинхронно получает единственный объект из заданного QuerySet, соответствующий переданным параметрам.
+
+    @param queryset: QuerySet, из которого нужно получить объект.
+    @param exception: Класс исключения, которое будет выброшено, если объект не найден. Если None, возвращается None.
+
+    @return: Объект модели или None, если объект не найден и exception не задан.
+
+    @raises exception: Если объект не найден и передан класс исключения.
+
+    @behavior:
+        - Пытается асинхронно получить объект с помощью queryset.aget().
+        - Если объект не найден, обрабатывает исключение DoesNotExist.
+        - Если exception is not None, выбрасывает указанное исключение.
+        - Если exception is None, возвращает None.
+
+    @usage:
+        result = await aget(MyModel.objects, MyCustomException, id=1)
+    """
+    try:
+        return await queryset.aget(*args, **kwargs)
+    except queryset.model.DoesNotExist:
+        if exception is not None:
+            raise exception()
+    return None
+
+
+async def arelated(model_object, related_field_name: str) -> object or None:
+    return await sync_to_async(getattr)(model_object, related_field_name, None)
+
+
+async def aadd(queryset, data, *args, **kwargs):
+    return await sync_to_async(queryset.add)(data, *args, **kwargs)
+
+
+async def aall(objects: Manager) -> list:
+    return await sync_to_async(list)(objects.all())
+
+
+async def afilter(queryset, *args, **kwargs) -> list:
+    """
+    This function is used to filter objects...
+    :param queryset:
+    :param args:
+    :param kwargs:
+    :return: List of ...
+    """
+    return await sync_to_async(list)(queryset.filter(*args, **kwargs))
+
+
+def auser_passes_test(test_func, login_url=None, redirect_field_name=REDIRECT_FIELD_NAME):
+    """
+    Decorator for views that checks that the user passes the given test,
+    redirecting to the log-in page if necessary. The test should be a callable
+    that takes the user object and returns True if the user passes.
+    """
+    if not login_url:
+        login_url = settings.LOGIN_URL
+
+    def decorator(view_func):
+        @wraps(view_func)
+        async def _wrapped_view(request, *args, **kwargs):
+            if await test_func(request.user):
+                return await view_func(request, *args, **kwargs)
+            path = request.build_absolute_uri()
+            resolved_login_url = resolve_url(login_url)
+            # If the login_url is the same scheme and net location then just
+            # use the path as the "next" url.
+            login_scheme, login_netloc = urlparse(resolved_login_url)[:2]
+            current_scheme, current_netloc = urlparse(path)[:2]
+            if ((not login_scheme or login_scheme == current_scheme) and
+                    (not login_netloc or login_netloc == current_netloc)):
+                path = request.get_full_path()
+            return redirect(login_url)
+
+        return _wrapped_view
+
+    return decorator
+
+
+def alogin_required(
+        function=None, redirect_field_name=REDIRECT_FIELD_NAME, login_url=None
+):
+    """
+    Decorator for views that checks that the user is logged in, redirecting
+    to the log-in page if necessary.
+    """
+    actual_decorator = auser_passes_test(
+        sync_to_async(lambda u: u.is_authenticated),
+        login_url=login_url,
+        redirect_field_name=redirect_field_name,
+    )
+    if function:
+        return actual_decorator(function)
+    return actual_decorator
+
+
+async def set_image_by_url(model_obj: Model, field_name: str, image_url: str) -> None:
+    """
+    Загружает изображение с заданного URL и устанавливает его в указанное поле модели без
+    предварительного сохранения файла на диск.
+
+    @param model_obj: Экземпляр модели, в который нужно установить изображение.
+    @param field_name: Название поля, в которое нужно сохранить изображение.
+    @param image_url: URL изображения, которое нужно загрузить.
+    @return: None
+    """
+    # Скачиваем изображение как объект ContentFile
+    image_file: ContentFile = await download_file_to_temp(image_url)
+
+    # Используем setattr, чтобы установить файл в поле модели
+    await sync_to_async(getattr(model_obj, field_name).save)(image_file.name, image_file)
+    await model_obj.asave()

adjango-0.0.1/adjango/utils/mail.py

@@ -0,0 +1,30 @@
+import json
+import logging
+
+from django.conf import settings
+from django.core.mail import send_mail
+from django.template.loader import render_to_string
+
+log = logging.getLogger(settings.ADJANGO_EMAIL_LOGGER_NAME)
+
+
+def send_emails(subject: str, emails: tuple, template: str, context=None):
+    """
+    Отправляет email с использованием указанного шаблона.
+
+    @param subject: Тема письма.
+    @param emails: Список email-адресов получателей.
+    @param template: Путь к шаблону письма.
+    @param context: Контекст для рендеринга шаблона.
+    """
+    if send_mail(
+            subject=subject, message=str(json.dumps(context)),
+            from_email=settings.EMAIL_HOST_USER,
+            recipient_list=list(emails),
+            html_message=render_to_string(template, context=context if context is not None else {})
+    ):
+        log.info(f'Successfully sent template={template} emails {", ".join(emails)}')
+    else:
+        log.critical(
+            f'Failed to send template={template} emails {", ".join(emails)} context={str(json.dumps(context))}'
+        )

adjango-0.0.1/adjango/utils/rediser.py

@@ -0,0 +1,105 @@
+from django.core.cache import cache as djc
+
+MIN_1 = 1 * 60
+MIN_5 = 5 * 60
+MIN_10 = 10 * 60
+MIN_15 = 15 * 60
+MIN_20 = 20 * 60
+MIN_25 = 25 * 60
+MIN_30 = 30 * 60
+MIN_40 = 40 * 60
+MIN_50 = 50 * 60
+HOUR_1 = 1 * 60 * 60
+HOUR_2 = 2 * 60 * 60
+HOUR_3 = 3 * 60 * 60
+HOUR_4 = 4 * 60 * 60
+HOUR_5 = 5 * 60 * 60
+HOUR_6 = 6 * 60 * 60
+HOUR_7 = 7 * 60 * 60
+HOUR_8 = 8 * 60 * 60
+HOUR_9 = 9 * 60 * 60
+HOUR_10 = 10 * 60 * 60
+HOUR_11 = 11 * 60 * 60
+HOUR_12 = 12 * 60 * 60
+HOUR_13 = 13 * 60 * 60
+HOUR_14 = 14 * 60 * 60
+HOUR_15 = 15 * 60 * 60
+HOUR_16 = 16 * 60 * 60
+HOUR_17 = 17 * 60 * 60
+HOUR_18 = 18 * 60 * 60
+HOUR_19 = 19 * 60 * 60
+HOUR_20 = 20 * 60 * 60
+HOUR_21 = 21 * 60 * 60
+HOUR_22 = 22 * 60 * 60
+HOUR_23 = 23 * 60 * 60
+DAY_1 = 1 * 60 * 60 * 24
+DAYS_2 = 2 * 60 * 60 * 24
+DAYS_3 = 3 * 60 * 60 * 24
+DAYS_4 = 4 * 60 * 60 * 24
+DAYS_5 = 5 * 60 * 60 * 24
+DAYS_6 = 6 * 60 * 60 * 24
+DAYS_7 = 7 * 60 * 60 * 24
+DAYS_8 = 8 * 60 * 60 * 24
+DAYS_9 = 9 * 60 * 60 * 24
+DAYS_10 = 10 * 60 * 60 * 24
+DAYS_11 = 11 * 60 * 60 * 24
+DAYS_12 = 12 * 60 * 60 * 24
+DAYS_13 = 13 * 60 * 60 * 24
+DAYS_14 = 14 * 60 * 60 * 24
+DAYS_15 = 15 * 60 * 60 * 24
+DAYS_16 = 16 * 60 * 60 * 24
+DAYS_17 = 17 * 60 * 60 * 24
+DAYS_18 = 18 * 60 * 60 * 24
+DAYS_19 = 19 * 60 * 60 * 24
+DAYS_20 = 20 * 60 * 60 * 24
+
+
+class CacheNotFound(Exception): pass
+
+
+class Rediser:
+    """Рофлан класыч для удобного использования кэширования в Django."""
+
+    @staticmethod
+    def cache(name, obj=None, timeout=HOUR_12, *args, **kwargs):
+        """
+        Кэширует результат функции или возвращает кэшированный результат, если он доступен.
+
+        @param name: Базовое имя кэш-записи.
+        @param obj: Объект или функция для кэширования.
+        @param timeout: Время в секундах до истечения срока действия.
+        @return: Кэшированный результат или результат вызова функции.
+        """
+        if djc.get(name) is not None: return False, djc.get(name)
+        if obj is None:
+            raise CacheNotFound(f'No cache found for {name}')
+        else:
+            result = obj(*args, **kwargs) if callable(obj) else obj
+            djc.set(name, result, timeout=timeout)
+            return True, result
+
+    @staticmethod
+    async def acache(name, obj=None, timeout=HOUR_12, *args, **kwargs):
+        """
+        Асинхронно кэширует результат функции или возвращает кэшированный результат, если он доступен.
+
+        @param name: Базовое имя кэш-записи.
+        @param obj: Объект или функция для кэширования.
+        @param timeout: Время в секундах до истечения срока действия.
+        @return: Кэшированный результат или результат вызова функции.
+        """
+        if djc.get(name) is not None: return False, djc.get(name)
+        if obj is None:
+            raise CacheNotFound(f'No cache found for {name}')
+        else:
+            result = await obj(*args, **kwargs) if callable(obj) else obj
+            djc.set(name, result, timeout=timeout)
+            return True, result
+
+    @staticmethod
+    def delete(name):
+        djc.delete(name)
+
+    @staticmethod
+    def delete_all():
+        djc.clear()

adjango-0.0.1/adjango.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.1
+Name: adjango
+Version: 0.0.1
+Summary: A library with many features for interacting with Django
+Home-page: https://github.com/Artasov/adjango
+Author: xlartas
+Author-email: ivanhvalevskey@gmail.com
+Project-URL: Source, https://github.com/Artasov/adjango
+Project-URL: Tracker, https://github.com/Artasov/adjango/issues
+Keywords: adjango django utils funcs features async
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.0
+Classifier: Programming Language :: Python :: 3.8
+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: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django<5.3,>=4.0
+Requires-Dist: pyperclip>=1.8.0
+Requires-Dist: aiohttp>=3.8.0
+
+# ADjango 
+
+**ADjango** 
+> Sometimes I use this in different projects, so I decided to put it on pypi
+
+## Installation
+```bash
+pip install adjango
+```
+
+## Settings
+
+* ### Add the application to the project.
+    ```python
+    INSTALLED_APPS = [
+        #...
+        'adjango',
+    ]
+    ```
+* ### In `settings.py` set the params
+    ```python
+    ADJANGO_BACKENDS_APPS = BASE_DIR / 'apps'
+    ADJANGO_FRONTEND_APPS = BASE_DIR.parent / 'frontend' / 'src' / 'apps'
+    ADJANGO_APPS_PREPATH = 'apps.'
+    ADJANGO_EXCEPTION_REPORT_EMAIL = ('ivanhvalevskey@gmail.com',)
+    ADJANGO_EXCEPTION_REPORT_TEMPLATE = 'core/error_report.html'
+    ADJANGO_LOGGER_NAME = 'global'
+    ADJANGO_EMAIL_LOGGER_NAME = 'email'
+    ```
+    ```python
+    MIDDLEWARE = [
+        ...
+        # add request.ip in views
+        'adjango.middleware.IPAddressMiddleware',  
+        ...
+    ]
+    ```

adjango-0.0.1/adjango.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.cfg
+setup.py
+adjango/__init__.py
+adjango/apps.py
+adjango/middleware.py
+adjango.egg-info/PKG-INFO
+adjango.egg-info/SOURCES.txt
+adjango.egg-info/dependency_links.txt
+adjango.egg-info/requires.txt
+adjango.egg-info/top_level.txt
+adjango/management/__init__.py
+adjango/management/commands/__init__.py
+adjango/management/commands/add_paths.py
+adjango/management/commands/copy_proj.py
+adjango/management/commands/dumpdata_to_dir.py
+adjango/management/commands/loaddata_from_dir.py
+adjango/management/commands/remakemigrations.py
+adjango/utils/__init__.py
+adjango/utils/base.py
+adjango/utils/common.py
+adjango/utils/funcs.py
+adjango/utils/mail.py
+adjango/utils/rediser.py

adjango-0.0.1/adjango.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

adjango-0.0.1/adjango.egg-info/requires.txt

@@ -0,0 +1,3 @@
+Django<5.3,>=4.0
+pyperclip>=1.8.0
+aiohttp>=3.8.0

adjango-0.0.1/adjango.egg-info/top_level.txt

@@ -0,0 +1 @@
+adjango

adjango-0.0.1/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+license_files = LICENSE
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

adjango-0.0.1/setup.py

@@ -0,0 +1,41 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="adjango",
+    version="0.0.1",
+    author="xlartas",
+    author_email="ivanhvalevskey@gmail.com",
+    description="A library with many features for interacting with Django",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Artasov/adjango",
+    packages=setuptools.find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "Django>=4.0,<5.3",
+        "pyperclip>=1.8.0",
+        "aiohttp>=3.8.0",
+    ],
+    classifiers=[
+        "Framework :: Django",
+        "Framework :: Django :: 4.0",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Operating System :: OS Independent",
+        "License :: OSI Approved :: MIT License",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Application Frameworks",
+    ],
+    python_requires='>=3.8',
+    keywords='adjango django utils funcs features async',
+    project_urls={
+        'Source': 'https://github.com/Artasov/adjango',
+        'Tracker': 'https://github.com/Artasov/adjango/issues',
+    },
+)