piccolo 1.27.1__py3-none-any.whl → 1.29.0__py3-none-any.whl

piccolo/table.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import inspect
 import itertools
 import types
-import typing as t
 import warnings
+from collections.abc import Sequence
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Optional, Union, cast, overload
 
 from piccolo.columns import Column
 from piccolo.columns.column_types import (
@@ -15,7 +16,6 @@ from piccolo.columns.column_types import (
     Email,
     ForeignKey,
     ReferencedTable,
-    Secret,
     Serial,
 )
 from piccolo.columns.defaults.base import Default
@@ -55,7 +55,7 @@ from piccolo.utils.sql_values import convert_to_sql_value
 from piccolo.utils.sync import run_sync
 from piccolo.utils.warnings import colored_warning
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.querystring import Selectable
 
 PROTECTED_TABLENAMES = ("user",)
@@ -65,7 +65,7 @@ TABLENAME_WARNING = (
 )
 
 
-TABLE_REGISTRY: t.List[t.Type[Table]] = []
+TABLE_REGISTRY: list[type[Table]] = []
 
 
 @dataclass
@@ -75,26 +75,26 @@ class TableMeta:
     """
 
     tablename: str = ""
-    columns: t.List[Column] = field(default_factory=list)
-    default_columns: t.List[Column] = field(default_factory=list)
-    non_default_columns: t.List[Column] = field(default_factory=list)
-    array_columns: t.List[Array] = field(default_factory=list)
-    email_columns: t.List[Email] = field(default_factory=list)
-    foreign_key_columns: t.List[ForeignKey] = field(default_factory=list)
+    columns: list[Column] = field(default_factory=list)
+    default_columns: list[Column] = field(default_factory=list)
+    non_default_columns: list[Column] = field(default_factory=list)
+    array_columns: list[Array] = field(default_factory=list)
+    email_columns: list[Email] = field(default_factory=list)
+    foreign_key_columns: list[ForeignKey] = field(default_factory=list)
     primary_key: Column = field(default_factory=Column)
-    json_columns: t.List[t.Union[JSON, JSONB]] = field(default_factory=list)
-    secret_columns: t.List[Secret] = field(default_factory=list)
-    auto_update_columns: t.List[Column] = field(default_factory=list)
-    tags: t.List[str] = field(default_factory=list)
-    help_text: t.Optional[str] = None
-    _db: t.Optional[Engine] = None
-    m2m_relationships: t.List[M2M] = field(default_factory=list)
-    schema: t.Optional[str] = None
+    json_columns: list[Union[JSON, JSONB]] = field(default_factory=list)
+    secret_columns: list[Column] = field(default_factory=list)
+    auto_update_columns: list[Column] = field(default_factory=list)
+    tags: list[str] = field(default_factory=list)
+    help_text: Optional[str] = None
+    _db: Optional[Engine] = None
+    m2m_relationships: list[M2M] = field(default_factory=list)
+    schema: Optional[str] = None
 
     # Records reverse foreign key relationships - i.e. when the current table
     # is the target of a foreign key. Used by external libraries such as
     # Piccolo API.
-    _foreign_key_references: t.List[ForeignKey] = field(default_factory=list)
+    _foreign_key_references: list[ForeignKey] = field(default_factory=list)
 
     def get_formatted_tablename(
         self, include_schema: bool = True, quoted: bool = True
@@ -120,8 +120,8 @@ class TableMeta:
             return ".".join(components)
 
     @property
-    def foreign_key_references(self) -> t.List[ForeignKey]:
-        foreign_keys: t.List[ForeignKey] = list(self._foreign_key_references)
+    def foreign_key_references(self) -> list[ForeignKey]:
+        foreign_keys: list[ForeignKey] = list(self._foreign_key_references)
         lazy_column_references = LAZY_COLUMN_REFERENCES.for_tablename(
             tablename=self.tablename
         )
@@ -173,11 +173,11 @@ class TableMeta:
 
         return column_object
 
-    def get_auto_update_values(self) -> t.Dict[Column, t.Any]:
+    def get_auto_update_values(self) -> dict[Column, Any]:
         """
         If columns have ``auto_update`` defined, then we retrieve these values.
         """
-        output: t.Dict[Column, t.Any] = {}
+        output: dict[Column, Any] = {}
         for column in self.auto_update_columns:
             value = column._meta.auto_update
             if callable(value):
@@ -203,7 +203,7 @@ class TableMetaclass(type):
 
             # `SessionsBase` is a `Table` subclass:
             def session_auth(
-                session_table: t.Type[SessionsBase] = SessionsBase
+                session_table: type[SessionsBase] = SessionsBase
             ):
                 ...
 
@@ -227,11 +227,11 @@ class Table(metaclass=TableMetaclass):
 
     def __init_subclass__(
         cls,
-        tablename: t.Optional[str] = None,
-        db: t.Optional[Engine] = None,
-        tags: t.Optional[t.List[str]] = None,
-        help_text: t.Optional[str] = None,
-        schema: t.Optional[str] = None,
+        tablename: Optional[str] = None,
+        db: Optional[Engine] = None,
+        tags: Optional[list[str]] = None,
+        help_text: Optional[str] = None,
+        schema: Optional[str] = None,
     ):  # sourcery no-metrics
         """
         Automatically populate the _meta, which includes the tablename, and
@@ -268,17 +268,17 @@ class Table(metaclass=TableMetaclass):
         if tablename in PROTECTED_TABLENAMES:
             warnings.warn(TABLENAME_WARNING.format(tablename=tablename))
 
-        columns: t.List[Column] = []
-        default_columns: t.List[Column] = []
-        non_default_columns: t.List[Column] = []
-        array_columns: t.List[Array] = []
-        foreign_key_columns: t.List[ForeignKey] = []
-        secret_columns: t.List[Secret] = []
-        json_columns: t.List[t.Union[JSON, JSONB]] = []
-        email_columns: t.List[Email] = []
-        auto_update_columns: t.List[Column] = []
-        primary_key: t.Optional[Column] = None
-        m2m_relationships: t.List[M2M] = []
+        columns: list[Column] = []
+        default_columns: list[Column] = []
+        non_default_columns: list[Column] = []
+        array_columns: list[Array] = []
+        foreign_key_columns: list[ForeignKey] = []
+        secret_columns: list[Column] = []
+        json_columns: list[Union[JSON, JSONB]] = []
+        email_columns: list[Email] = []
+        auto_update_columns: list[Column] = []
+        primary_key: Optional[Column] = None
+        m2m_relationships: list[M2M] = []
 
         attribute_names = itertools.chain(
             *[i.__dict__.keys() for i in reversed(cls.__mro__)]
@@ -314,15 +314,15 @@ class Table(metaclass=TableMetaclass):
                 if isinstance(column, Email):
                     email_columns.append(column)
 
-                if isinstance(column, Secret):
-                    secret_columns.append(column)
-
                 if isinstance(column, ForeignKey):
                     foreign_key_columns.append(column)
 
                 if isinstance(column, (JSON, JSONB)):
                     json_columns.append(column)
 
+                if column._meta.secret:
+                    secret_columns.append(column)
+
                 if column._meta.auto_update is not ...:
                     auto_update_columns.append(column)
 
@@ -372,7 +372,7 @@ class Table(metaclass=TableMetaclass):
 
     def __init__(
         self,
-        _data: t.Optional[t.Dict[Column, t.Any]] = None,
+        _data: Optional[dict[Column, Any]] = None,
         _ignore_missing: bool = False,
         _exists_in_db: bool = False,
         **kwargs,
@@ -412,7 +412,7 @@ class Table(metaclass=TableMetaclass):
 
         # This is used by get_or_create to indicate to the user whether it
         # was an existing row or not.
-        self._was_created: t.Optional[bool] = None
+        self._was_created: Optional[bool] = None
 
         for column in self._meta.columns:
             value = _data.get(column, ...)
@@ -423,7 +423,7 @@ class Table(metaclass=TableMetaclass):
 
                 if value is ...:
                     value = kwargs.pop(
-                        t.cast(str, column._meta.db_column_name), ...
+                        cast(str, column._meta.db_column_name), ...
                     )
 
             if value is ...:
@@ -456,7 +456,7 @@ class Table(metaclass=TableMetaclass):
 
     @classmethod
     def from_dict(
-        cls: t.Type[TableInstance], data: t.Dict[str, t.Any]
+        cls: type[TableInstance], data: dict[str, Any]
     ) -> TableInstance:
         """
         Used when loading fixtures. It can be overriden by subclasses in case
@@ -468,8 +468,8 @@ class Table(metaclass=TableMetaclass):
     ###########################################################################
 
     def save(
-        self, columns: t.Optional[t.Sequence[t.Union[Column, str]]] = None
-    ) -> t.Union[Insert, Update]:
+        self, columns: Optional[Sequence[Union[Column, str]]] = None
+    ) -> Union[Insert, Update]:
         """
         A proxy to an insert or update query.
 
@@ -504,7 +504,7 @@ class Table(metaclass=TableMetaclass):
                 for i in columns
             ]
 
-        values: t.Dict[Column, t.Any] = {
+        values: dict[Column, Any] = {
             i: getattr(self, i._meta.name, None) for i in column_instances
         }
 
@@ -525,9 +525,7 @@ class Table(metaclass=TableMetaclass):
             == getattr(self, self._meta.primary_key._meta.name)
         )
 
-    def update_self(
-        self, values: t.Dict[t.Union[Column, str], t.Any]
-    ) -> UpdateSelf:
+    def update_self(self, values: dict[Union[Column, str], Any]) -> UpdateSelf:
         """
         This allows the user to update a single object - useful when the values
         are derived from the database in some way.
@@ -581,7 +579,7 @@ class Table(metaclass=TableMetaclass):
 
     def refresh(
         self,
-        columns: t.Optional[t.Sequence[Column]] = None,
+        columns: Optional[Sequence[Column]] = None,
         load_json: bool = False,
     ) -> Refresh:
         """
@@ -611,16 +609,16 @@ class Table(metaclass=TableMetaclass):
         """
         return Refresh(instance=self, columns=columns, load_json=load_json)
 
-    @t.overload
+    @overload
     def get_related(
         self, foreign_key: ForeignKey[ReferencedTable]
     ) -> GetRelated[ReferencedTable]: ...
 
-    @t.overload
+    @overload
     def get_related(self, foreign_key: str) -> GetRelated[Table]: ...
 
     def get_related(
-        self, foreign_key: t.Union[str, ForeignKey[ReferencedTable]]
+        self, foreign_key: Union[str, ForeignKey[ReferencedTable]]
     ) -> GetRelated[ReferencedTable]:
         """
         Used to fetch a ``Table`` instance, for the target of a foreign key.
@@ -666,7 +664,7 @@ class Table(metaclass=TableMetaclass):
         self,
         *rows: Table,
         m2m: M2M,
-        extra_column_values: t.Dict[t.Union[Column, str], t.Any] = {},
+        extra_column_values: dict[Union[Column, str], Any] = {},
     ) -> M2MAddRelated:
         """
         Save the row if it doesn't already exist in the database, and insert
@@ -733,7 +731,7 @@ class Table(metaclass=TableMetaclass):
             m2m=m2m,
         )
 
-    def to_dict(self, *columns: Column) -> t.Dict[str, t.Any]:
+    def to_dict(self, *columns: Column) -> dict[str, Any]:
         """
         A convenience method which returns a dictionary, mapping column names
         to values for this table instance.
@@ -785,7 +783,7 @@ class Table(metaclass=TableMetaclass):
             )
         return output
 
-    def __setitem__(self, key: str, value: t.Any):
+    def __setitem__(self, key: str, value: Any):
         setattr(self, key, value)
 
     def __getitem__(self, key: str):
@@ -858,8 +856,8 @@ class Table(metaclass=TableMetaclass):
 
     @classmethod
     def all_related(
-        cls, exclude: t.Optional[t.List[t.Union[str, ForeignKey]]] = None
-    ) -> t.List[ForeignKey]:
+        cls, exclude: Optional[list[Union[str, ForeignKey]]] = None
+    ) -> list[ForeignKey]:
         """
         Used in conjunction with ``objects`` queries. Just as we can use
         ``all_related`` on a ``ForeignKey``, you can also use it for the table
@@ -908,8 +906,8 @@ class Table(metaclass=TableMetaclass):
 
     @classmethod
     def all_columns(
-        cls, exclude: t.Optional[t.Sequence[t.Union[str, Column]]] = None
-    ) -> t.List[Column]:
+        cls, exclude: Optional[Sequence[Union[str, Column]]] = None
+    ) -> list[Column]:
         """
         Used in conjunction with ``select`` queries. Just as we can use
         ``all_columns`` to retrieve all of the columns from a related table,
@@ -975,7 +973,7 @@ class Table(metaclass=TableMetaclass):
 
     @classmethod
     def insert(
-        cls: t.Type[TableInstance], *rows: TableInstance
+        cls: type[TableInstance], *rows: TableInstance
     ) -> Insert[TableInstance]:
         """
         Insert rows into the database.
@@ -993,7 +991,7 @@ class Table(metaclass=TableMetaclass):
         return query
 
     @classmethod
-    def raw(cls, sql: str, *args: t.Any) -> Raw:
+    def raw(cls, sql: str, *args: Any) -> Raw:
         """
         Execute raw SQL queries on the underlying engine - use with caution!
 
@@ -1012,8 +1010,8 @@ class Table(metaclass=TableMetaclass):
 
     @classmethod
     def _process_column_args(
-        cls, *columns: t.Union[Selectable, str]
-    ) -> t.Sequence[Selectable]:
+        cls, *columns: Union[Selectable, str]
+    ) -> Sequence[Selectable]:
         """
         Users can specify some column arguments as either Column instances, or
         as strings representing the column name, for convenience.
@@ -1030,7 +1028,7 @@ class Table(metaclass=TableMetaclass):
 
     @classmethod
     def select(
-        cls, *columns: t.Union[Selectable, str], exclude_secrets=False
+        cls, *columns: Union[Selectable, str], exclude_secrets=False
     ) -> Select:
         """
         Get data in the form of a list of dictionaries, with each dictionary
@@ -1109,8 +1107,8 @@ class Table(metaclass=TableMetaclass):
 
     @classmethod
     def objects(
-        cls: t.Type[TableInstance],
-        *prefetch: t.Union[ForeignKey, t.List[ForeignKey]],
+        cls: type[TableInstance],
+        *prefetch: Union[ForeignKey, list[ForeignKey]],
     ) -> Objects[TableInstance]:
         """
         Returns a list of table instances (each representing a row), which you
@@ -1151,8 +1149,8 @@ class Table(metaclass=TableMetaclass):
     @classmethod
     def count(
         cls,
-        column: t.Optional[Column] = None,
-        distinct: t.Optional[t.Sequence[Column]] = None,
+        column: Optional[Column] = None,
+        distinct: Optional[Sequence[Column]] = None,
     ) -> Count:
         """
         Count the number of matching rows::
@@ -1224,7 +1222,7 @@ class Table(metaclass=TableMetaclass):
     @classmethod
     def update(
         cls,
-        values: t.Optional[t.Dict[t.Union[Column, str], t.Any]] = None,
+        values: Optional[dict[Union[Column, str], Any]] = None,
         force: bool = False,
         use_auto_update: bool = True,
         **kwargs,
@@ -1288,7 +1286,7 @@ class Table(metaclass=TableMetaclass):
     @classmethod
     def create_index(
         cls,
-        columns: t.Union[t.List[Column], t.List[str]],
+        columns: Union[list[Column], list[str]],
         method: IndexMethod = IndexMethod.btree,
         if_not_exists: bool = False,
     ) -> CreateIndex:
@@ -1311,7 +1309,7 @@ class Table(metaclass=TableMetaclass):
     @classmethod
     def drop_index(
         cls,
-        columns: t.Union[t.List[Column], t.List[str]],
+        columns: Union[list[Column], list[str]],
         if_exists: bool = True,
     ) -> DropIndex:
         """
@@ -1328,7 +1326,7 @@ class Table(metaclass=TableMetaclass):
     ###########################################################################
 
     @classmethod
-    def _get_index_name(cls, column_names: t.List[str]) -> str:
+    def _get_index_name(cls, column_names: list[str]) -> str:
         """
         Generates an index name from the table name and column names.
         """
@@ -1338,7 +1336,7 @@ class Table(metaclass=TableMetaclass):
 
     @classmethod
     def _table_str(
-        cls, abbreviated=False, excluded_params: t.Optional[t.List[str]] = None
+        cls, abbreviated=False, excluded_params: Optional[list[str]] = None
     ):
         """
         Returns a basic string representation of the table and its columns.
@@ -1357,7 +1355,7 @@ class Table(metaclass=TableMetaclass):
         spacer = "\n    "
         columns = []
         for col in cls._meta.columns:
-            params: t.List[str] = []
+            params: list[str] = []
             for key, value in col._meta.params.items():
                 if key in excluded_params:
                     continue
@@ -1374,6 +1372,15 @@ class Table(metaclass=TableMetaclass):
             columns.append(
                 f"{col._meta.name} = {col.__class__.__name__}({params_string})"
             )
+
+        for m2m_relationship in cls._meta.m2m_relationships:
+            joining_table_name = (
+                m2m_relationship._meta.resolved_joining_table.__name__
+            )
+            columns.append(
+                f"{m2m_relationship._meta.name} = M2M({joining_table_name})"
+            )
+
         columns_string = spacer.join(columns)
         tablename = repr(cls._meta.tablename)
 
@@ -1392,10 +1399,10 @@ class Table(metaclass=TableMetaclass):
 
 def create_table_class(
     class_name: str,
-    bases: t.Tuple[t.Type] = (Table,),
-    class_kwargs: t.Dict[str, t.Any] = {},
-    class_members: t.Dict[str, t.Any] = {},
-) -> t.Type[Table]:
+    bases: tuple[type] = (Table,),
+    class_kwargs: dict[str, Any] = {},
+    class_members: dict[str, Any] = {},
+) -> type[Table]:
     """
     Used to dynamically create ``Table``subclasses at runtime. Most users
     will not require this. It's mostly used internally for Piccolo's
@@ -1411,8 +1418,8 @@ def create_table_class(
         For example, `{'my_column': Varchar()}`.
 
     """
-    return t.cast(
-        t.Type[Table],
+    return cast(
+        type[Table],
         types.new_class(
             name=class_name,
             bases=bases,
@@ -1427,7 +1434,7 @@ def create_table_class(
 
 
 async def create_db_tables(
-    *tables: t.Type[Table], if_not_exists: bool = False
+    *tables: type[Table], if_not_exists: bool = False
 ) -> None:
     """
     Creates the database table for each ``Table`` class passed in. The tables
@@ -1458,7 +1465,7 @@ async def create_db_tables(
 
 
 def create_db_tables_sync(
-    *tables: t.Type[Table], if_not_exists: bool = False
+    *tables: type[Table], if_not_exists: bool = False
 ) -> None:
     """
     A sync wrapper around :func:`create_db_tables`.
@@ -1466,7 +1473,7 @@ def create_db_tables_sync(
     run_sync(create_db_tables(*tables, if_not_exists=if_not_exists))
 
 
-def create_tables(*tables: t.Type[Table], if_not_exists: bool = False) -> None:
+def create_tables(*tables: type[Table], if_not_exists: bool = False) -> None:
     """
     This original implementation has been replaced, because it was synchronous,
     and felt at odds with the rest of the Piccolo codebase which is async
@@ -1485,7 +1492,7 @@ def create_tables(*tables: t.Type[Table], if_not_exists: bool = False) -> None:
     return create_db_tables_sync(*tables, if_not_exists=if_not_exists)
 
 
-async def drop_db_tables(*tables: t.Type[Table]) -> None:
+async def drop_db_tables(*tables: type[Table]) -> None:
     """
     Drops the database table for each ``Table`` class passed in. The tables
     are dropped in the correct order, based on their foreign keys.
@@ -1518,14 +1525,14 @@ async def drop_db_tables(*tables: t.Type[Table]) -> None:
     await atomic.run()
 
 
-def drop_db_tables_sync(*tables: t.Type[Table]) -> None:
+def drop_db_tables_sync(*tables: type[Table]) -> None:
     """
     A sync wrapper around :func:`drop_db_tables`.
     """
     run_sync(drop_db_tables(*tables))
 
 
-def drop_tables(*tables: t.Type[Table]) -> None:
+def drop_tables(*tables: type[Table]) -> None:
     """
     This original implementation has been replaced, because it was synchronous,
     and felt at odds with the rest of the Piccolo codebase which is async
@@ -1548,8 +1555,8 @@ def drop_tables(*tables: t.Type[Table]) -> None:
 
 
 def sort_table_classes(
-    table_classes: t.List[t.Type[Table]],
-) -> t.List[t.Type[Table]]:
+    table_classes: list[type[Table]],
+) -> list[type[Table]]:
     """
     Sort the table classes based on their foreign keys, so they can be created
     in the correct order.
@@ -1564,7 +1571,7 @@ def sort_table_classes(
     sorter = TopologicalSorter(graph)
     ordered_tablenames = tuple(sorter.static_order())
 
-    output: t.List[t.Type[Table]] = []
+    output: list[type[Table]] = []
     for tablename in ordered_tablenames:
         table_class = table_class_dict.get(tablename)
         if table_class is not None:
@@ -1574,10 +1581,10 @@ def sort_table_classes(
 
 
 def _get_graph(
-    table_classes: t.List[t.Type[Table]],
+    table_classes: list[type[Table]],
     iterations: int = 0,
     max_iterations: int = 5,
-) -> t.Dict[str, t.Set[str]]:
+) -> dict[str, set[str]]:
     """
     Analyses the tables based on their foreign keys, and returns a data
     structure like:
@@ -1590,13 +1597,13 @@ def _get_graph(
     to it via a foreign key.
 
     """
-    output: t.Dict[str, t.Set[str]] = {}
+    output: dict[str, set[str]] = {}
 
     if iterations >= max_iterations:
         return output
 
     for table_class in table_classes:
-        dependents: t.Set[str] = set()
+        dependents: set[str] = set()
         for fk in table_class._meta.foreign_key_columns:
             referenced_table = fk._foreign_key_meta.resolved_references
 

piccolo/table_reflection.py

@@ -4,8 +4,8 @@ tables.
 """
 
 import asyncio
-import typing as t
 from dataclasses import dataclass
+from typing import Any, Optional, Union
 
 from piccolo.apps.schema.commands.generate import get_output_schema
 from piccolo.engine import engine_finder
@@ -58,7 +58,7 @@ class Singleton(type):
     A metaclass that creates a Singleton base class when called.
     """
 
-    _instances: t.Dict = {}
+    _instances: dict = {}
 
     def __call__(cls, *args, **kwargs):
         if cls not in cls._instances:
@@ -80,7 +80,7 @@ class TableStorage(metaclass=Singleton):
     works with Postgres.
     """
 
-    def __init__(self, engine: t.Optional[Engine] = None):
+    def __init__(self, engine: Optional[Engine] = None):
         """
         :param engine:
             Which engine to use to make the database queries. If not specified,
@@ -89,13 +89,13 @@ class TableStorage(metaclass=Singleton):
         """
         self.engine = engine or engine_finder()
         self.tables = ImmutableDict()
-        self._schema_tables: t.Dict[str, t.List[str]] = {}
+        self._schema_tables: dict[str, list[str]] = {}
 
     async def reflect(
         self,
         schema_name: str = "public",
-        include: t.Union[t.List[str], str, None] = None,
-        exclude: t.Union[t.List[str], str, None] = None,
+        include: Union[list[str], str, None] = None,
+        exclude: Union[list[str], str, None] = None,
         keep_existing: bool = False,
     ) -> None:
         """
@@ -154,7 +154,7 @@ class TableStorage(metaclass=Singleton):
         dict.clear(self.tables)
         self._schema_tables.clear()
 
-    async def get_table(self, tablename: str) -> t.Optional[t.Type[Table]]:
+    async def get_table(self, tablename: str) -> Optional[type[Table]]:
         """
         Returns the ``Table`` class if it exists. If the table is not present
         in ``TableStorage``, it will try to reflect it.
@@ -177,7 +177,7 @@ class TableStorage(metaclass=Singleton):
             table_class = self.tables.get(tablename)
         return table_class
 
-    async def _add_table(self, schema_name: str, table: t.Type[Table]) -> None:
+    async def _add_table(self, schema_name: str, table: type[Table]) -> None:
         if issubclass(table, Table):
             table_name = self._get_table_name(
                 table._meta.tablename, schema_name
@@ -229,7 +229,7 @@ class TableStorage(metaclass=Singleton):
             raise ValueError("Couldn't find schema name.")
 
     @staticmethod
-    def _to_list(value: t.Any) -> t.List:
+    def _to_list(value: Any) -> list:
         if isinstance(value, list):
             return value
         elif isinstance(value, (tuple, set)):