holado 0.4.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

holado_db/tools/db/clients/base/db_client.py

@@ -41,6 +41,8 @@ class DBClient(object):
         
         self.__connection = None
         self.__query_builder = None
+        self.__audit_manager = None
+        self.__column_names_by_table = {}
     
     @property
     def name(self):
@@ -68,6 +70,19 @@ class DBClient(object):
             raise TechnicalException(f"DB client '{self.__name}' doesn't manage cursor")
         return self.__cursor
     
+    @property
+    def audit_manager(self):
+        if self.__audit_manager is None:
+            self.__audit_manager = self._new_audit_manager()
+        return self.__audit_manager
+    
+    def _new_audit_manager(self):
+        """Create a new audit manager.
+        By default, use a audit manager with a single table of audit for whole DB and with triggers on audited tables.
+        Override this method in order to define which audit manager to use.
+        """
+        raise NotImplementedError()
+    
     def connect(self):
         try:
             self.__connection = self._connect(**self.__connect_kwargs)
@@ -83,22 +98,45 @@ class DBClient(object):
         if not self.is_connected:
             raise FunctionalException(f"DB Client '{self.name}' is not connected")
     
-    def is_query_type(self, sql_or_query, query_type):
-        if isinstance(sql_or_query, pypika.queries.QueryBuilder):
-            sql = self.query_builder.to_sql(sql_or_query)
-        else:
-            sql = sql_or_query
-        if not isinstance(sql, str):
-            raise TechnicalException(f"Unexpected type '{Typing.get_object_class_fullname(sql)}' for parameter sql_or_query")
-        
-        if isinstance(query_type, str):
-            query_type = QueryType[query_type.upper()]
-        if not isinstance(query_type, QueryType):
-            raise TechnicalException(f"Unmanage query_type of type '{Typing.get_object_class_fullname(query_type)}'")
-        
-        p = sql_metadata.Parser(sql)
-        return p.query_type == query_type
+    # Manage queries
+    
+    def insert(self, table_name, data: dict, do_commit=None):
+        """
+        Insert given data.
+        Parameter 'data' has to be a dictionary with keys equal to table column names.
+        """
+        query, values = self.query_builder.insert(table_name, data)
+        return self.execute_query(query, *values, do_commit=do_commit)
+    
+    def update(self, table_name, data: dict, where_data: dict=None, where_compare_data: list=None, do_commit=None):
+        """
+        Update given data.
+        Parameters 'data' and 'where_data' have to be dictionaries with keys equal to table column names.
+        """
+        query, values = self.query_builder.update(table_name, data, where_data=where_data, where_compare_data=where_compare_data)
+        return self.execute_query(query, *values, do_commit=do_commit)
+    
+    def select(self, table_name, where_data: dict=None, where_compare_data: list=None, sql_return="*", **kwargs):
+        """
+        Select by filtering on given where data.
+        @param where_data: dictionary of (field_name, value) for simple where clauses.
+        @param where_compare_data: list of tuples (field_name, operator, value) for where clauses comparing fields with values.
+        """
+        query, values = self.query_builder.select(table_name, where_data=where_data, where_compare_data=where_compare_data, sql_return=sql_return)
+        return self.execute_query(query, *values, do_commit=False, **kwargs)
+    
+    def delete(self, table_name, where_data: dict=None, where_compare_data: list=None, do_commit=None):
+        """
+        Delete by filtering on given where data.
+        Parameter 'where_data' has to be a dictionary with keys equal to table column names.
+        """
+        query, values = self.query_builder.delete(table_name, where_data=where_data, where_compare_data=where_compare_data)
+        return self.execute_query(query, *values, do_commit=do_commit)
     
+    def count(self, table_name, where_data: dict=None, where_compare_data: list=None):
+        result = self.select(table_name, where_data=where_data, where_compare_data=where_compare_data, sql_return="count(*)")
+        return result[0][0].content
+        
     def execute_query(self, query, *args, **kwargs):
         sql = self.query_builder.to_sql(query)
         
@@ -126,7 +164,7 @@ class DBClient(object):
         
         # Execute
         if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"[{self.name}] Executing SQL [{sql}] with parameters [{args if args else ''}{kwargs if kwargs else ''}]...")
+            logger.debug(f"[{self.name}] Executing SQL [{Tools.truncate_text(sql, 1000)}] (args: {Tools.truncate_text(args, 1000)} ; kwargs: {Tools.truncate_text(kwargs, 1000)})...")
         try:
             if args:
                 self.cursor.execute(sql, args)
@@ -172,7 +210,7 @@ class DBClient(object):
         else:
             res = None
         
-        self.__log_sql_result(res, message=f"Executed SQL [{sql}] with parameters [{args if args else ''}{kwargs if kwargs else ''}]")
+        self.__log_sql_result(res, message=f"Executed SQL [{Tools.truncate_text(sql, 1000)}] (args: {Tools.truncate_text(args, 1000)} ; kwargs: {Tools.truncate_text(kwargs, 1000)})")
         
         # Manage commit
         if do_commit:
@@ -184,6 +222,52 @@ class DBClient(object):
             
         return res
     
+    def is_query_type(self, sql_or_query, query_type):
+        if isinstance(sql_or_query, pypika.queries.QueryBuilder):
+            sql = self.query_builder.to_sql(sql_or_query)
+        else:
+            sql = sql_or_query
+        if not isinstance(sql, str):
+            raise TechnicalException(f"Unexpected type '{Typing.get_object_class_fullname(sql)}' for parameter sql_or_query")
+        sql = sql.lower()
+        
+        # Parsing query with sql_metadata can be costly, thus begin by fast and simple methods
+        query_type_str = query_type.lower() if isinstance(query_type, str) else query_type.name.lower()
+        for qt in ['select', 'insert', 'update', 'delete']:
+            if sql.startswith(qt):
+                return qt == query_type_str
+        
+        # Parse more complex queries
+        if isinstance(query_type, str):
+            query_type = QueryType[query_type.upper()]
+        if not isinstance(query_type, QueryType):
+            raise TechnicalException(f"Unmanage query_type of type '{Typing.get_object_class_fullname(query_type)}'")
+        
+        try:
+            p = sql_metadata.Parser(sql)
+            res = p.query_type == query_type
+        except ValueError as exc:
+            if "Not supported query type" in str(exc):
+                res = False
+            else:
+                raise TechnicalException(f"Failed to define query type") from exc
+        except Exception as exc:
+            raise TechnicalException(f"Failed to define query type") from exc
+        
+        return res
+    
+    def set_or_update_json_key_value(self, table_name, field_name, json_key, json_value, where_data: dict=None, where_compare_data: list=None):
+        """
+        Set or update a json field with key=value.
+        """
+        raise NotImplementedError()
+        
+    def _get_sql_placeholder(self):
+        """
+        Return the character/string to use as placeholder in SQL requests.
+        """
+        raise NotImplementedError()
+
     def _get_base_exception_type(self):
         raise NotImplementedError()
     
@@ -203,57 +287,59 @@ class DBClient(object):
         else:
             return str(sql_result)
     
+    
+    # Manage transactions
+    
     def commit(self):
         self.connection.commit()
         
     def rollback(self):
         self.connection.rollback()
-        
+    
+    
+    # Manage tables
+    
     def exist_table(self, table_name):
         raise NotImplementedError()
     
-    def insert(self, table_name, data: dict, do_commit=None):
-        """
-        Insert given data.
-        Parameter 'data' has to be a dictionary with keys equal to table column names.
-        """
-        query, values = self.query_builder.insert(table_name, data)
-        return self.execute_query(query, *values, do_commit=do_commit)
-    
-    def update(self, table_name, data: dict, where_data: dict=None, where_compare_data: list=None, do_commit=None):
-        """
-        Update given data.
-        Parameters 'data' and 'where_data' have to be dictionaries with keys equal to table column names.
-        """
-        query, values = self.query_builder.update(table_name, data, where_data=where_data, where_compare_data=where_compare_data)
-        return self.execute_query(query, *values, do_commit=do_commit)
+    def create_table(self, table_name, create_sql, raise_if_exist=False, do_commit=True, do_audit=False):
+        if not self.exist_table(table_name):
+            self.execute(create_sql, do_commit=do_commit)
+            if not self.exist_table(table_name):
+                raise TechnicalException(f"Failed to create table '{table_name}' with SQL request [{create_sql}]")
+            
+            # Audit table
+            if do_audit:
+                self.audit_manager.audit_table(table_name)
+        elif raise_if_exist:
+            raise FunctionalException(f"Table '{table_name}' already exists")
     
-    def select(self, table_name, where_data: dict=None, where_compare_data: list=None, sql_return="*", **kwargs):
-        """
-        Select by filtering on given where data.
-        @param where_data: dictionary of (field_name, value) for simple where clauses.
-        @param where_compare_data: list of tuples (field_name, operator, value) for where clauses comparing fields with values.
-        """
-        query, values = self.query_builder.select(table_name, where_data=where_data, where_compare_data=where_compare_data, sql_return=sql_return)
-        return self.execute_query(query, *values, do_commit=False, **kwargs)
+    def drop_table(self, table_name, raise_if_not_exist=False, do_commit=True):
+        if self.exist_table(table_name):
+            sql = f"drop table {table_name};"
+            self.execute(sql, do_commit=do_commit)
+            if self.exist_table(table_name):
+                raise TechnicalException(f"Failed to drop table '{table_name}' with SQL request [{sql}]")
+        elif raise_if_not_exist:
+            raise FunctionalException(f"Table '{table_name}' doesn't exist")
     
-    def delete(self, table_name, where_data: dict=None, where_compare_data: list=None, do_commit=None):
-        """
-        Delete by filtering on given where data.
-        Parameter 'where_data' has to be a dictionary with keys equal to table column names.
-        """
-        query, values = self.query_builder.delete(table_name, where_data=where_data, where_compare_data=where_compare_data)
-        return self.execute_query(query, *values, do_commit=do_commit)
+    def get_table_column_names(self, table_name):
+        if table_name not in self.__column_names_by_table:
+            self.__column_names_by_table[table_name] = self._get_table_column_names(table_name)
+        return self.__column_names_by_table[table_name]
     
-    def set_or_update_json_key_value(self, table_name, field_name, json_key, json_value, where_data: dict=None, where_compare_data: list=None):
-        """
-        Set or update a json field with key=value.
-        """
-        raise NotImplementedError()
+    def _get_table_column_names(self, table_name):
+        sql = f"select * from {table_name} limit 1"
+        try:
+            self.cursor.execute(sql)
+        except self._get_base_exception_type() as exc:
+            self.rollback()
+            raise TechnicalException(f"[{self.name}] Error while executing SQL [{sql}]") from exc
+        
+        if self.cursor.description:
+            res = [field[0] for field in self.cursor.description]
+        else:
+            raise TechnicalException(f"Failed to get column names of table {table_name}")
+        
+        return res
         
-    def _get_sql_placeholder(self):
-        """
-        Return the character/string to use as placeholder in SQL requests.
-        """
-        raise NotImplementedError()
-

holado_db/tools/db/clients/postgresql/postgresql_audit.py

@@ -0,0 +1,75 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2023 by Eric Klumpp
+# 
+# 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.
+#################################################
+
+import logging
+from holado.common.handlers.undefined import default_value
+from holado_db.tools.db.clients.base.db_audit import TriggerAuditManager
+
+logger = logging.getLogger(__name__)
+
+
+class PostgreSQLTriggerAuditManager(TriggerAuditManager):
+    """Manage audit of tables by triggers.
+    WARNING: This case is not tested yet
+    """
+    def __init__(self, name, db_client):
+        super().__init__(name, db_client)
+    
+    def _get_audit_table_sql_create(self, audit_table_name=default_value):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        return f"""CREATE TABLE {audit_table_name} (
+                id SERIAL PRIMARY KEY,
+                table_name TEXT,
+                record_id INTEGER,
+                operation_type TEXT,
+                changed_at TIMESTAMP DEFAULT now(),
+                changed_by TEXT,
+                previous_values JSONB,
+                new_values JSONB
+            )"""
+    
+    def _get_drop_trigger_sql_of_audit_table_operation(self, table_name, operation_type, audit_table_name):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        trigger_name = self.get_trigger_name(table_name, operation_type)
+        return f"DROP TRIGGER IF EXISTS {trigger_name} on {table_name}"
+    
+    def _get_create_trigger_sql_to_audit_table_operation(self, table_name, operation_type, audit_table_name):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        trigger_name = self.get_trigger_name(table_name, operation_type)
+        trigger_insert_sql = self.__get_trigger_insert_sql(table_name, operation_type, audit_table_name)
+        return f"""CREATE TRIGGER {trigger_name} AFTER {operation_type.upper()} ON {table_name}
+                BEGIN
+                    {trigger_insert_sql}
+                END;
+                """
+    
+    def __get_trigger_insert_sql(self, table_name, operation_type, audit_table_name):
+        rowid_txt = "NEW.id" if operation_type in ['insert', 'update'] else "OLD.id"
+        op_type = operation_type[0]
+        prev_vals_txt = "to_jsonb(OLD)" if operation_type in ['update', 'delete'] else "NULL"
+        new_vals_txt = "to_jsonb(NEW)" if operation_type in ['insert', 'update'] else "NULL"
+        
+        audit_info = [f"'{table_name}'",
+                      rowid_txt,
+                      f"'{op_type}'",
+                      "current_user",
+                      prev_vals_txt,
+                      new_vals_txt,
+                     ]
+        audit_info = ','.join(audit_info)
+        
+        return f"""INSERT INTO {audit_table_name} (table_name, record_id, operation_type, changed_by, previous_values, new_values) 
+                   VALUES ({audit_info});"""
+
+
+

holado_db/tools/db/clients/postgresql/postgresql_client.py

@@ -17,6 +17,7 @@ from holado_core.common.tables.table_with_header import TableWithHeader
 from holado_core.common.tools.tools import Tools
 import json
 from pypika.terms import Function, LiteralValue
+from holado_db.tools.db.clients.postgresql.postgresql_audit import PostgreSQLTriggerAuditManager
 
 logger = logging.getLogger(__name__)
 
@@ -43,6 +44,9 @@ class PostgreSQLClient(DBClient):
     def __init__(self, name, connect_kwargs):
         super().__init__(name if name else 'PostgreSQL', connect_kwargs)
         
+    def _new_audit_manager(self):
+        return PostgreSQLTriggerAuditManager("Audit with triggers", self)
+        
     def _get_base_exception_type(self):
         return psycopg.Error
     

holado_db/tools/db/clients/sqlite/sqlite_audit.py

@@ -0,0 +1,70 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2023 by Eric Klumpp
+# 
+# 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.
+#################################################
+
+import logging
+from holado.common.handlers.undefined import default_value
+from holado_db.tools.db.clients.base.db_audit import TriggerAuditManager
+
+logger = logging.getLogger(__name__)
+
+
+class SQLite3TriggerAuditManager(TriggerAuditManager):
+    def __init__(self, name, db_client):
+        super().__init__(name, db_client)
+    
+    def _get_audit_table_sql_create(self, audit_table_name=default_value):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        return f"""CREATE TABLE {audit_table_name} (
+                id INTEGER PRIMARY KEY,
+                table_name TEXT,
+                record_id INTEGER,
+                operation_type TEXT,
+                changed_at TEXT,
+                previous_values TEXT,
+                new_values TEXT
+            )"""
+    
+    def _get_drop_trigger_sql_of_audit_table_operation(self, table_name, operation_type, audit_table_name):
+        trigger_name = self.get_trigger_name(table_name, operation_type)
+        return f"DROP TRIGGER IF EXISTS {trigger_name}"
+    
+    def _get_create_trigger_sql_to_audit_table_operation(self, table_name, operation_type, audit_table_name):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        trigger_name = self.get_trigger_name(table_name, operation_type)
+        trigger_insert_sql = self.__get_trigger_insert_sql(table_name, operation_type, audit_table_name)
+        return f"""CREATE TRIGGER {trigger_name} AFTER {operation_type.upper()} ON {table_name}
+                BEGIN
+                    {trigger_insert_sql}
+                END;
+                """
+    
+    def __get_trigger_insert_sql(self, table_name, operation_type, audit_table_name):
+        values = [f"'{table_name}'",
+                  "NEW.rowid" if operation_type in ['insert', 'update'] else "OLD.rowid",
+                  f"'{operation_type[0]}'",
+                  "DATETIME('now')",
+                  self.__get_row_version_json_object_sql(table_name, 'OLD') if operation_type in ['update', 'delete'] else "NULL",
+                  self.__get_row_version_json_object_sql(table_name, 'NEW') if operation_type in ['insert', 'update'] else "NULL",
+                 ]
+        
+        return f"""INSERT INTO {audit_table_name} (table_name, record_id, operation_type, changed_at, previous_values, new_values) 
+                   VALUES ({','.join(values)});"""
+    
+    def __get_row_version_json_object_sql(self, table_name, row_version):
+        col_names = self._db_client.get_table_column_names(table_name)
+        json_object_args = []
+        for cn in col_names:
+            json_object_args.append(f"'{cn}'")
+            json_object_args.append(f"{row_version}.{cn}")
+        return f"json_object({','.join(json_object_args)})"
+

holado_db/tools/db/clients/sqlite/sqlite_client.py

@@ -15,6 +15,7 @@ import logging
 from holado_db.tools.db.clients.base.db_client import DBClient
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_core.common.tools.tools import Tools
+from holado_db.tools.db.clients.sqlite.sqlite_audit import SQLite3TriggerAuditManager
 
 logger = logging.getLogger(__name__)
 
@@ -35,6 +36,9 @@ class SQLite3Client(DBClient):
     def __init__(self, name, connect_kwargs):
         super().__init__(name if name else 'SQLite3', connect_kwargs)
         
+    def _new_audit_manager(self):
+        return SQLite3TriggerAuditManager("Audit with triggers", self)
+    
     def _get_base_exception_type(self):
         return sqlite3.Error
         

holado_django/__init__.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# 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.
+#################################################
+
+
+def dependencies():
+    """
+    Return None or the list of names of modules it depend on
+    """
+    return None
+
+def register():
+    """
+    Register the services of this module
+    """
+    # from holado.common.context.session_context import SessionContext
+    
+    # from holado_xxx.xxx import XXXManager
+    # SessionContext.instance().services.register_service_type("xxx_manager", XXXManager)
+    pass
+

holado_django/server/HOWTO.txt

@@ -0,0 +1,27 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# 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.
+#################################################
+
+
+HOWTO create a REST server easier with HolAdo:
+
+    1. Create a working directory (WORK_DIR) where all server files will be stored
+    2. Copy in WORK_DIR the appropriate django project. For this case, it is holado_django/server/django_projects/rest_api
+    3. Update application with wanted REST APIs. For this case, update/add files in rest_api/rest_api/application: views.py, models.py,...
+    4. Make migrations if needed (cf django documentation)
+    5. Run server manually with a command like "python manage.py runserver", or use module holado_django/server/django_server.py
+
+    Example: A simple example is in holado_examples/projects/server_rest/server_rest_example
+
+    Note: These steps are simple and doesn't give help to developpers knowing Django and Django REST framework.
+          They should be a first step towards future more powerful tools.
+

holado_django/server/django_projects/rest_api/manage.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'rest_api.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == '__main__':
+    main()

holado_django/server/django_projects/rest_api/rest_api/application/admin.py

@@ -0,0 +1,3 @@
+# from django.contrib import admin
+
+# Register your models here.

holado_django/server/django_projects/rest_api/rest_api/application/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+django_application_inst = None
+
+
+class ApplicationConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'application'

holado_django/server/django_projects/rest_api/rest_api/application/models.py

@@ -0,0 +1,3 @@
+# from django.db import models
+
+# Create your models here.

holado_django/server/django_projects/rest_api/rest_api/application/tests.py

@@ -0,0 +1,3 @@
+# from django.test import TestCase
+
+# Create your tests here.

holado_django/server/django_projects/rest_api/rest_api/application/views.py

@@ -0,0 +1,6 @@
+# from django.shortcuts import render
+# from rest_framework import viewsets
+# from rest_framework import permissions
+
+
+

holado_django/server/django_projects/rest_api/rest_api/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for server_rest_example project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.2/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'rest_api.settings')
+
+application = get_asgi_application()