Mise à jour de Monitor.py et autres scripts

myenv/lib/python3.11/site-packages/mysql/connector/django/base.py

@@ -0,0 +1,653 @@
+# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0, as
+# published by the Free Software Foundation.
+#
+# This program is designed to work with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an
+# additional permission to link the program and your derivative works
+# with the separately licensed software that they have either included with
+# the program or referenced in the documentation.
+#
+# Without limiting anything contained in the foregoing, this file,
+# which is part of MySQL Connector/Python, is also subject to the
+# Universal FOSS Exception, version 1.0, a copy of which can be found at
+# http://oss.oracle.com/licenses/universal-foss-exception.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+
+# mypy: disable-error-code="override"
+
+"""Django database Backend using MySQL Connector/Python.
+
+This Django database backend is heavily based on the MySQL backend from Django.
+
+Changes include:
+* Support for microseconds (MySQL 5.6.3 and later)
+* Using INFORMATION_SCHEMA where possible
+* Using new defaults for, for example SQL_AUTO_IS_NULL
+
+Requires and comes with MySQL Connector/Python v8.0.22 and later:
+    http://dev.mysql.com/downloads/connector/python/
+"""
+
+import warnings
+
+from datetime import datetime, time
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generator,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Union,
+)
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.db import IntegrityError
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.utils import dateparse, timezone
+from django.utils.functional import cached_property
+
+from mysql.connector.types import MySQLConvertibleType
+
+try:
+    import mysql.connector
+
+    from mysql.connector.conversion import MySQLConverter
+    from mysql.connector.custom_types import HexLiteral
+    from mysql.connector.pooling import PooledMySQLConnection
+    from mysql.connector.types import ParamsSequenceOrDictType, RowType, StrOrBytes
+except ImportError as err:
+    raise ImproperlyConfigured(f"Error loading mysql.connector module: {err}") from err
+
+try:
+    from _mysql_connector import datetime_to_mysql
+except ImportError:
+    HAVE_CEXT = False
+else:
+    HAVE_CEXT = True
+
+from .client import DatabaseClient
+from .creation import DatabaseCreation
+from .features import DatabaseFeatures
+from .introspection import DatabaseIntrospection
+from .operations import DatabaseOperations
+from .schema import DatabaseSchemaEditor
+from .validation import DatabaseValidation
+
+Error = mysql.connector.Error
+DatabaseError = mysql.connector.DatabaseError
+NotSupportedError = mysql.connector.NotSupportedError
+OperationalError = mysql.connector.OperationalError
+ProgrammingError = mysql.connector.ProgrammingError
+
+if TYPE_CHECKING:
+    from mysql.connector.abstracts import MySQLConnectionAbstract, MySQLCursorAbstract
+
+
+def adapt_datetime_with_timezone_support(value: datetime) -> StrOrBytes:
+    """Equivalent to DateTimeField.get_db_prep_value. Used only by raw SQL."""
+    if settings.USE_TZ:
+        if timezone.is_naive(value):
+            warnings.warn(
+                f"MySQL received a naive datetime ({value})"
+                " while time zone support is active.",
+                RuntimeWarning,
+            )
+            default_timezone = timezone.get_default_timezone()
+            value = timezone.make_aware(value, default_timezone)
+        # pylint: disable=no-member
+        value = value.astimezone(timezone.utc).replace(  # type: ignore[attr-defined]
+            tzinfo=None
+        )
+    if HAVE_CEXT:
+        mysql_datetime: bytes = datetime_to_mysql(value)
+        return mysql_datetime
+    return value.strftime("%Y-%m-%d %H:%M:%S.%f")
+
+
+class CursorWrapper:
+    """Wrapper around MySQL Connector/Python's cursor class.
+
+    The cursor class is defined by the options passed to MySQL
+    Connector/Python. If buffered option is True in those options,
+    MySQLCursorBuffered will be used.
+    """
+
+    codes_for_integrityerror = (
+        1048,  # Column cannot be null
+        1690,  # BIGINT UNSIGNED value is out of range
+        3819,  # CHECK constraint is violated
+        4025,  # CHECK constraint failed
+    )
+
+    def __init__(self, cursor: "MySQLCursorAbstract") -> None:
+        self.cursor: "MySQLCursorAbstract" = cursor
+
+    @staticmethod
+    def _adapt_execute_args_dict(
+        args: Dict[str, MySQLConvertibleType]
+    ) -> Dict[str, MySQLConvertibleType]:
+        if not args:
+            return args
+        new_args = dict(args)
+        for key, value in args.items():
+            if isinstance(value, datetime):
+                new_args[key] = adapt_datetime_with_timezone_support(value)
+
+        return new_args
+
+    @staticmethod
+    def _adapt_execute_args(
+        args: Optional[Sequence[MySQLConvertibleType]],
+    ) -> Optional[Sequence[MySQLConvertibleType]]:
+        if not args:
+            return args
+        new_args = list(args)
+        for i, arg in enumerate(args):
+            if isinstance(arg, datetime):
+                new_args[i] = adapt_datetime_with_timezone_support(arg)
+
+        return tuple(new_args)
+
+    def execute(
+        self,
+        query: str,
+        args: Optional[
+            Union[Sequence[MySQLConvertibleType], Dict[str, MySQLConvertibleType]]
+        ] = None,
+    ) -> Optional[Generator["MySQLCursorAbstract", None, None]]:
+        """Executes the given operation
+
+        This wrapper method around the execute()-method of the cursor is
+        mainly needed to re-raise using different exceptions.
+        """
+        new_args: Optional[ParamsSequenceOrDictType] = None
+        if isinstance(args, dict):
+            new_args = self._adapt_execute_args_dict(args)
+        else:
+            new_args = self._adapt_execute_args(args)
+        try:
+            return self.cursor.execute(query, new_args)
+        except mysql.connector.OperationalError as exc:
+            if exc.args[0] in self.codes_for_integrityerror:
+                raise IntegrityError(*tuple(exc.args)) from None
+            raise
+
+    def executemany(
+        self,
+        query: str,
+        args: Sequence[
+            Union[Sequence[MySQLConvertibleType], Dict[str, MySQLConvertibleType]]
+        ],
+    ) -> Optional[Generator["MySQLCursorAbstract", None, None]]:
+        """Executes the given operation
+
+        This wrapper method around the executemany()-method of the cursor is
+        mainly needed to re-raise using different exceptions.
+        """
+        try:
+            return self.cursor.executemany(query, args)
+        except mysql.connector.OperationalError as exc:
+            if exc.args[0] in self.codes_for_integrityerror:
+                raise IntegrityError(*tuple(exc.args)) from None
+            raise
+
+    def __getattr__(self, attr: Any) -> Any:
+        """Return an attribute of wrapped cursor"""
+        return getattr(self.cursor, attr)
+
+    def __iter__(self) -> Iterator[RowType]:
+        """Return an iterator over wrapped cursor"""
+        return iter(self.cursor)
+
+
+class DatabaseWrapper(BaseDatabaseWrapper):  # pylint: disable=abstract-method
+    """Represent a database connection."""
+
+    vendor = "mysql"
+    # This dictionary maps Field objects to their associated MySQL column
+    # types, as strings. Column-type strings can contain format strings; they'll
+    # be interpolated against the values of Field.__dict__ before being output.
+    # If a column type is set to None, it won't be included in the output.
+    data_types = {
+        "AutoField": "integer AUTO_INCREMENT",
+        "BigAutoField": "bigint AUTO_INCREMENT",
+        "BinaryField": "longblob",
+        "BooleanField": "bool",
+        "CharField": "varchar(%(max_length)s)",
+        "DateField": "date",
+        "DateTimeField": "datetime(6)",
+        "DecimalField": "numeric(%(max_digits)s, %(decimal_places)s)",
+        "DurationField": "bigint",
+        "FileField": "varchar(%(max_length)s)",
+        "FilePathField": "varchar(%(max_length)s)",
+        "FloatField": "double precision",
+        "IntegerField": "integer",
+        "BigIntegerField": "bigint",
+        "IPAddressField": "char(15)",
+        "GenericIPAddressField": "char(39)",
+        "JSONField": "json",
+        "NullBooleanField": "bool",
+        "OneToOneField": "integer",
+        "PositiveBigIntegerField": "bigint UNSIGNED",
+        "PositiveIntegerField": "integer UNSIGNED",
+        "PositiveSmallIntegerField": "smallint UNSIGNED",
+        "SlugField": "varchar(%(max_length)s)",
+        "SmallAutoField": "smallint AUTO_INCREMENT",
+        "SmallIntegerField": "smallint",
+        "TextField": "longtext",
+        "TimeField": "time(6)",
+        "UUIDField": "char(32)",
+    }
+
+    # For these data types:
+    # - MySQL < 8.0.13 doesn't accept default values and
+    #   implicitly treat them as nullable
+    # - all versions of MySQL doesn't support full width database
+    #   indexes
+    _limited_data_types = (
+        "tinyblob",
+        "blob",
+        "mediumblob",
+        "longblob",
+        "tinytext",
+        "text",
+        "mediumtext",
+        "longtext",
+        "json",
+    )
+
+    operators = {
+        "exact": "= %s",
+        "iexact": "LIKE %s",
+        "contains": "LIKE BINARY %s",
+        "icontains": "LIKE %s",
+        "regex": "REGEXP BINARY %s",
+        "iregex": "REGEXP %s",
+        "gt": "> %s",
+        "gte": ">= %s",
+        "lt": "< %s",
+        "lte": "<= %s",
+        "startswith": "LIKE BINARY %s",
+        "endswith": "LIKE BINARY %s",
+        "istartswith": "LIKE %s",
+        "iendswith": "LIKE %s",
+    }
+
+    # The patterns below are used to generate SQL pattern lookup clauses when
+    # the right-hand side of the lookup isn't a raw string (it might be an expression
+    # or the result of a bilateral transformation).
+    # In those cases, special characters for LIKE operators (e.g. \, *, _) should be
+    # escaped on database side.
+    #
+    # Note: we use str.format() here for readability as '%' is used as a wildcard for
+    # the LIKE operator.
+    pattern_esc = r"REPLACE(REPLACE(REPLACE({}, '\\', '\\\\'), '%%', '\%%'), '_', '\_')"
+    pattern_ops = {
+        "contains": "LIKE BINARY CONCAT('%%', {}, '%%')",
+        "icontains": "LIKE CONCAT('%%', {}, '%%')",
+        "startswith": "LIKE BINARY CONCAT({}, '%%')",
+        "istartswith": "LIKE CONCAT({}, '%%')",
+        "endswith": "LIKE BINARY CONCAT('%%', {})",
+        "iendswith": "LIKE CONCAT('%%', {})",
+    }
+
+    isolation_level: Optional[str] = None
+    isolation_levels = {
+        "read uncommitted",
+        "read committed",
+        "repeatable read",
+        "serializable",
+    }
+
+    Database = mysql.connector
+    SchemaEditorClass = DatabaseSchemaEditor
+    # Classes instantiated in __init__().
+    client_class = DatabaseClient
+    creation_class = DatabaseCreation
+    features_class = DatabaseFeatures
+    introspection_class = DatabaseIntrospection
+    ops_class = DatabaseOperations
+    validation_class = DatabaseValidation
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        options = self.settings_dict.get("OPTIONS")
+        if options:
+            self._use_pure = options.get("use_pure", not HAVE_CEXT)
+            converter_class = options.get(
+                "converter_class",
+                DjangoMySQLConverter,
+            )
+            if not issubclass(converter_class, DjangoMySQLConverter):
+                raise ProgrammingError(
+                    "Converter class should be a subclass of "
+                    "mysql.connector.django.base.DjangoMySQLConverter"
+                )
+            self.converter = converter_class()
+        else:
+            self.converter = DjangoMySQLConverter()
+            self._use_pure = not HAVE_CEXT
+
+    def __getattr__(self, attr: str) -> bool:
+        if attr.startswith("mysql_is"):
+            return False
+        raise AttributeError
+
+    def get_connection_params(self) -> Dict[str, Any]:
+        kwargs = {
+            "charset": "utf8",
+            "use_unicode": True,
+            "buffered": False,
+            "consume_results": True,
+        }
+
+        settings_dict = self.settings_dict
+
+        if settings_dict["USER"]:
+            kwargs["user"] = settings_dict["USER"]
+        if settings_dict["NAME"]:
+            kwargs["database"] = settings_dict["NAME"]
+        if settings_dict["PASSWORD"]:
+            kwargs["passwd"] = settings_dict["PASSWORD"]
+        if settings_dict["HOST"].startswith("/"):
+            kwargs["unix_socket"] = settings_dict["HOST"]
+        elif settings_dict["HOST"]:
+            kwargs["host"] = settings_dict["HOST"]
+        if settings_dict["PORT"]:
+            kwargs["port"] = int(settings_dict["PORT"])
+        if settings_dict.get("OPTIONS", {}).get("init_command"):
+            kwargs["init_command"] = settings_dict["OPTIONS"]["init_command"]
+
+        # Raise exceptions for database warnings if DEBUG is on
+        kwargs["raise_on_warnings"] = settings.DEBUG
+
+        kwargs["client_flags"] = [
+            # Need potentially affected rows on UPDATE
+            mysql.connector.constants.ClientFlag.FOUND_ROWS,
+        ]
+
+        try:
+            options = settings_dict["OPTIONS"].copy()
+            isolation_level = options.pop("isolation_level", None)
+            if isolation_level:
+                isolation_level = isolation_level.lower()
+                if isolation_level not in self.isolation_levels:
+                    valid_levels = ", ".join(
+                        f"'{level}'" for level in sorted(self.isolation_levels)
+                    )
+                    raise ImproperlyConfigured(
+                        f"Invalid transaction isolation level '{isolation_level}' "
+                        f"specified.\nUse one of {valid_levels}, or None."
+                    )
+            self.isolation_level = isolation_level
+            kwargs.update(options)
+        except KeyError:
+            # OPTIONS missing is OK
+            pass
+        return kwargs
+
+    def get_new_connection(
+        self, conn_params: Dict[str, Any]
+    ) -> Union[PooledMySQLConnection, "MySQLConnectionAbstract"]:
+        if "converter_class" not in conn_params:
+            conn_params["converter_class"] = DjangoMySQLConverter
+        cnx = mysql.connector.connect(**conn_params)
+
+        return cnx
+
+    def init_connection_state(self) -> None:
+        assignments = []
+        if self.features.is_sql_auto_is_null_enabled:  # type: ignore[attr-defined]
+            # SQL_AUTO_IS_NULL controls whether an AUTO_INCREMENT column on
+            # a recently inserted row will return when the field is tested
+            # for NULL. Disabling this brings this aspect of MySQL in line
+            # with SQL standards.
+            assignments.append("SET SQL_AUTO_IS_NULL = 0")
+
+        if self.isolation_level:
+            assignments.append(
+                "SET SESSION TRANSACTION ISOLATION LEVEL "
+                f"{self.isolation_level.upper()}"
+            )
+
+        if assignments:
+            with self.cursor() as cursor:
+                cursor.execute("; ".join(assignments))
+
+        if "AUTOCOMMIT" in self.settings_dict:
+            try:
+                self.set_autocommit(self.settings_dict["AUTOCOMMIT"])
+            except AttributeError:
+                self._set_autocommit(self.settings_dict["AUTOCOMMIT"])
+
+    def create_cursor(self, name: Any = None) -> CursorWrapper:
+        cursor = self.connection.cursor()
+        return CursorWrapper(cursor)
+
+    def _rollback(self) -> None:
+        try:
+            BaseDatabaseWrapper._rollback(self)  # type: ignore[attr-defined]
+        except NotSupportedError:
+            pass
+
+    def _set_autocommit(self, autocommit: bool) -> None:
+        with self.wrap_database_errors:
+            self.connection.autocommit = autocommit
+
+    def disable_constraint_checking(self) -> bool:
+        """
+        Disable foreign key checks, primarily for use in adding rows with
+        forward references. Always return True to indicate constraint checks
+        need to be re-enabled.
+        """
+        with self.cursor() as cursor:
+            cursor.execute("SET foreign_key_checks=0")
+        return True
+
+    def enable_constraint_checking(self) -> None:
+        """
+        Re-enable foreign key checks after they have been disabled.
+        """
+        # Override needs_rollback in case constraint_checks_disabled is
+        # nested inside transaction.atomic.
+        self.needs_rollback, needs_rollback = False, self.needs_rollback
+        try:
+            with self.cursor() as cursor:
+                cursor.execute("SET foreign_key_checks=1")
+        finally:
+            self.needs_rollback = needs_rollback
+
+    def check_constraints(self, table_names: Optional[List[str]] = None) -> None:
+        """
+        Check each table name in `table_names` for rows with invalid foreign
+        key references. This method is intended to be used in conjunction with
+        `disable_constraint_checking()` and `enable_constraint_checking()`, to
+        determine if rows with invalid references were entered while constraint
+        checks were off.
+        """
+        with self.cursor() as cursor:
+            if table_names is None:
+                table_names = self.introspection.table_names(cursor)
+            for table_name in table_names:
+                primary_key_column_name = self.introspection.get_primary_key_column(
+                    cursor, table_name
+                )
+                if not primary_key_column_name:
+                    continue
+                key_columns = self.introspection.get_key_columns(  # type: ignore[attr-defined]
+                    cursor, table_name
+                )
+                for (
+                    column_name,
+                    referenced_table_name,
+                    referenced_column_name,
+                ) in key_columns:
+                    cursor.execute(
+                        f"""
+                        SELECT REFERRING.`{primary_key_column_name}`,
+                        REFERRING.`{column_name}`
+                        FROM `{table_name}` as REFERRING
+                        LEFT JOIN `{referenced_table_name}` as REFERRED
+                        ON (
+                            REFERRING.`{column_name}` =
+                            REFERRED.`{referenced_column_name}`
+                        )
+                        WHERE REFERRING.`{column_name}` IS NOT NULL
+                        AND REFERRED.`{referenced_column_name}` IS NULL
+                        """
+                    )
+                    for bad_row in cursor.fetchall():
+                        raise IntegrityError(
+                            f"The row in table '{table_name}' with primary "
+                            f"key '{bad_row[0]}' has an invalid foreign key: "
+                            f"{table_name}.{column_name} contains a value "
+                            f"'{bad_row[1]}' that does not have a "
+                            f"corresponding value in "
+                            f"{referenced_table_name}."
+                            f"{referenced_column_name}."
+                        )
+
+    def is_usable(self) -> bool:
+        try:
+            self.connection.ping()
+        except Error:
+            return False
+        return True
+
+    @cached_property  # type: ignore[misc]
+    @staticmethod
+    def display_name() -> str:
+        """Display name."""
+        return "MySQL"
+
+    @cached_property
+    def data_type_check_constraints(self) -> Dict[str, str]:
+        """Mapping of Field objects to their SQL for CHECK constraints."""
+        if self.features.supports_column_check_constraints:
+            check_constraints = {
+                "PositiveBigIntegerField": "`%(column)s` >= 0",
+                "PositiveIntegerField": "`%(column)s` >= 0",
+                "PositiveSmallIntegerField": "`%(column)s` >= 0",
+            }
+            return check_constraints
+        return {}
+
+    @cached_property
+    def mysql_server_data(self) -> Dict[str, Any]:
+        """Return MySQL server data."""
+        with self.temporary_connection() as cursor:
+            # Select some server variables and test if the time zone
+            # definitions are installed. CONVERT_TZ returns NULL if 'UTC'
+            # timezone isn't loaded into the mysql.time_zone table.
+            cursor.execute(
+                """
+                SELECT VERSION(),
+                       @@sql_mode,
+                       @@default_storage_engine,
+                       @@sql_auto_is_null,
+                       @@lower_case_table_names,
+                       CONVERT_TZ('2001-01-01 01:00:00', 'UTC', 'UTC') IS NOT NULL
+            """
+            )
+            row = cursor.fetchone()
+        return {
+            "version": row[0],
+            "sql_mode": row[1],
+            "default_storage_engine": row[2],
+            "sql_auto_is_null": bool(row[3]),
+            "lower_case_table_names": bool(row[4]),
+            "has_zoneinfo_database": bool(row[5]),
+        }
+
+    @cached_property
+    def mysql_server_info(self) -> Any:
+        """Return MySQL version."""
+        with self.temporary_connection() as cursor:
+            cursor.execute("SELECT VERSION()")
+            return cursor.fetchone()[0]
+
+    @cached_property
+    def mysql_version(self) -> Tuple[int, ...]:
+        """Return MySQL version."""
+        config = self.get_connection_params()
+        with mysql.connector.connect(**config) as conn:
+            server_version: Tuple[int, ...] = conn.get_server_version()
+        return server_version
+
+    @cached_property
+    def sql_mode(self) -> Set[str]:
+        """Return SQL mode."""
+        with self.cursor() as cursor:
+            cursor.execute("SELECT @@sql_mode")
+            sql_mode = cursor.fetchone()
+        return set(sql_mode[0].split(",") if sql_mode else ())
+
+    @property
+    def use_pure(self) -> bool:
+        """Return True if pure Python version is being used."""
+        ans: bool = self._use_pure
+        return ans
+
+
+class DjangoMySQLConverter(MySQLConverter):
+    """Custom converter for Django."""
+
+    # pylint: disable=unused-argument
+
+    @staticmethod
+    def _time_to_python(value: bytes, dsc: Any = None) -> Optional[time]:
+        """Return MySQL TIME data type as datetime.time()
+
+        Returns datetime.time()
+        """
+        return dateparse.parse_time(value.decode("utf-8"))
+
+    @staticmethod
+    def _datetime_to_python(value: bytes, dsc: Any = None) -> Optional[datetime]:
+        """Connector/Python always returns naive datetime.datetime
+
+        Connector/Python always returns naive timestamps since MySQL has
+        no time zone support.
+
+        - A naive datetime is a datetime that doesn't know its own timezone.
+
+        Django needs a non-naive datetime, but in this method we don't need
+        to make a datetime value time zone aware since Django itself at some
+        point will make it aware (at least in versions 3.2.16 and 4.1.2) when
+        USE_TZ=True. This may change in a future release, we need to keep an
+        eye on this behaviour.
+
+        Returns datetime.datetime()
+        """
+        return MySQLConverter._datetime_to_python(value) if value else None
+
+    # pylint: enable=unused-argument
+
+    def _safestring_to_mysql(self, value: str) -> Union[bytes, HexLiteral]:
+        return self._str_to_mysql(value)
+
+    def _safetext_to_mysql(self, value: str) -> Union[bytes, HexLiteral]:
+        return self._str_to_mysql(value)
+
+    def _safebytes_to_mysql(self, value: bytes) -> bytes:
+        return self._bytes_to_mysql(value)

myenv/lib/python3.11/site-packages/mysql/connector/django/client.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0, as
+# published by the Free Software Foundation.
+#
+# This program is designed to work with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an
+# additional permission to link the program and your derivative works
+# with the separately licensed software that they have either included with
+# the program or referenced in the documentation.
+#
+# Without limiting anything contained in the foregoing, this file,
+# which is part of MySQL Connector/Python, is also subject to the
+# Universal FOSS Exception, version 1.0, a copy of which can be found at
+# http://oss.oracle.com/licenses/universal-foss-exception.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+
+"""Database Client."""
+
+import os
+import subprocess
+
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+from django.db.backends.base.client import BaseDatabaseClient
+
+
+class DatabaseClient(BaseDatabaseClient):
+    """Encapsulate backend-specific methods for opening a client shell."""
+
+    executable_name = "mysql"
+
+    @classmethod
+    def settings_to_cmd_args_env(
+        cls, settings_dict: Dict[str, Any], parameters: Optional[Iterable[str]] = None
+    ) -> Tuple[List[str], Optional[Dict[str, Any]]]:
+        args = [cls.executable_name]
+
+        db = settings_dict["OPTIONS"].get("database", settings_dict["NAME"])
+        user = settings_dict["OPTIONS"].get("user", settings_dict["USER"])
+        passwd = settings_dict["OPTIONS"].get("password", settings_dict["PASSWORD"])
+        host = settings_dict["OPTIONS"].get("host", settings_dict["HOST"])
+        port = settings_dict["OPTIONS"].get("port", settings_dict["PORT"])
+        ssl_ca = settings_dict["OPTIONS"].get("ssl_ca")
+        ssl_cert = settings_dict["OPTIONS"].get("ssl_cert")
+        ssl_key = settings_dict["OPTIONS"].get("ssl_key")
+        defaults_file = settings_dict["OPTIONS"].get("read_default_file")
+        charset = settings_dict["OPTIONS"].get("charset")
+
+        # --defaults-file should always be the first option
+        if defaults_file:
+            args.append(f"--defaults-file={defaults_file}")
+
+        # Load any custom init_commands. We always force SQL_MODE to TRADITIONAL
+        init_command = settings_dict["OPTIONS"].get("init_command", "")
+        args.append(f"--init-command=SET @@session.SQL_MODE=TRADITIONAL;{init_command}")
+
+        if user:
+            args.append(f"--user={user}")
+        if passwd:
+            args.append(f"--password={passwd}")
+
+        if host:
+            if "/" in host:
+                args.append(f"--socket={host}")
+            else:
+                args.append(f"--host={host}")
+
+        if port:
+            args.append(f"--port={port}")
+
+        if db:
+            args.append(f"--database={db}")
+
+        if ssl_ca:
+            args.append(f"--ssl-ca={ssl_ca}")
+        if ssl_cert:
+            args.append(f"--ssl-cert={ssl_cert}")
+        if ssl_key:
+            args.append(f"--ssl-key={ssl_key}")
+
+        if charset:
+            args.append(f"--default-character-set={charset}")
+
+        if parameters:
+            args.extend(parameters)
+
+        return args, None
+
+    def runshell(self, parameters: Optional[Iterable[str]] = None) -> None:
+        args, env = self.settings_to_cmd_args_env(
+            self.connection.settings_dict, parameters
+        )
+        env = {**os.environ, **env} if env else None
+        subprocess.run(args, env=env, check=True)

myenv/lib/python3.11/site-packages/mysql/connector/django/compiler.py

@@ -0,0 +1,45 @@
+# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0, as
+# published by the Free Software Foundation.
+#
+# This program is designed to work with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an
+# additional permission to link the program and your derivative works
+# with the separately licensed software that they have either included with
+# the program or referenced in the documentation.
+#
+# Without limiting anything contained in the foregoing, this file,
+# which is part of MySQL Connector/Python, is also subject to the
+# Universal FOSS Exception, version 1.0, a copy of which can be found at
+# http://oss.oracle.com/licenses/universal-foss-exception.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+
+"""SQL Compiler classes."""
+
+from django.db.backends.mysql.compiler import (
+    SQLAggregateCompiler,
+    SQLCompiler,
+    SQLDeleteCompiler,
+    SQLInsertCompiler,
+    SQLUpdateCompiler,
+)
+
+__all__ = [
+    "SQLAggregateCompiler",
+    "SQLCompiler",
+    "SQLDeleteCompiler",
+    "SQLInsertCompiler",
+    "SQLUpdateCompiler",
+]

myenv/lib/python3.11/site-packages/mysql/connector/django/creation.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0, as
+# published by the Free Software Foundation.
+#
+# This program is designed to work with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an
+# additional permission to link the program and your derivative works
+# with the separately licensed software that they have either included with
+# the program or referenced in the documentation.
+#
+# Without limiting anything contained in the foregoing, this file,
+# which is part of MySQL Connector/Python, is also subject to the
+# Universal FOSS Exception, version 1.0, a copy of which can be found at
+# http://oss.oracle.com/licenses/universal-foss-exception.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+
+"""Backend specific database creation."""
+
+from django.db.backends.mysql.creation import DatabaseCreation
+
+__all__ = ["DatabaseCreation"]

myenv/lib/python3.11/site-packages/mysql/connector/django/features.py

@@ -0,0 +1,50 @@
+# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0, as
+# published by the Free Software Foundation.
+#
+# This program is designed to work with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an
+# additional permission to link the program and your derivative works
+# with the separately licensed software that they have either included with
+# the program or referenced in the documentation.
+#
+# Without limiting anything contained in the foregoing, this file,
+# which is part of MySQL Connector/Python, is also subject to the
+# Universal FOSS Exception, version 1.0, a copy of which can be found at
+# http://oss.oracle.com/licenses/universal-foss-exception.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+
+"""Database Features."""
+
+from typing import Any, List
+
+from django.db.backends.mysql.features import DatabaseFeatures as MySQLDatabaseFeatures
+from django.utils.functional import cached_property
+
+
+class DatabaseFeatures(MySQLDatabaseFeatures):
+    """Database Features Specification class."""
+
+    empty_fetchmany_value: List[Any] = []
+
+    @cached_property
+    def can_introspect_check_constraints(self) -> bool:  # type: ignore[override]
+        """Check if backend support introspection CHECK of constraints."""
+        return self.connection.mysql_version >= (8, 0, 16)
+
+    @cached_property
+    def supports_microsecond_precision(self) -> bool:
+        """Check if backend support microsecond precision."""
+        return self.connection.mysql_version >= (5, 6, 3)

myenv/lib/python3.11/site-packages/mysql/connector/django/introspection.py

@@ -0,0 +1,461 @@
+# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0, as
+# published by the Free Software Foundation.
+#
+# This program is designed to work with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an
+# additional permission to link the program and your derivative works
+# with the separately licensed software that they have either included with
+# the program or referenced in the documentation.
+#
+# Without limiting anything contained in the foregoing, this file,
+# which is part of MySQL Connector/Python, is also subject to the
+# Universal FOSS Exception, version 1.0, a copy of which can be found at
+# http://oss.oracle.com/licenses/universal-foss-exception.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+
+# mypy: disable-error-code="override,attr-defined,call-arg"
+
+"""Database Introspection."""
+
+from collections import namedtuple
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Tuple
+
+import sqlparse
+
+from django import VERSION as DJANGO_VERSION
+from django.db.backends.base.introspection import (
+    BaseDatabaseIntrospection,
+    FieldInfo as BaseFieldInfo,
+    TableInfo,
+)
+from django.db.models import Index
+from django.utils.datastructures import OrderedSet
+
+from mysql.connector.constants import FieldType
+
+# from .base import CursorWrapper produces a circular import error,
+# avoiding importing CursorWrapper explicitly, using a documented
+# trick; write the imports inside if TYPE_CHECKING: so that they
+# are not executed at runtime.
+# Ref: https://buildmedia.readthedocs.org/media/pdf/mypy/stable/mypy.pdf [page 42]
+if TYPE_CHECKING:
+    # CursorWraper is used exclusively for type hinting
+    from mysql.connector.django.base import CursorWrapper
+
+# Based on my investigation, named tuples to
+# comply with mypy need to define a static list or tuple
+# for field_names (second argument). In this case, the field
+# names are created dynamically for FieldInfo which triggers
+# a mypy error. The solution is not straightforward since
+# FieldInfo attributes are Django version dependent. Code
+# refactory is needed to fix this issue.
+FieldInfo = namedtuple(  # type: ignore[misc]
+    "FieldInfo",
+    BaseFieldInfo._fields + ("extra", "is_unsigned", "has_json_constraint"),
+)
+if DJANGO_VERSION < (3, 2, 0):
+    InfoLine = namedtuple(
+        "InfoLine",
+        "col_name data_type max_len num_prec num_scale extra column_default "
+        "is_unsigned",
+    )
+else:
+    InfoLine = namedtuple(  # type: ignore[no-redef]
+        "InfoLine",
+        "col_name data_type max_len num_prec num_scale extra column_default "
+        "collation is_unsigned",
+    )
+
+
+class DatabaseIntrospection(BaseDatabaseIntrospection):
+    """Encapsulate backend-specific introspection utilities."""
+
+    data_types_reverse = {
+        FieldType.BLOB: "TextField",
+        FieldType.DECIMAL: "DecimalField",
+        FieldType.NEWDECIMAL: "DecimalField",
+        FieldType.DATE: "DateField",
+        FieldType.DATETIME: "DateTimeField",
+        FieldType.DOUBLE: "FloatField",
+        FieldType.FLOAT: "FloatField",
+        FieldType.INT24: "IntegerField",
+        FieldType.LONG: "IntegerField",
+        FieldType.LONGLONG: "BigIntegerField",
+        FieldType.SHORT: "SmallIntegerField",
+        FieldType.STRING: "CharField",
+        FieldType.TIME: "TimeField",
+        FieldType.TIMESTAMP: "DateTimeField",
+        FieldType.TINY: "IntegerField",
+        FieldType.TINY_BLOB: "TextField",
+        FieldType.MEDIUM_BLOB: "TextField",
+        FieldType.LONG_BLOB: "TextField",
+        FieldType.VAR_STRING: "CharField",
+    }
+
+    def get_field_type(self, data_type: str, description: FieldInfo) -> str:
+        field_type = super().get_field_type(data_type, description)  # type: ignore[arg-type]
+        if "auto_increment" in description.extra:
+            if field_type == "IntegerField":
+                return "AutoField"
+            if field_type == "BigIntegerField":
+                return "BigAutoField"
+            if field_type == "SmallIntegerField":
+                return "SmallAutoField"
+        if description.is_unsigned:
+            if field_type == "BigIntegerField":
+                return "PositiveBigIntegerField"
+            if field_type == "IntegerField":
+                return "PositiveIntegerField"
+            if field_type == "SmallIntegerField":
+                return "PositiveSmallIntegerField"
+        # JSON data type is an alias for LONGTEXT in MariaDB, use check
+        # constraints clauses to introspect JSONField.
+        if description.has_json_constraint:
+            return "JSONField"
+        return field_type
+
+    def get_table_list(self, cursor: "CursorWrapper") -> List[TableInfo]:
+        """Return a list of table and view names in the current database."""
+        cursor.execute("SHOW FULL TABLES")
+        return [
+            TableInfo(row[0], {"BASE TABLE": "t", "VIEW": "v"}.get(row[1]))
+            for row in cursor.fetchall()
+        ]
+
+    def get_table_description(
+        self, cursor: "CursorWrapper", table_name: str
+    ) -> List[FieldInfo]:
+        """
+        Return a description of the table with the DB-API cursor.description
+        interface."
+        """
+        json_constraints: Dict[Any, Any] = {}
+        # A default collation for the given table.
+        cursor.execute(
+            """
+            SELECT  table_collation
+            FROM    information_schema.tables
+            WHERE   table_schema = DATABASE()
+            AND     table_name = %s
+        """,
+            [table_name],
+        )
+        row = cursor.fetchone()
+        default_column_collation = row[0] if row else ""
+        # information_schema database gives more accurate results for some figures:
+        # - varchar length returned by cursor.description is an internal length,
+        #   not visible length (#5725)
+        # - precision and scale (for decimal fields) (#5014)
+        # - auto_increment is not available in cursor.description
+        if DJANGO_VERSION < (3, 2, 0):
+            cursor.execute(
+                """
+                SELECT
+                    column_name, data_type, character_maximum_length,
+                    numeric_precision, numeric_scale, extra, column_default,
+                    CASE
+                        WHEN column_type LIKE '%% unsigned' THEN 1
+                        ELSE 0
+                    END AS is_unsigned
+                FROM information_schema.columns
+                WHERE table_name = %s AND table_schema = DATABASE()
+            """,
+                [table_name],
+            )
+        else:
+            cursor.execute(
+                """
+                SELECT
+                    column_name, data_type, character_maximum_length,
+                    numeric_precision, numeric_scale, extra, column_default,
+                    CASE
+                        WHEN collation_name = %s THEN NULL
+                        ELSE collation_name
+                    END AS collation_name,
+                    CASE
+                        WHEN column_type LIKE '%% unsigned' THEN 1
+                        ELSE 0
+                    END AS is_unsigned
+                FROM information_schema.columns
+                WHERE table_name = %s AND table_schema = DATABASE()
+            """,
+                [default_column_collation, table_name],
+            )
+        field_info = {line[0]: InfoLine(*line) for line in cursor.fetchall()}
+
+        cursor.execute(
+            f"SELECT * FROM {self.connection.ops.quote_name(table_name)} LIMIT 1"
+        )
+
+        def to_int(i: Any) -> Optional[int]:
+            return int(i) if i is not None else i
+
+        fields = []
+        for line in cursor.description:
+            info = field_info[line[0]]
+            if DJANGO_VERSION < (3, 2, 0):
+                fields.append(
+                    FieldInfo(
+                        *line[:3],
+                        to_int(info.max_len) or line[3],
+                        to_int(info.num_prec) or line[4],
+                        to_int(info.num_scale) or line[5],
+                        line[6],
+                        info.column_default,
+                        info.extra,
+                        info.is_unsigned,
+                        line[0] in json_constraints,
+                    )
+                )
+            else:
+                fields.append(
+                    FieldInfo(
+                        *line[:3],
+                        to_int(info.max_len) or line[3],
+                        to_int(info.num_prec) or line[4],
+                        to_int(info.num_scale) or line[5],
+                        line[6],
+                        info.column_default,
+                        info.collation,
+                        info.extra,
+                        info.is_unsigned,
+                        line[0] in json_constraints,
+                    )
+                )
+        return fields
+
+    def get_indexes(
+        self, cursor: "CursorWrapper", table_name: str
+    ) -> Dict[int, Dict[str, bool]]:
+        """Return indexes from table."""
+        cursor.execute(f"SHOW INDEX FROM {self.connection.ops.quote_name(table_name)}")
+        # Do a two-pass search for indexes: on first pass check which indexes
+        # are multicolumn, on second pass check which single-column indexes
+        # are present.
+        rows = list(cursor.fetchall())
+        multicol_indexes = set()
+        for row in rows:
+            if row[3] > 1:
+                multicol_indexes.add(row[2])
+        indexes: Dict[int, Dict[str, bool]] = {}
+        for row in rows:
+            if row[2] in multicol_indexes:
+                continue
+            if row[4] not in indexes:
+                indexes[row[4]] = {"primary_key": False, "unique": False}
+            # It's possible to have the unique and PK constraints in
+            # separate indexes.
+            if row[2] == "PRIMARY":
+                indexes[row[4]]["primary_key"] = True
+            if not row[1]:
+                indexes[row[4]]["unique"] = True
+        return indexes
+
+    def get_primary_key_column(
+        self, cursor: "CursorWrapper", table_name: str
+    ) -> Optional[int]:
+        """
+        Returns the name of the primary key column for the given table
+        """
+        for column in self.get_indexes(cursor, table_name).items():
+            if column[1]["primary_key"]:
+                return column[0]
+        return None
+
+    def get_sequences(
+        self, cursor: "CursorWrapper", table_name: str, table_fields: Any = ()
+    ) -> List[Dict[str, str]]:
+        for field_info in self.get_table_description(cursor, table_name):
+            if "auto_increment" in field_info.extra:
+                # MySQL allows only one auto-increment column per table.
+                return [{"table": table_name, "column": field_info.name}]
+        return []
+
+    def get_relations(
+        self, cursor: "CursorWrapper", table_name: str
+    ) -> Dict[str, Tuple[str, str]]:
+        """
+        Return a dictionary of {field_name: (field_name_other_table, other_table)}
+        representing all relationships to the given table.
+        """
+        constraints = self.get_key_columns(cursor, table_name)
+        relations = {}
+        for my_fieldname, other_table, other_field in constraints:
+            relations[my_fieldname] = (other_field, other_table)
+        return relations
+
+    def get_key_columns(
+        self, cursor: "CursorWrapper", table_name: str
+    ) -> List[Tuple[str, str, str]]:
+        """
+        Return a list of (column_name, referenced_table_name, referenced_column_name)
+        for all key columns in the given table.
+        """
+        key_columns: List[Any] = []
+        cursor.execute(
+            """
+            SELECT column_name, referenced_table_name, referenced_column_name
+            FROM information_schema.key_column_usage
+            WHERE table_name = %s
+                AND table_schema = DATABASE()
+                AND referenced_table_name IS NOT NULL
+                AND referenced_column_name IS NOT NULL""",
+            [table_name],
+        )
+        key_columns.extend(cursor.fetchall())
+        return key_columns
+
+    def get_storage_engine(self, cursor: "CursorWrapper", table_name: str) -> str:
+        """
+        Retrieve the storage engine for a given table. Return the default
+        storage engine if the table doesn't exist.
+        """
+        cursor.execute(
+            "SELECT engine FROM information_schema.tables WHERE table_name = %s",
+            [table_name],
+        )
+        result = cursor.fetchone()
+        # pylint: disable=protected-access
+        if not result:
+            return self.connection.features._mysql_storage_engine
+        # pylint: enable=protected-access
+        return result[0]
+
+    def _parse_constraint_columns(
+        self, check_clause: Any, columns: Set[str]
+    ) -> OrderedSet:
+        check_columns: OrderedSet = OrderedSet()
+        statement = sqlparse.parse(check_clause)[0]
+        tokens = (token for token in statement.flatten() if not token.is_whitespace)
+        for token in tokens:
+            if (
+                token.ttype == sqlparse.tokens.Name
+                and self.connection.ops.quote_name(token.value) == token.value
+                and token.value[1:-1] in columns
+            ):
+                check_columns.add(token.value[1:-1])
+        return check_columns
+
+    def get_constraints(
+        self, cursor: "CursorWrapper", table_name: str
+    ) -> Dict[str, Any]:
+        """
+        Retrieve any constraints or keys (unique, pk, fk, check, index) across
+        one or more columns.
+        """
+        constraints: Dict[str, Any] = {}
+        # Get the actual constraint names and columns
+        name_query = """
+            SELECT kc.`constraint_name`, kc.`column_name`,
+                kc.`referenced_table_name`, kc.`referenced_column_name`
+            FROM information_schema.key_column_usage AS kc
+            WHERE
+                kc.table_schema = DATABASE() AND
+                kc.table_name = %s
+            ORDER BY kc.`ordinal_position`
+        """
+        cursor.execute(name_query, [table_name])
+        for constraint, column, ref_table, ref_column in cursor.fetchall():
+            if constraint not in constraints:
+                constraints[constraint] = {
+                    "columns": OrderedSet(),
+                    "primary_key": False,
+                    "unique": False,
+                    "index": False,
+                    "check": False,
+                    "foreign_key": (ref_table, ref_column) if ref_column else None,
+                }
+                if self.connection.features.supports_index_column_ordering:
+                    constraints[constraint]["orders"] = []
+            constraints[constraint]["columns"].add(column)
+        # Now get the constraint types
+        type_query = """
+            SELECT c.constraint_name, c.constraint_type
+            FROM information_schema.table_constraints AS c
+            WHERE
+                c.table_schema = DATABASE() AND
+                c.table_name = %s
+        """
+        cursor.execute(type_query, [table_name])
+        for constraint, kind in cursor.fetchall():
+            if kind.lower() == "primary key":
+                constraints[constraint]["primary_key"] = True
+                constraints[constraint]["unique"] = True
+            elif kind.lower() == "unique":
+                constraints[constraint]["unique"] = True
+        # Add check constraints.
+        if self.connection.features.can_introspect_check_constraints:
+            unnamed_constraints_index = 0
+            columns = {
+                info.name for info in self.get_table_description(cursor, table_name)
+            }
+            type_query = """
+                SELECT cc.constraint_name, cc.check_clause
+                FROM
+                    information_schema.check_constraints AS cc,
+                    information_schema.table_constraints AS tc
+                WHERE
+                    cc.constraint_schema = DATABASE() AND
+                    tc.table_schema = cc.constraint_schema AND
+                    cc.constraint_name = tc.constraint_name AND
+                    tc.constraint_type = 'CHECK' AND
+                    tc.table_name = %s
+            """
+            cursor.execute(type_query, [table_name])
+            for constraint, check_clause in cursor.fetchall():
+                constraint_columns = self._parse_constraint_columns(
+                    check_clause, columns
+                )
+                # Ensure uniqueness of unnamed constraints. Unnamed unique
+                # and check columns constraints have the same name as
+                # a column.
+                if set(constraint_columns) == {constraint}:
+                    unnamed_constraints_index += 1
+                    constraint = f"__unnamed_constraint_{unnamed_constraints_index}__"
+                constraints[constraint] = {
+                    "columns": constraint_columns,
+                    "primary_key": False,
+                    "unique": False,
+                    "index": False,
+                    "check": True,
+                    "foreign_key": None,
+                }
+        # Now add in the indexes
+        cursor.execute(f"SHOW INDEX FROM {self.connection.ops.quote_name(table_name)}")
+        for _, _, index, _, column, order, type_ in [
+            x[:6] + (x[10],) for x in cursor.fetchall()
+        ]:
+            if index not in constraints:
+                constraints[index] = {
+                    "columns": OrderedSet(),
+                    "primary_key": False,
+                    "unique": False,
+                    "check": False,
+                    "foreign_key": None,
+                }
+                if self.connection.features.supports_index_column_ordering:
+                    constraints[index]["orders"] = []
+            constraints[index]["index"] = True
+            constraints[index]["type"] = (
+                Index.suffix if type_ == "BTREE" else type_.lower()
+            )
+            constraints[index]["columns"].add(column)
+            if self.connection.features.supports_index_column_ordering:
+                constraints[index]["orders"].append("DESC" if order == "D" else "ASC")
+        # Convert the sorted sets to lists
+        for constraint in constraints.values():
+            constraint["columns"] = list(constraint["columns"])
+        return constraints

myenv/lib/python3.11/site-packages/mysql/connector/django/operations.py

@@ -0,0 +1,104 @@
+# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0, as
+# published by the Free Software Foundation.
+#
+# This program is designed to work with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an
+# additional permission to link the program and your derivative works
+# with the separately licensed software that they have either included with
+# the program or referenced in the documentation.
+#
+# Without limiting anything contained in the foregoing, this file,
+# which is part of MySQL Connector/Python, is also subject to the
+# Universal FOSS Exception, version 1.0, a copy of which can be found at
+# http://oss.oracle.com/licenses/universal-foss-exception.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+
+# mypy: disable-error-code="override,attr-defined"
+
+"""Database Operations."""
+
+from datetime import datetime, time, timezone
+from typing import Optional
+
+from django.conf import settings
+from django.db.backends.mysql.operations import (
+    DatabaseOperations as MySQLDatabaseOperations,
+)
+from django.utils import timezone as django_timezone
+
+try:
+    from _mysql_connector import datetime_to_mysql, time_to_mysql
+except ImportError:
+    HAVE_CEXT = False
+else:
+    HAVE_CEXT = True
+
+
+class DatabaseOperations(MySQLDatabaseOperations):
+    """Database Operations class."""
+
+    compiler_module = "mysql.connector.django.compiler"
+
+    def regex_lookup(self, lookup_type: str) -> str:
+        """Return the string to use in a query when performing regular
+        expression lookup."""
+        if self.connection.mysql_version < (8, 0, 0):
+            if lookup_type == "regex":
+                return "%s REGEXP BINARY %s"
+            return "%s REGEXP %s"
+
+        match_option = "c" if lookup_type == "regex" else "i"
+        return f"REGEXP_LIKE(%s, %s, '{match_option}')"
+
+    def adapt_datetimefield_value(self, value: Optional[datetime]) -> Optional[bytes]:
+        """Transform a datetime value to an object compatible with what is
+        expected by the backend driver for datetime columns."""
+        return self.value_to_db_datetime(value)
+
+    def value_to_db_datetime(self, value: Optional[datetime]) -> Optional[bytes]:
+        """Convert value to MySQL DATETIME."""
+        ans: Optional[bytes] = None
+        if value is None:
+            return ans
+        # MySQL doesn't support tz-aware times
+        if django_timezone.is_aware(value):
+            if settings.USE_TZ:
+                value = value.astimezone(timezone.utc).replace(tzinfo=None)
+            else:
+                raise ValueError("MySQL backend does not support timezone-aware times")
+        if not self.connection.features.supports_microsecond_precision:
+            value = value.replace(microsecond=0)
+        if not self.connection.use_pure:
+            return datetime_to_mysql(value)
+        return self.connection.converter.to_mysql(value)
+
+    def adapt_timefield_value(self, value: Optional[time]) -> Optional[bytes]:
+        """Transform a time value to an object compatible with what is expected
+        by the backend driver for time columns."""
+        return self.value_to_db_time(value)
+
+    def value_to_db_time(self, value: Optional[time]) -> Optional[bytes]:
+        """Convert value to MySQL TIME."""
+        if value is None:
+            return None
+
+        # MySQL doesn't support tz-aware times
+        if django_timezone.is_aware(value):
+            raise ValueError("MySQL backend does not support timezone-aware times")
+
+        if not self.connection.use_pure:
+            return time_to_mysql(value)
+        return self.connection.converter.to_mysql(value)

myenv/lib/python3.11/site-packages/mysql/connector/django/schema.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0, as
+# published by the Free Software Foundation.
+#
+# This program is designed to work with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an
+# additional permission to link the program and your derivative works
+# with the separately licensed software that they have either included with
+# the program or referenced in the documentation.
+#
+# Without limiting anything contained in the foregoing, this file,
+# which is part of MySQL Connector/Python, is also subject to the
+# Universal FOSS Exception, version 1.0, a copy of which can be found at
+# http://oss.oracle.com/licenses/universal-foss-exception.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+
+# mypy: disable-error-code="override"
+
+"""Database schema editor."""
+from typing import Any
+
+from django.db.backends.mysql.schema import (
+    DatabaseSchemaEditor as MySQLDatabaseSchemaEditor,
+)
+
+
+class DatabaseSchemaEditor(MySQLDatabaseSchemaEditor):
+    """This class is responsible for emitting schema-changing statements to the
+    databases.
+    """
+
+    def quote_value(self, value: Any) -> Any:
+        """Quote value."""
+        self.connection.ensure_connection()
+        if isinstance(value, str):
+            value = value.replace("%", "%%")
+        quoted = self.connection.connection.converter.escape(value)
+        if isinstance(value, str) and isinstance(quoted, bytes):
+            quoted = quoted.decode()
+        return quoted
+
+    def prepare_default(self, value: Any) -> Any:
+        """Implement the required abstract method.
+
+        MySQL has requires_literal_defaults=False, therefore return the value.
+        """
+        return value

myenv/lib/python3.11/site-packages/mysql/connector/django/validation.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0, as
+# published by the Free Software Foundation.
+#
+# This program is designed to work with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an
+# additional permission to link the program and your derivative works
+# with the separately licensed software that they have either included with
+# the program or referenced in the documentation.
+#
+# Without limiting anything contained in the foregoing, this file,
+# which is part of MySQL Connector/Python, is also subject to the
+# Universal FOSS Exception, version 1.0, a copy of which can be found at
+# http://oss.oracle.com/licenses/universal-foss-exception.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+
+"""Backend specific database validation."""
+
+from django.db.backends.mysql.validation import DatabaseValidation
+
+__all__ = ["DatabaseValidation"]