sqlspec 0.47.0__cp314-cp314-win_amd64.whl

sqlspec/adapters/mysqlconnector/litestar/store.py

@@ -0,0 +1,426 @@
+"""MysqlConnector session store for Litestar integration."""
+
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Any, Final, cast
+
+import mysql.connector
+
+from sqlspec.extensions.litestar.store import BaseSQLSpecStore
+from sqlspec.utils.logging import get_logger
+from sqlspec.utils.sync_tools import async_
+
+if TYPE_CHECKING:
+    from sqlspec.adapters.mysqlconnector.config import MysqlConnectorAsyncConfig, MysqlConnectorSyncConfig
+
+logger = get_logger("sqlspec.adapters.mysqlconnector.litestar.store")
+
+__all__ = ("MysqlConnectorAsyncStore", "MysqlConnectorSyncStore")
+
+MYSQL_TABLE_NOT_FOUND_ERROR: Final = 1146
+
+
+class MysqlConnectorAsyncStore(BaseSQLSpecStore["MysqlConnectorAsyncConfig"]):
+    """MySQL/MariaDB session store using mysql-connector async driver."""
+
+    __slots__ = ()
+
+    def __init__(self, config: "MysqlConnectorAsyncConfig") -> None:
+        super().__init__(config)
+
+    def _get_create_table_sql(self) -> str:
+        return f"""
+        CREATE TABLE IF NOT EXISTS {self._table_name} (
+            session_id VARCHAR(255) PRIMARY KEY,
+            data LONGBLOB NOT NULL,
+            expires_at DATETIME(6),
+            created_at DATETIME(6) DEFAULT CURRENT_TIMESTAMP(6),
+            updated_at DATETIME(6) DEFAULT CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6),
+            INDEX idx_{self._table_name}_expires_at (expires_at)
+        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+        """
+
+    def _get_drop_table_sql(self) -> "list[str]":
+        return [
+            f"DROP INDEX idx_{self._table_name}_expires_at ON {self._table_name}",
+            f"DROP TABLE IF EXISTS {self._table_name}",
+        ]
+
+    async def create_table(self) -> None:
+        sql = self._get_create_table_sql()
+        async with self._config.provide_session() as driver:
+            await driver.execute_script(sql)
+        self._log_table_created()
+
+    async def get(self, key: str, renew_for: "int | timedelta | None" = None) -> "bytes | None":
+        sql = f"""
+        SELECT data, expires_at FROM {self._table_name}
+        WHERE session_id = %s
+        AND (expires_at IS NULL OR expires_at > UTC_TIMESTAMP(6))
+        """
+
+        try:
+            async with self._config.provide_connection() as conn:
+                cursor = await conn.cursor()
+                try:
+                    await cursor.execute(sql, (key,))
+                    row = await cursor.fetchone()
+                finally:
+                    await cursor.close()
+
+                if row is None:
+                    return None
+
+                data_value: Any = row[0]
+                expires_at: Any = row[1]
+
+                if renew_for is not None and expires_at is not None:
+                    new_expires_at = self._calculate_expires_at(renew_for)
+                    if new_expires_at is not None:
+                        naive_expires_at = new_expires_at.replace(tzinfo=None)
+                        update_sql = f"""
+                            UPDATE {self._table_name}
+                            SET expires_at = %s, updated_at = UTC_TIMESTAMP(6)
+                            WHERE session_id = %s
+                            """
+                        update_cursor = await conn.cursor()
+                        try:
+                            await update_cursor.execute(update_sql, (naive_expires_at, key))
+                        finally:
+                            await update_cursor.close()
+                        await conn.commit()
+
+                return bytes(cast("bytes", data_value))
+        except mysql.connector.Error as exc:
+            if "doesn't exist" in str(exc) or getattr(exc, "errno", None) == MYSQL_TABLE_NOT_FOUND_ERROR:
+                return None
+            raise
+
+    async def set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
+        data = self._value_to_bytes(value)
+        expires_at = self._calculate_expires_at(expires_in)
+        naive_expires_at = expires_at.replace(tzinfo=None) if expires_at else None
+
+        sql = f"""
+        INSERT INTO {self._table_name} (session_id, data, expires_at)
+        VALUES (%s, %s, %s) AS new
+        ON DUPLICATE KEY UPDATE
+            data = new.data,
+            expires_at = new.expires_at,
+            updated_at = UTC_TIMESTAMP(6)
+        """
+
+        async with self._config.provide_connection() as conn:
+            cursor = await conn.cursor()
+            try:
+                await cursor.execute(sql, (key, data, naive_expires_at))
+            finally:
+                await cursor.close()
+            await conn.commit()
+
+    async def delete(self, key: str) -> None:
+        sql = f"DELETE FROM {self._table_name} WHERE session_id = %s"
+
+        async with self._config.provide_connection() as conn:
+            cursor = await conn.cursor()
+            try:
+                await cursor.execute(sql, (key,))
+            finally:
+                await cursor.close()
+            await conn.commit()
+
+    async def delete_all(self) -> None:
+        sql = f"DELETE FROM {self._table_name}"
+
+        try:
+            async with self._config.provide_connection() as conn:
+                cursor = await conn.cursor()
+                try:
+                    await cursor.execute(sql)
+                finally:
+                    await cursor.close()
+                await conn.commit()
+            self._log_delete_all()
+        except mysql.connector.Error as exc:
+            if "doesn't exist" in str(exc) or getattr(exc, "errno", None) == MYSQL_TABLE_NOT_FOUND_ERROR:
+                logger.debug("Table %s does not exist, skipping delete_all", self._table_name)
+                return
+            raise
+
+    async def exists(self, key: str) -> bool:
+        sql = f"""
+        SELECT 1 FROM {self._table_name}
+        WHERE session_id = %s
+        AND (expires_at IS NULL OR expires_at > UTC_TIMESTAMP(6))
+        """
+
+        try:
+            async with self._config.provide_connection() as conn:
+                cursor = await conn.cursor()
+                try:
+                    await cursor.execute(sql, (key,))
+                    result = await cursor.fetchone()
+                finally:
+                    await cursor.close()
+                return result is not None
+        except mysql.connector.Error as exc:
+            if "doesn't exist" in str(exc) or getattr(exc, "errno", None) == MYSQL_TABLE_NOT_FOUND_ERROR:
+                return False
+            raise
+
+    async def expires_in(self, key: str) -> "int | None":
+        sql = f"""
+        SELECT expires_at FROM {self._table_name}
+        WHERE session_id = %s
+        """
+
+        async with self._config.provide_connection() as conn:
+            cursor = await conn.cursor()
+            try:
+                await cursor.execute(sql, (key,))
+                row = await cursor.fetchone()
+            finally:
+                await cursor.close()
+
+            if row is None or row[0] is None:
+                return None
+
+            expires_at_naive: datetime = cast("datetime", row[0])
+            expires_at_utc = expires_at_naive.replace(tzinfo=timezone.utc)
+            now = datetime.now(timezone.utc)
+
+            if expires_at_utc <= now:
+                return 0
+
+            delta = expires_at_utc - now
+            return int(delta.total_seconds())
+
+    async def delete_expired(self) -> int:
+        sql = f"DELETE FROM {self._table_name} WHERE expires_at <= UTC_TIMESTAMP(6)"
+
+        async with self._config.provide_connection() as conn:
+            cursor = await conn.cursor()
+            try:
+                await cursor.execute(sql)
+                await conn.commit()
+                count: int = cursor.rowcount
+            finally:
+                await cursor.close()
+            if count > 0:
+                self._log_delete_expired(count)
+            return count
+
+
+class MysqlConnectorSyncStore(BaseSQLSpecStore["MysqlConnectorSyncConfig"]):
+    """MySQL/MariaDB session store using mysql-connector sync driver."""
+
+    __slots__ = ()
+
+    def __init__(self, config: "MysqlConnectorSyncConfig") -> None:
+        super().__init__(config)
+
+    def _get_create_table_sql(self) -> str:
+        return f"""
+        CREATE TABLE IF NOT EXISTS {self._table_name} (
+            session_id VARCHAR(255) PRIMARY KEY,
+            data LONGBLOB NOT NULL,
+            expires_at DATETIME(6),
+            created_at DATETIME(6) DEFAULT CURRENT_TIMESTAMP(6),
+            updated_at DATETIME(6) DEFAULT CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6),
+            INDEX idx_{self._table_name}_expires_at (expires_at)
+        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+        """
+
+    def _get_drop_table_sql(self) -> "list[str]":
+        return [
+            f"DROP INDEX idx_{self._table_name}_expires_at ON {self._table_name}",
+            f"DROP TABLE IF EXISTS {self._table_name}",
+        ]
+
+    def _create_table(self) -> None:
+        sql = self._get_create_table_sql()
+        with self._config.provide_session() as driver:
+            driver.execute_script(sql)
+            driver.commit()
+        self._log_table_created()
+
+    async def create_table(self) -> None:
+        await async_(self._create_table)()
+
+    def _get(self, key: str, renew_for: "int | timedelta | None" = None) -> "bytes | None":
+        sql = f"""
+        SELECT data, expires_at FROM {self._table_name}
+        WHERE session_id = %s
+        AND (expires_at IS NULL OR expires_at > UTC_TIMESTAMP(6))
+        """
+
+        try:
+            with self._config.provide_connection() as conn:
+                cursor = conn.cursor()
+                try:
+                    cursor.execute(sql, (key,))
+                    row = cursor.fetchone()
+                finally:
+                    cursor.close()
+
+                if row is None:
+                    return None
+
+                data_value: Any = row[0]
+                expires_at: Any = row[1]
+
+                if renew_for is not None and expires_at is not None:
+                    new_expires_at = self._calculate_expires_at(renew_for)
+                    if new_expires_at is not None:
+                        naive_expires_at = new_expires_at.replace(tzinfo=None)
+                        update_sql = f"""
+                            UPDATE {self._table_name}
+                            SET expires_at = %s, updated_at = UTC_TIMESTAMP(6)
+                            WHERE session_id = %s
+                            """
+                        update_cursor = conn.cursor()
+                        try:
+                            update_cursor.execute(update_sql, (naive_expires_at, key))
+                        finally:
+                            update_cursor.close()
+                        conn.commit()
+
+                return bytes(cast("bytes", data_value))
+        except mysql.connector.Error as exc:
+            if "doesn't exist" in str(exc) or getattr(exc, "errno", None) == MYSQL_TABLE_NOT_FOUND_ERROR:
+                return None
+            raise
+
+    async def get(self, key: str, renew_for: "int | timedelta | None" = None) -> "bytes | None":
+        return await async_(self._get)(key, renew_for)
+
+    def _set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
+        data = self._value_to_bytes(value)
+        expires_at = self._calculate_expires_at(expires_in)
+        naive_expires_at = expires_at.replace(tzinfo=None) if expires_at else None
+
+        sql = f"""
+        INSERT INTO {self._table_name} (session_id, data, expires_at)
+        VALUES (%s, %s, %s) AS new
+        ON DUPLICATE KEY UPDATE
+            data = new.data,
+            expires_at = new.expires_at,
+            updated_at = UTC_TIMESTAMP(6)
+        """
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                cursor.execute(sql, (key, data, naive_expires_at))
+            finally:
+                cursor.close()
+            conn.commit()
+
+    async def set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
+        await async_(self._set)(key, value, expires_in)
+
+    def _delete(self, key: str) -> None:
+        sql = f"DELETE FROM {self._table_name} WHERE session_id = %s"
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                cursor.execute(sql, (key,))
+            finally:
+                cursor.close()
+            conn.commit()
+
+    async def delete(self, key: str) -> None:
+        await async_(self._delete)(key)
+
+    def _delete_all(self) -> None:
+        sql = f"DELETE FROM {self._table_name}"
+
+        try:
+            with self._config.provide_connection() as conn:
+                cursor = conn.cursor()
+                try:
+                    cursor.execute(sql)
+                finally:
+                    cursor.close()
+                conn.commit()
+            self._log_delete_all()
+        except mysql.connector.Error as exc:
+            if "doesn't exist" in str(exc) or getattr(exc, "errno", None) == MYSQL_TABLE_NOT_FOUND_ERROR:
+                logger.debug("Table %s does not exist, skipping delete_all", self._table_name)
+                return
+            raise
+
+    async def delete_all(self) -> None:
+        await async_(self._delete_all)()
+
+    def _exists(self, key: str) -> bool:
+        sql = f"""
+        SELECT 1 FROM {self._table_name}
+        WHERE session_id = %s
+        AND (expires_at IS NULL OR expires_at > UTC_TIMESTAMP(6))
+        """
+
+        try:
+            with self._config.provide_connection() as conn:
+                cursor = conn.cursor()
+                try:
+                    cursor.execute(sql, (key,))
+                    result = cursor.fetchone()
+                finally:
+                    cursor.close()
+                return result is not None
+        except mysql.connector.Error as exc:
+            if "doesn't exist" in str(exc) or getattr(exc, "errno", None) == MYSQL_TABLE_NOT_FOUND_ERROR:
+                return False
+            raise
+
+    async def exists(self, key: str) -> bool:
+        return await async_(self._exists)(key)
+
+    def _expires_in(self, key: str) -> "int | None":
+        sql = f"""
+        SELECT expires_at FROM {self._table_name}
+        WHERE session_id = %s
+        """
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                cursor.execute(sql, (key,))
+                row = cursor.fetchone()
+            finally:
+                cursor.close()
+
+            if row is None or row[0] is None:
+                return None
+
+            expires_at_naive: datetime = cast("datetime", row[0])
+            expires_at_utc = expires_at_naive.replace(tzinfo=timezone.utc)
+            now = datetime.now(timezone.utc)
+
+            if expires_at_utc <= now:
+                return 0
+
+            delta = expires_at_utc - now
+            return int(delta.total_seconds())
+
+    async def expires_in(self, key: str) -> "int | None":
+        return await async_(self._expires_in)(key)
+
+    def _delete_expired(self) -> int:
+        sql = f"DELETE FROM {self._table_name} WHERE expires_at <= UTC_TIMESTAMP(6)"
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                cursor.execute(sql)
+                conn.commit()
+                count: int = cursor.rowcount
+            finally:
+                cursor.close()
+            if count > 0:
+                self._log_delete_expired(count)
+            return count
+
+    async def delete_expired(self) -> int:
+        return await async_(self._delete_expired)()

sqlspec/adapters/oracledb/__init__.py

@@ -0,0 +1,39 @@
+from sqlspec.adapters.oracledb._param_types import OracleBlob, OracleClob, OracleJson
+from sqlspec.adapters.oracledb.config import (
+    OracleAsyncConfig,
+    OracleConnectionParams,
+    OracleDriverFeatures,
+    OraclePoolParams,
+    OracleSyncConfig,
+)
+from sqlspec.adapters.oracledb.core import default_statement_config
+from sqlspec.adapters.oracledb.data_dictionary import (
+    OracledbAsyncDataDictionary,
+    OracledbSyncDataDictionary,
+    OracleVersionInfo,
+)
+from sqlspec.adapters.oracledb.driver import (
+    OracleAsyncDriver,
+    OracleAsyncExceptionHandler,
+    OracleSyncDriver,
+    OracleSyncExceptionHandler,
+)
+
+__all__ = (
+    "OracleAsyncConfig",
+    "OracleAsyncDriver",
+    "OracleAsyncExceptionHandler",
+    "OracleBlob",
+    "OracleClob",
+    "OracleConnectionParams",
+    "OracleDriverFeatures",
+    "OracleJson",
+    "OraclePoolParams",
+    "OracleSyncConfig",
+    "OracleSyncDriver",
+    "OracleSyncExceptionHandler",
+    "OracleVersionInfo",
+    "OracledbAsyncDataDictionary",
+    "OracledbSyncDataDictionary",
+    "default_statement_config",
+)

sqlspec/adapters/oracledb/_json_handlers.py

@@ -0,0 +1,196 @@
+"""Oracle native JSON type handlers.
+
+Provides automatic conversion between Python ``dict`` / ``list`` / ``tuple`` values
+and Oracle's JSON storage types via connection type handlers.
+
+Routing matrix (input):
+
+* Oracle 21c+ native ``JSON``: bind via ``DB_TYPE_JSON`` (binary OSON).
+* Oracle 19c-20c with ``BLOB CHECK (... IS JSON)``: bind via ``DB_TYPE_BLOB`` with
+  UTF-8 JSON bytes.
+* Oracle 12c-18c with ``CLOB CHECK (... IS JSON)``: bind via ``DB_TYPE_CLOB`` with
+  serialized JSON string.
+* Server major version is read from ``connection._sqlspec_oracle_major`` (set in
+  ``OracleSyncConfig._init_connection`` / ``OracleAsyncConfig._init_connection``).
+  When unknown, default to 21c+ behavior.
+
+Routing matrix (output):
+
+* ``DB_TYPE_JSON``: passthrough (python-oracledb already returns ``dict``).
+* ``DB_TYPE_BLOB`` with ``JSON`` in column ``type_name``: parse via
+  ``json_converter_out_blob``.
+* ``DB_TYPE_CLOB`` with ``JSON`` in column ``type_name``: parse via
+  ``json_converter_out_clob``.
+
+Handlers chain to any pre-existing ``inputtypehandler`` / ``outputtypehandler``
+registered on the connection (e.g. NumPy vector, UUID), so registration order
+matters: register JSON after numpy, before UUID is also safe because each
+handler returns ``None`` for values it does not own.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from sqlspec.adapters.oracledb._typing import DB_TYPE_BLOB, DB_TYPE_CLOB, DB_TYPE_JSON
+from sqlspec.utils.serializers import from_json, to_json
+
+if TYPE_CHECKING:
+    from oracledb import AsyncConnection, AsyncCursor, Connection, Cursor
+
+__all__ = (
+    "json_converter_in_blob",
+    "json_converter_in_clob",
+    "json_converter_out_blob",
+    "json_converter_out_clob",
+    "json_input_type_handler",
+    "json_output_type_handler",
+    "register_json_handlers",
+)
+
+
+_JSON_TYPE_NAME_MARKER = "JSON"
+
+# Server-version thresholds for JSON binding strategy selection.
+# 21c+ supports DB_TYPE_JSON (binary OSON); 19c-20c uses BLOB CHECK (... IS JSON);
+# pre-19c uses CLOB CHECK (... IS JSON).
+_NATIVE_JSON_MIN_MAJOR = 21
+_BLOB_IS_JSON_MIN_MAJOR = 19
+
+
+def json_converter_in_clob(value: Any) -> str:
+    """Serialize a Python value to a JSON string for CLOB binding."""
+    return to_json(value)
+
+
+def json_converter_in_blob(value: Any) -> bytes:
+    """Serialize a Python value to UTF-8 JSON bytes for BLOB binding."""
+    return to_json(value, as_bytes=True)
+
+
+def json_converter_out_clob(value: "str | None") -> Any:
+    """Parse a JSON string from a CLOB read back into a Python value."""
+    if value is None:
+        return None
+    return from_json(value)
+
+
+def json_converter_out_blob(value: "bytes | None") -> Any:
+    """Parse JSON bytes from a BLOB read back into a Python value."""
+    if value is None:
+        return None
+    return from_json(value)
+
+
+def _is_json_payload(value: Any) -> bool:
+    """Return True if the value should be claimed by the JSON input handler.
+
+    ``dict`` and ``tuple``/``list`` of dicts are claimed. Sequences whose first
+    element is a number are NOT claimed — those are vector embeddings and
+    belong to the vector handler.
+    """
+    if isinstance(value, dict):
+        return True
+    if isinstance(value, (list, tuple)):
+        if not value:
+            # Empty sequence: ambiguous (could be empty vector or empty list).
+            # Defer to the next handler in the chain.
+            return False
+        first = value[0]
+        # Reject sequences of numbers (vector embeddings).
+        return not (isinstance(first, (int, float)) and not isinstance(first, bool))
+    return False
+
+
+def _input_type_handler(cursor: "Cursor | AsyncCursor", value: Any, arraysize: int) -> Any:
+    """Oracle input type handler for JSON-shaped Python values."""
+    if not _is_json_payload(value):
+        return None
+
+    server_major = getattr(cursor.connection, "_sqlspec_oracle_major", None)
+
+    if server_major is None or server_major >= _NATIVE_JSON_MIN_MAJOR:
+        return cursor.var(DB_TYPE_JSON, arraysize=arraysize)
+    if server_major >= _BLOB_IS_JSON_MIN_MAJOR:
+        return cursor.var(DB_TYPE_BLOB, arraysize=arraysize, inconverter=json_converter_in_blob)
+    return cursor.var(DB_TYPE_CLOB, arraysize=arraysize, inconverter=json_converter_in_clob)
+
+
+def _output_type_handler(cursor: "Cursor | AsyncCursor", metadata: Any) -> Any:
+    """Oracle output type handler for JSON-bearing column reads."""
+    type_code = getattr(metadata, "type_code", None)
+
+    if type_code is DB_TYPE_JSON:
+        # Native JSON: python-oracledb returns dict/list directly. No conversion.
+        return None
+
+    type_name = (getattr(metadata, "type_name", "") or "").upper()
+    if _JSON_TYPE_NAME_MARKER not in type_name:
+        return None
+
+    if type_code is DB_TYPE_BLOB:
+        return cursor.var(DB_TYPE_BLOB, arraysize=cursor.arraysize, outconverter=json_converter_out_blob)
+    if type_code is DB_TYPE_CLOB:
+        return cursor.var(DB_TYPE_CLOB, arraysize=cursor.arraysize, outconverter=json_converter_out_clob)
+    return None
+
+
+def json_input_type_handler(cursor: "Cursor | AsyncCursor", value: Any, arraysize: int) -> Any:
+    """Public input type handler entry point."""
+    return _input_type_handler(cursor, value, arraysize)
+
+
+def json_output_type_handler(cursor: "Cursor | AsyncCursor", metadata: Any) -> Any:
+    """Public output type handler entry point."""
+    return _output_type_handler(cursor, metadata)
+
+
+def register_json_handlers(connection: "Connection | AsyncConnection") -> None:
+    """Register JSON type handlers on an Oracle connection.
+
+    Chains to any existing handlers via ``_JsonInputHandler`` / ``_JsonOutputHandler``
+    wrapper classes so vector / UUID handlers continue to fire for non-JSON values.
+    """
+    try:
+        existing_input = connection.inputtypehandler
+    except AttributeError:
+        existing_input = None
+    try:
+        existing_output = connection.outputtypehandler
+    except AttributeError:
+        existing_output = None
+
+    connection.inputtypehandler = _JsonInputHandler(existing_input)
+    connection.outputtypehandler = _JsonOutputHandler(existing_output)
+
+
+class _JsonInputHandler:
+    """Chaining wrapper that claims dict/list/tuple values, falling back otherwise."""
+
+    __slots__ = ("_fallback",)
+
+    def __init__(self, fallback: "Any | None") -> None:
+        self._fallback = fallback
+
+    def __call__(self, cursor: "Cursor | AsyncCursor", value: Any, arraysize: int) -> Any:
+        result = _input_type_handler(cursor, value, arraysize)
+        if result is not None:
+            return result
+        if self._fallback is not None:
+            return self._fallback(cursor, value, arraysize)
+        return None
+
+
+class _JsonOutputHandler:
+    """Chaining wrapper that claims JSON-bearing columns, falling back otherwise."""
+
+    __slots__ = ("_fallback",)
+
+    def __init__(self, fallback: "Any | None") -> None:
+        self._fallback = fallback
+
+    def __call__(self, cursor: "Cursor | AsyncCursor", metadata: Any) -> Any:
+        result = _output_type_handler(cursor, metadata)
+        if result is not None:
+            return result
+        if self._fallback is not None:
+            return self._fallback(cursor, metadata)
+        return None