datachain 0.14.2__py3-none-any.whl → 0.39.0__py3-none-any.whl

datachain/data_storage/warehouse.py

@@ -1,28 +1,30 @@
 import glob
-import json
 import logging
 import posixpath
-import random
+import secrets
 import string
 from abc import ABC, abstractmethod
-from collections.abc import Generator, Iterable, Iterator, Sequence
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from collections.abc import Callable, Generator, Iterable, Iterator, Sequence
+from typing import TYPE_CHECKING, Any, Union, cast
 from urllib.parse import urlparse
 
 import attrs
 import sqlalchemy as sa
-from sqlalchemy import Table, case, select
-from sqlalchemy.sql import func
 from sqlalchemy.sql.expression import true
-from tqdm.auto import tqdm
 
+from datachain import json
 from datachain.client import Client
 from datachain.data_storage.schema import convert_rows_custom_column_types
 from datachain.data_storage.serializer import Serializable
 from datachain.dataset import DatasetRecord, StorageURI
+from datachain.lib.file import File
+from datachain.lib.model_store import ModelStore
+from datachain.lib.signal_schema import SignalSchema
 from datachain.node import DirType, DirTypeGroup, Node, NodeWithPath, get_path
+from datachain.query.batch import RowsOutput
+from datachain.query.schema import ColumnMeta
 from datachain.sql.functions import path as pathfunc
-from datachain.sql.types import Int, SQLType
+from datachain.sql.types import SQLType
 from datachain.utils import sql_escape_like
 
 if TYPE_CHECKING:
@@ -31,18 +33,18 @@ if TYPE_CHECKING:
         _FromClauseArgument,
         _OnClauseArgument,
     )
-    from sqlalchemy.sql.selectable import Select
+    from sqlalchemy.sql.selectable import FromClause
     from sqlalchemy.types import TypeEngine
 
     from datachain.data_storage import schema
     from datachain.data_storage.db_engine import DatabaseEngine
     from datachain.data_storage.schema import DataTable
-    from datachain.lib.file import File
 
 
 logger = logging.getLogger("datachain")
 
 SELECT_BATCH_SIZE = 100_000  # number of rows to fetch at a time
+INSERT_BATCH_SIZE = 10_000  # number of rows to insert at a time
 
 
 class AbstractWarehouse(ABC, Serializable):
@@ -69,12 +71,36 @@ class AbstractWarehouse(ABC, Serializable):
         return self
 
     def __exit__(self, exc_type, exc_value, traceback) -> None:
-        # Default behavior is to do nothing, as connections may be shared.
-        pass
+        """Default behavior is to do nothing, as connections may be shared."""
 
     def cleanup_for_tests(self):
         """Cleanup for tests."""
 
+    def _to_jsonable(self, obj: Any) -> Any:
+        """Recursively convert Python/Pydantic structures into JSON-serializable
+        objects.
+        """
+
+        if ModelStore.is_pydantic(type(obj)):
+            # Use Pydantic's JSON mode to ensure datetime and other non-JSON
+            # native types are serialized in a compatible way.
+            return obj.model_dump(mode="json")
+
+        if isinstance(obj, dict):
+            out: dict[str, Any] = {}
+            for k, v in obj.items():
+                if not isinstance(k, str):
+                    key_str = json.dumps(self._to_jsonable(k), ensure_ascii=False)
+                else:
+                    key_str = k
+                out[key_str] = self._to_jsonable(v)
+            return out
+
+        if isinstance(obj, (list, tuple, set)):
+            return [self._to_jsonable(i) for i in obj]
+
+        return obj
+
     def convert_type(  # noqa: PLR0911
         self,
         val: Any,
@@ -121,11 +147,13 @@ class AbstractWarehouse(ABC, Serializable):
             if col_python_type is dict or col_type_name == "JSON":
                 if value_type is str:
                     return val
-                if value_type in (dict, list):
-                    return json.dumps(val)
-                raise ValueError(
-                    f"Cannot convert value {val!r} with type {value_type} to JSON"
-                )
+                try:
+                    json_ready = self._to_jsonable(val)
+                    return json.dumps(json_ready, ensure_ascii=False)
+                except Exception as e:
+                    raise ValueError(
+                        f"Cannot convert value {val!r} with type {value_type} to JSON"
+                    ) from e
 
             if isinstance(val, col_python_type):
                 return val
@@ -173,22 +201,22 @@ class AbstractWarehouse(ABC, Serializable):
     #
 
     @abstractmethod
-    def is_ready(self, timeout: Optional[int] = None) -> bool: ...
+    def is_ready(self, timeout: int | None = None) -> bool: ...
 
     def dataset_rows(
         self,
         dataset: DatasetRecord,
-        version: Optional[int] = None,
-        object_name: str = "file",
+        version: str | None = None,
+        column: str = "file",
     ):
         version = version or dataset.latest_version
 
-        table_name = self.dataset_table_name(dataset.name, version)
+        table_name = self.dataset_table_name(dataset, version)
         return self.schema.dataset_row_cls(
             table_name,
             self.db,
             dataset.get_schema(version),
-            object_name=object_name,
+            column=column,
         )
 
     @property
@@ -199,6 +227,15 @@ class AbstractWarehouse(ABC, Serializable):
     # Query Execution
     #
 
+    def query_count(self, query: sa.Select) -> int:
+        """Count the number of rows in a query."""
+        count_query = sa.select(sa.func.count(1)).select_from(query.subquery())
+        return next(self.db.execute(count_query))[0]
+
+    def table_rows_count(self, table) -> int:
+        count_query = sa.select(sa.func.count(1)).select_from(table)
+        return next(self.db.execute(count_query))[0]
+
     def dataset_select_paginated(
         self,
         query,
@@ -210,7 +247,7 @@ class AbstractWarehouse(ABC, Serializable):
         limit = query._limit
         paginated_query = query.limit(page_size)
 
-        offset = 0
+        offset = query._offset or 0
         num_yielded = 0
 
         # Ensure we're using a thread-local connection
@@ -218,7 +255,8 @@ class AbstractWarehouse(ABC, Serializable):
             while True:
                 if limit is not None:
                     limit -= num_yielded
-                    if limit == 0:
+                    num_yielded = 0
+                    if limit <= 0:
                         break
                     if limit < page_size:
                         paginated_query = paginated_query.limit(None).limit(limit)
@@ -226,16 +264,81 @@ class AbstractWarehouse(ABC, Serializable):
                 # Cursor results are not thread-safe, so we convert them to a list
                 results = list(wh.dataset_rows_select(paginated_query.offset(offset)))
 
-                processed = False
+                processed = 0
                 for row in results:
-                    processed = True
+                    processed += 1
                     yield row
                     num_yielded += 1
 
-                if not processed:
+                if processed < page_size:
                     break  # no more results
                 offset += page_size
 
+    def _regenerate_system_columns(
+        self,
+        selectable: sa.Select,
+        keep_existing_columns: bool = False,
+        regenerate_columns: Iterable[str] | None = None,
+    ) -> sa.Select:
+        """
+        Return a SELECT that regenerates system columns deterministically.
+
+        If keep_existing_columns is True, existing system columns will be kept as-is
+        even when they are listed in ``regenerate_columns``.
+
+        Args:
+            selectable: Base SELECT
+            keep_existing_columns: When True, reuse existing system columns even if
+                they are part of the regeneration set.
+            regenerate_columns: Names of system columns to regenerate. Defaults to
+                {"sys__id", "sys__rand"}. Columns not listed are left untouched.
+        """
+        system_columns = {
+            sys_col.name: sys_col.type
+            for sys_col in self.schema.dataset_row_cls.sys_columns()
+        }
+        regenerate = set(regenerate_columns or system_columns)
+        generators = {
+            "sys__id": self._system_row_number_expr,
+            "sys__rand": self._system_random_expr,
+        }
+
+        base = cast("FromClause", selectable.subquery())
+
+        def build(name: str) -> sa.ColumnElement:
+            expr = generators[name]()
+            return sa.cast(expr, system_columns[name]).label(name)
+
+        columns: list[sa.ColumnElement] = []
+        present: set[str] = set()
+        changed = False
+
+        for col in base.c:
+            present.add(col.name)
+            regen = col.name in regenerate and not keep_existing_columns
+            columns.append(build(col.name) if regen else col)
+            changed |= regen
+
+        for name in regenerate - present:
+            columns.append(build(name))
+            changed = True
+
+        if not changed:
+            return selectable
+
+        inner = sa.select(*columns).select_from(base).subquery()
+        return sa.select(*inner.c).select_from(inner)
+
+    def _system_row_number_expr(self):
+        """Return an expression that produces deterministic row numbers."""
+
+        raise NotImplementedError
+
+    def _system_random_expr(self):
+        """Return an expression that produces deterministic random values."""
+
+        raise NotImplementedError
+
     #
     # Table Name Internal Functions
     #
@@ -246,12 +349,24 @@ class AbstractWarehouse(ABC, Serializable):
         name = parsed.path if parsed.scheme == "file" else parsed.netloc
         return parsed.scheme, name
 
-    def dataset_table_name(self, dataset_name: str, version: int) -> str:
+    def dataset_table_name(self, dataset: DatasetRecord, version: str) -> str:
+        return self._construct_dataset_table_name(
+            dataset.project.namespace.name,
+            dataset.project.name,
+            dataset.name,
+            version,
+        )
+
+    def _construct_dataset_table_name(
+        self, namespace: str, project: str, dataset_name: str, version: str
+    ) -> str:
         prefix = self.DATASET_TABLE_PREFIX
         if Client.is_data_source_uri(dataset_name):
             # for datasets that are created for bucket listing we use different prefix
             prefix = self.DATASET_SOURCE_TABLE_PREFIX
-        return f"{prefix}{dataset_name}_{version}"
+        return (
+            f"{prefix}{namespace}_{project}_{dataset_name}_{version.replace('.', '_')}"
+        )
 
     def temp_table_name(self) -> str:
         return self.TMP_TABLE_NAME_PREFIX + _random_string(6)
@@ -269,38 +384,26 @@ class AbstractWarehouse(ABC, Serializable):
         name: str,
         columns: Sequence["sa.Column"] = (),
         if_not_exists: bool = True,
-    ) -> Table:
+    ) -> sa.Table:
         """Creates a dataset rows table for the given dataset name and columns"""
 
     def drop_dataset_rows_table(
         self,
         dataset: DatasetRecord,
-        version: int,
+        version: str,
         if_exists: bool = True,
     ) -> None:
         """Drops a dataset rows table for the given dataset name."""
-        table_name = self.dataset_table_name(dataset.name, version)
-        table = Table(table_name, self.db.metadata)
+        table_name = self.dataset_table_name(dataset, version)
+        table = sa.Table(table_name, self.db.metadata)
         self.db.drop_table(table, if_exists=if_exists)
-
-    @abstractmethod
-    def merge_dataset_rows(
-        self,
-        src: "DatasetRecord",
-        dst: "DatasetRecord",
-        src_version: int,
-        dst_version: int,
-    ) -> None:
-        """
-        Merges source dataset rows and current latest destination dataset rows
-        into a new rows table created for new destination dataset version.
-        Note that table for new destination version must be created upfront.
-        Merge results should not contain duplicates.
-        """
+        # Remove from metadata cache to allow recreation
+        if table_name in self.db.metadata.tables:
+            self.db.metadata.remove(self.db.metadata.tables[table_name])
 
     def dataset_rows_select(
         self,
-        query: sa.sql.selectable.Select,
+        query: sa.Select,
         **kwargs,
     ) -> Iterator[tuple[Any, ...]]:
         """
@@ -311,51 +414,81 @@ class AbstractWarehouse(ABC, Serializable):
             query.selected_columns, rows, self.db.dialect
         )
 
+    def dataset_rows_select_from_ids(
+        self,
+        query: sa.Select,
+        ids: Iterable[RowsOutput],
+        is_batched: bool,
+    ) -> Iterator[RowsOutput]:
+        """
+        Fetch dataset rows from database using a list of IDs.
+        """
+        if (id_col := query.selected_columns.get("sys__id")) is None:
+            raise RuntimeError("sys__id column not found in query")
+
+        query = query._clone().offset(None).limit(None).order_by(None)
+
+        if is_batched:
+            for batch in ids:
+                yield list(self.dataset_rows_select(query.where(id_col.in_(batch))))
+        else:
+            yield from self.dataset_rows_select(query.where(id_col.in_(ids)))
+
     @abstractmethod
     def get_dataset_sources(
-        self, dataset: DatasetRecord, version: int
+        self, dataset: DatasetRecord, version: str
     ) -> list[StorageURI]: ...
 
-    def rename_dataset_table(
-        self,
-        old_name: str,
-        new_name: str,
-        old_version: int,
-        new_version: int,
+    def rename_dataset_tables(
+        self, dataset: DatasetRecord, dataset_updated: DatasetRecord
     ) -> None:
-        old_ds_table_name = self.dataset_table_name(old_name, old_version)
-        new_ds_table_name = self.dataset_table_name(new_name, new_version)
-
-        self.db.rename_table(old_ds_table_name, new_ds_table_name)
+        """
+        Renames all dataset version tables when parts of the dataset that
+        are used in constructing table name are updated.
+        If nothing important is changed, nothing will be renamed (no DB calls
+        will be made at all).
+        """
+        for version in [v.version for v in dataset_updated.versions]:
+            if not dataset.has_version(version):
+                continue
+            src = self.dataset_table_name(dataset, version)
+            dest = self.dataset_table_name(dataset_updated, version)
+            if src == dest:
+                continue
+            self.db.rename_table(src, dest)
 
     def dataset_rows_count(self, dataset: DatasetRecord, version=None) -> int:
         """Returns total number of rows in a dataset"""
         dr = self.dataset_rows(dataset, version)
         table = dr.get_table()
-        query = select(sa.func.count(table.c.sys__id))
+        query = sa.select(sa.func.count(table.c.sys__id))
         (res,) = self.db.execute(query)
         return res[0]
 
     def dataset_stats(
-        self, dataset: DatasetRecord, version: int
-    ) -> tuple[Optional[int], Optional[int]]:
+        self, dataset: DatasetRecord, version: str
+    ) -> tuple[int | None, int | None]:
         """
         Returns tuple with dataset stats: total number of rows and total dataset size.
         """
-        if not (self.db.has_table(self.dataset_table_name(dataset.name, version))):
+        if not (self.db.has_table(self.dataset_table_name(dataset, version))):
             return None, None
 
+        file_signals = list(
+            SignalSchema.deserialize(dataset.feature_schema).get_signals(File)
+        )
+
         dr = self.dataset_rows(dataset, version)
         table = dr.get_table()
         expressions: tuple[_ColumnsClauseArgument[Any], ...] = (
             sa.func.count(table.c.sys__id),
         )
-        size_columns = [
-            c for c in table.columns if c.name == "size" or c.name.endswith("__size")
-        ]
+        size_column_names = [ColumnMeta.to_db_name(s) + "__size" for s in file_signals]
+        size_columns = [c for c in table.columns if c.name in size_column_names]
+
         if size_columns:
             expressions = (*expressions, sa.func.sum(sum(size_columns)))
-        query = select(*expressions)
+        query = sa.select(*expressions)
         ((nrows, *rest),) = self.db.execute(query)
         return nrows, rest[0] if rest else 0
 
@@ -364,17 +497,22 @@ class AbstractWarehouse(ABC, Serializable):
         """Convert File entries so they can be passed on to `insert_rows()`"""
 
     @abstractmethod
-    def insert_rows(self, table: Table, rows: Iterable[dict[str, Any]]) -> None:
+    def insert_rows(
+        self,
+        table: sa.Table,
+        rows: Iterable[dict[str, Any]],
+        batch_size: int = INSERT_BATCH_SIZE,
+    ) -> None:
         """Does batch inserts of any kind of rows into table"""
 
-    def insert_rows_done(self, table: Table) -> None:
+    def insert_rows_done(self, table: sa.Table) -> None:
         """
         Only needed for certain implementations
         to signal when rows inserts are complete.
         """
 
     @abstractmethod
-    def insert_dataset_rows(self, df, dataset: DatasetRecord, version: int) -> int:
+    def insert_dataset_rows(self, df, dataset: DatasetRecord, version: str) -> int:
         """Inserts dataset rows directly into dataset table"""
 
     @abstractmethod
@@ -393,7 +531,7 @@ class AbstractWarehouse(ABC, Serializable):
 
     @abstractmethod
     def dataset_table_export_file_names(
-        self, dataset: DatasetRecord, version: int
+        self, dataset: DatasetRecord, version: str
     ) -> list[str]:
         """
         Returns list of file names that will be created when user runs dataset export
@@ -404,7 +542,7 @@ class AbstractWarehouse(ABC, Serializable):
         self,
         bucket_uri: str,
         dataset: DatasetRecord,
-        version: int,
+        version: str,
         client_config=None,
     ) -> list[str]:
         """
@@ -454,7 +592,7 @@ class AbstractWarehouse(ABC, Serializable):
         dr = dataset_rows
         columns = [c.name for c in query.selected_columns]
         for row in self.db.execute(query):
-            d = dict(zip(columns, row))
+            d = dict(zip(columns, row, strict=False))
             yield Node(**{dr.without_object(k): v for k, v in d.items()})
 
     def get_dirs_by_parent_path(
@@ -478,7 +616,7 @@ class AbstractWarehouse(ABC, Serializable):
         dataset_rows: "DataTable",
         path_list: list[str],
         glob_name: str,
-        object_name="file",
+        column="file",
     ) -> Iterator[Node]:
         """Finds all Nodes that correspond to GLOB like path pattern."""
         dr = dataset_rows
@@ -488,7 +626,7 @@ class AbstractWarehouse(ABC, Serializable):
         ).subquery()
         path_glob = "/".join([*path_list, glob_name])
         dirpath = path_glob[: -len(glob_name)]
-        relpath = func.substr(de.c(q, "path"), len(dirpath) + 1)
+        relpath = sa.func.substr(de.c(q, "path"), len(dirpath) + 1)
 
         return self.get_nodes(
             self.expand_query(de, q, dr)
@@ -512,7 +650,7 @@ class AbstractWarehouse(ABC, Serializable):
         de = dr.dir_expansion()
         q = de.query(
             dr.select().where(dr.c("is_latest") == true()).subquery(),
-            object_name=dr.object_name,
+            column=dr.column,
         ).subquery()
         q = self.expand_query(de, q, dr)
 
@@ -575,25 +713,23 @@ class AbstractWarehouse(ABC, Serializable):
             default = getattr(
                 attrs.fields(Node), dr.without_object(column.name)
             ).default
-            return func.coalesce(column, default).label(column.name)
+            return sa.func.coalesce(column, default).label(column.name)
 
         return sa.select(
             q.c.sys__id,
-            case((de.c(q, "is_dir") == true(), DirType.DIR), else_=DirType.FILE).label(
-                dr.col_name("dir_type")
-            ),
+            sa.case(
+                (de.c(q, "is_dir") == true(), DirType.DIR), else_=DirType.FILE
+            ).label(dr.col_name("dir_type")),
             de.c(q, "path"),
             with_default(dr.c("etag")),
             de.c(q, "version"),
             with_default(dr.c("is_latest")),
             dr.c("last_modified"),
             with_default(dr.c("size")),
-            with_default(dr.c("rand", object_name="sys")),
+            with_default(dr.c("rand", column="sys")),
             dr.c("location"),
             de.c(q, "source"),
-        ).select_from(
-            q.outerjoin(dr.table, q.c.sys__id == dr.c("id", object_name="sys"))
-        )
+        ).select_from(q.outerjoin(dr.table, q.c.sys__id == dr.c("id", column="sys")))
 
     def get_node_by_path(self, dataset_rows: "DataTable", path: str) -> Node:
         """Gets node that corresponds to some path"""
@@ -658,7 +794,7 @@ class AbstractWarehouse(ABC, Serializable):
             return de.c(inner_query, f)
 
         return self.db.execute(
-            select(*(field_to_expr(f) for f in fields)).order_by(
+            sa.select(*(field_to_expr(f) for f in fields)).order_by(
                 de.c(inner_query, "source"),
                 de.c(inner_query, "path"),
                 de.c(inner_query, "version"),
@@ -680,7 +816,7 @@ class AbstractWarehouse(ABC, Serializable):
             return dr.c(f)
 
         q = (
-            select(*(field_to_expr(f) for f in fields))
+            sa.select(*(field_to_expr(f) for f in fields))
             .where(
                 dr.c("path").like(f"{sql_escape_like(dirpath)}%"),
                 ~self.instr(pathfunc.name(dr.c("path")), "/"),
@@ -693,7 +829,7 @@ class AbstractWarehouse(ABC, Serializable):
     def size(
         self,
         dataset_rows: "DataTable",
-        node: Union[Node, dict[str, Any]],
+        node: Node | dict[str, Any],
         count_files: bool = False,
     ) -> tuple[int, int]:
         """
@@ -715,10 +851,10 @@ class AbstractWarehouse(ABC, Serializable):
         sub_glob = posixpath.join(path, "*")
         dr = dataset_rows
         selections: list[sa.ColumnElement] = [
-            func.sum(dr.c("size")),
+            sa.func.sum(dr.c("size")),
         ]
         if count_files:
-            selections.append(func.count())
+            selections.append(sa.func.count())
         results = next(
             self.db.execute(
                 dr.select(*selections).where(
@@ -735,10 +871,10 @@ class AbstractWarehouse(ABC, Serializable):
         self,
         dataset_rows: "DataTable",
         parent_path: str,
-        fields: Optional[Sequence[str]] = None,
-        type: Optional[str] = None,
+        fields: Sequence[str] | None = None,
+        type: str | None = None,
         conds=None,
-        order_by: Optional[Union[str, list[str]]] = None,
+        order_by: str | list[str] | None = None,
         include_subobjects: bool = True,
     ) -> sa.Select:
         if not conds:
@@ -776,7 +912,7 @@ class AbstractWarehouse(ABC, Serializable):
         self,
         dataset_rows: "DataTable",
         node: Node,
-        sort: Union[list[str], str, None] = None,
+        sort: list[str] | str | None = None,
         include_subobjects: bool = True,
     ) -> Iterator[NodeWithPath]:
         """
@@ -834,28 +970,33 @@ class AbstractWarehouse(ABC, Serializable):
     def create_udf_table(
         self,
         columns: Sequence["sa.Column"] = (),
-        name: Optional[str] = None,
-    ) -> "sa.Table":
+        name: str | None = None,
+    ) -> sa.Table:
         """
         Create a temporary table for storing custom signals generated by a UDF.
         SQLite TEMPORARY tables cannot be directly used as they are process-specific,
         and UDFs are run in other processes when run in parallel.
         """
+        columns = [
+            c
+            for c in columns
+            if c.name not in [col.name for col in self.dataset_row_cls.sys_columns()]
+        ]
         tbl = sa.Table(
             name or self.udf_table_name(),
             sa.MetaData(),
-            sa.Column("sys__id", Int, primary_key=True),
+            *self.dataset_row_cls.sys_columns(),
             *columns,
         )
-        self.db.create_table(tbl, if_not_exists=True)
+        self.db.create_table(tbl, if_not_exists=True, kind="udf")
         return tbl
 
     @abstractmethod
     def copy_table(
         self,
-        table: Table,
-        query: "Select",
-        progress_cb: Optional[Callable[[int], None]] = None,
+        table: sa.Table,
+        query: sa.Select,
+        progress_cb: Callable[[int], None] | None = None,
     ) -> None:
         """
         Copy the results of a query into a table.
@@ -868,13 +1009,15 @@ class AbstractWarehouse(ABC, Serializable):
         right: "_FromClauseArgument",
         onclause: "_OnClauseArgument",
         inner: bool = True,
-    ) -> "Select":
+        full: bool = False,
+        columns=None,
+    ) -> sa.Select:
         """
         Join two tables together.
         """
 
     @abstractmethod
-    def create_pre_udf_table(self, query: "Select") -> "Table":
+    def create_pre_udf_table(self, query: sa.Select) -> sa.Table:
         """
         Create a temporary table from a query for use in a UDF.
         """
@@ -899,16 +1042,10 @@ class AbstractWarehouse(ABC, Serializable):
         are cleaned up as soon as they are no longer needed.
         """
         to_drop = set(names)
-        with tqdm(
-            desc="Cleanup", unit=" tables", total=len(to_drop), leave=False
-        ) as pbar:
-            for name in to_drop:
-                self.db.drop_table(Table(name, self.db.metadata), if_exists=True)
-                pbar.update(1)
+        for name in to_drop:
+            self.db.drop_table(sa.Table(name, self.db.metadata), if_exists=True)
 
 
 def _random_string(length: int) -> str:
-    return "".join(
-        random.choice(string.ascii_letters + string.digits)  # noqa: S311
-        for i in range(length)
-    )
+    alphabet = string.ascii_letters + string.digits
+    return "".join(secrets.choice(alphabet) for _ in range(length))