pixeltable 0.4.18__py3-none-any.whl → 0.4.19__py3-none-any.whl

pixeltable/metadata/converters/util.py

@@ -1,6 +1,6 @@
 import copy
 import logging
-from typing import Any, Callable, Optional
+from typing import Any, Callable
 from uuid import UUID
 
 import sqlalchemy as sql
@@ -12,11 +12,11 @@ __logger = logging.getLogger('pixeltable')
 
 def convert_table_md(
     engine: sql.engine.Engine,
-    table_md_updater: Optional[Callable[[dict, UUID], None]] = None,
-    column_md_updater: Optional[Callable[[dict], None]] = None,
-    external_store_md_updater: Optional[Callable[[dict], None]] = None,
-    substitution_fn: Optional[Callable[[Optional[str], Any], Optional[tuple[Optional[str], Any]]]] = None,
-    table_modifier: Optional[Callable[[sql.Connection, UUID, dict, dict], None]] = None,
+    table_md_updater: Callable[[dict, UUID], None] | None = None,
+    column_md_updater: Callable[[dict], None] | None = None,
+    external_store_md_updater: Callable[[dict], None] | None = None,
+    substitution_fn: Callable[[str | None, Any], tuple[str | None, Any] | None] | None = None,
+    table_modifier: Callable[[sql.Connection, UUID, dict, dict], None] | None = None,
 ) -> None:
     """
     Converts schema.TableMd dicts based on the specified conversion functions.
@@ -80,9 +80,7 @@ def __update_external_store_md(table_md: dict, external_store_md_updater: Callab
         external_store_md_updater(store_md)
 
 
-def __substitute_md_rec(
-    md: Any, substitution_fn: Callable[[Optional[str], Any], Optional[tuple[Optional[str], Any]]]
-) -> Any:
+def __substitute_md_rec(md: Any, substitution_fn: Callable[[str | None, Any], tuple[str | None, Any] | None]) -> Any:
     if isinstance(md, dict):
         updated_dict: dict[str, Any] = {}
         for k, v in md.items():
@@ -110,8 +108,8 @@ def __substitute_md_rec(
 
 def convert_table_schema_version_md(
     engine: sql.engine.Engine,
-    table_schema_version_md_updater: Optional[Callable[[dict], None]] = None,
-    schema_column_updater: Optional[Callable[[dict], None]] = None,
+    table_schema_version_md_updater: Callable[[dict], None] | None = None,
+    schema_column_updater: Callable[[dict], None] | None = None,
 ) -> None:
     """
     Converts schema.TableSchemaVersionMd dicts based on the specified conversion functions.
@@ -150,7 +148,7 @@ def __update_schema_column(table_schema_version_md: dict, schema_column_updater:
 
 
 def convert_table_version_record(
-    engine: sql.engine.Engine, table_version_record_updater: Optional[Callable[[TableVersion], None]]
+    engine: sql.engine.Engine, table_version_record_updater: Callable[[TableVersion], None] | None
 ) -> None:
     with sql.orm.Session(engine, future=True) as session:
         for record in session.query(TableVersion).all():
@@ -159,7 +157,7 @@ def convert_table_version_record(
 
 
 def convert_table_schema_version_record(
-    engine: sql.engine.Engine, table_schema_version_record_updater: Optional[Callable[[TableSchemaVersion], None]]
+    engine: sql.engine.Engine, table_schema_version_record_updater: Callable[[TableSchemaVersion], None] | None
 ) -> None:
     with sql.orm.Session(engine, future=True) as session:
         for record in session.query(TableSchemaVersion).all():

pixeltable/metadata/schema.py

@@ -1,7 +1,8 @@
 import dataclasses
+import types
 import typing
 import uuid
-from typing import Any, NamedTuple, Optional, TypeVar, Union, get_type_hints
+from typing import Any, NamedTuple, TypeVar, Union, get_type_hints
 
 import sqlalchemy as sql
 from sqlalchemy import BigInteger, ForeignKey, Integer, LargeBinary, orm
@@ -29,8 +30,8 @@ def md_from_dict(data_class_type: type[T], data: Any) -> T:
     origin = typing.get_origin(data_class_type)
     if origin is not None:
         type_args = typing.get_args(data_class_type)
-        if origin is Union and type(None) in type_args:
-            # Handling Optional types
+        if (origin is Union or origin is types.UnionType) and type(None) in type_args:
+            # handling T | None, T | None
             non_none_args = [arg for arg in type_args if arg is not type(None)]
             assert len(non_none_args) == 1
             return md_from_dict(non_none_args[0], data) if data is not None else None
@@ -74,7 +75,7 @@ class SystemInfo(Base):
 @dataclasses.dataclass
 class DirMd:
     name: str
-    user: Optional[str]
+    user: str | None
     additional_md: dict[str, Any]
 
 
@@ -103,20 +104,20 @@ class ColumnMd:
 
     id: int
     schema_version_add: int
-    schema_version_drop: Optional[int]
+    schema_version_drop: int | None
     col_type: dict
 
     # if True, is part of the primary key
     is_pk: bool
 
     # if set, this is a computed column
-    value_expr: Optional[dict]
+    value_expr: dict | None
 
     # if True, the column is present in the stored table
-    stored: Optional[bool]
+    stored: bool | None
 
     # If present, the URI for the destination for column values
-    destination: Optional[str] = None
+    destination: str | None = None
 
 
 @dataclasses.dataclass
@@ -132,13 +133,13 @@ class IndexMd:
     index_val_col_id: int  # column holding the values to be indexed
     index_val_undo_col_id: int  # column holding index values for deleted rows
     schema_version_add: int
-    schema_version_drop: Optional[int]
+    schema_version_drop: int | None
     class_fqn: str
     init_args: dict[str, Any]
 
 
 # a stored table version path is a list of (table id as str, effective table version)
-TableVersionPath = list[tuple[str, Optional[int]]]
+TableVersionPath = list[tuple[str, int | None]]
 
 
 @dataclasses.dataclass
@@ -150,16 +151,16 @@ class ViewMd:
     base_versions: TableVersionPath
 
     # filter predicate applied to the base table; view-only
-    predicate: Optional[dict[str, Any]]
+    predicate: dict[str, Any] | None
 
     # sampling predicate applied to the base table; view-only
-    sample_clause: Optional[dict[str, Any]]
+    sample_clause: dict[str, Any] | None
 
     # ComponentIterator subclass; only for component views
-    iterator_class_fqn: Optional[str]
+    iterator_class_fqn: str | None
 
     # args to pass to the iterator class constructor; only for component views
-    iterator_args: Optional[dict[str, Any]]
+    iterator_args: dict[str, Any] | None
 
 
 @dataclasses.dataclass
@@ -168,7 +169,7 @@ class TableMd:
     name: str
     is_replica: bool
 
-    user: Optional[str]
+    user: str | None
 
     # monotonically increasing w/in Table for both data and schema changes, starting at 0
     current_version: int
@@ -194,7 +195,7 @@ class TableMd:
 
     column_md: dict[int, ColumnMd]  # col_id -> ColumnMd
     index_md: dict[int, IndexMd]  # index_id -> IndexMd
-    view_md: Optional[ViewMd]
+    view_md: ViewMd | None
     additional_md: dict[str, Any]
 
     has_pending_ops: bool = False
@@ -245,8 +246,8 @@ class TableVersionMd:
     created_at: float  # time.time()
     version: int
     schema_version: int
-    user: Optional[str] = None  # User that created this version
-    update_status: Optional[UpdateStatus] = None  # UpdateStatus of the change that created this version
+    user: str | None = None  # User that created this version
+    update_status: UpdateStatus | None = None  # UpdateStatus of the change that created this version
     # A version fragment cannot be queried or instantiated via get_table(). A fragment represents a version of a
     # replica table that has incomplete data, and exists only to provide base table support for a dependent view.
     is_fragment: bool = False
@@ -273,7 +274,7 @@ class SchemaColumn:
 
     # media validation strategy of this particular media column; if not set, TableMd.media_validation applies
     # stores column.MediaValiation.name.lower()
-    media_validation: Optional[str]
+    media_validation: str | None
 
 
 @dataclasses.dataclass
@@ -284,7 +285,7 @@ class TableSchemaVersionMd:
 
     tbl_id: str  # uuid.UUID
     schema_version: int
-    preceding_schema_version: Optional[int]
+    preceding_schema_version: int | None
     columns: dict[int, SchemaColumn]  # col_id -> SchemaColumn
     num_retained_versions: int
     comment: str
@@ -347,7 +348,7 @@ class Function(Base):
     )
     dir_id: orm.Mapped[uuid.UUID] = orm.mapped_column(UUID(as_uuid=True), ForeignKey('dirs.id'), nullable=True)
     md: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False)  # FunctionMd
-    binary_obj: orm.Mapped[Optional[bytes]] = orm.mapped_column(LargeBinary, nullable=True)
+    binary_obj: orm.Mapped[bytes | None] = orm.mapped_column(LargeBinary, nullable=True)
 
 
 class FullTableMd(NamedTuple):

pixeltable/metadata/utils.py

@@ -1,14 +1,12 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from pixeltable.metadata import schema
 
 
 class MetadataUtils:
     @classmethod
     def _diff_md(
-        cls, old_md: Optional[dict[int, schema.SchemaColumn]], new_md: Optional[dict[int, schema.SchemaColumn]]
+        cls, old_md: dict[int, schema.SchemaColumn] | None, new_md: dict[int, schema.SchemaColumn] | None
     ) -> str:
         """Return a string reporting the differences in a specific entry in two dictionaries
 
@@ -43,9 +41,7 @@ class MetadataUtils:
         return r
 
     @classmethod
-    def _create_md_change_dict(
-        cls, md_list: Optional[list[tuple[int, dict[int, schema.SchemaColumn]]]]
-    ) -> dict[int, str]:
+    def _create_md_change_dict(cls, md_list: list[tuple[int, dict[int, schema.SchemaColumn]]] | None) -> dict[int, str]:
         """Return a dictionary of schema changes by version
         Args:
             md_list: a list of tuples, each containing a version number and a metadata dictionary.

pixeltable/mypy/mypy_plugin.py

@@ -1,4 +1,4 @@
-from typing import Callable, ClassVar, Optional
+from typing import Callable, ClassVar
 
 from mypy import nodes
 from mypy.plugin import AnalyzeTypeContext, ClassDefContext, FunctionContext, MethodSigContext, Plugin
@@ -26,21 +26,21 @@ class PxtPlugin(Plugin):
     }
     __FULLNAME_MAP: ClassVar[dict] = {f'{k.__module__}.{k.__name__}': v for k, v in __TYPE_MAP.items()}
 
-    def get_function_hook(self, fullname: str) -> Optional[Callable[[FunctionContext], Type]]:
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
         return adjust_uda_type
 
-    def get_type_analyze_hook(self, fullname: str) -> Optional[Callable[[AnalyzeTypeContext], Type]]:
+    def get_type_analyze_hook(self, fullname: str) -> Callable[[AnalyzeTypeContext], Type] | None:
         if fullname in self.__FULLNAME_MAP:
             subst_name = self.__FULLNAME_MAP[fullname]
             return lambda ctx: adjust_pxt_type(ctx, subst_name)
         return None
 
-    def get_method_signature_hook(self, fullname: str) -> Optional[Callable[[MethodSigContext], FunctionLike]]:
+    def get_method_signature_hook(self, fullname: str) -> Callable[[MethodSigContext], FunctionLike] | None:
         if fullname in (self.__ADD_COLUMN_FULLNAME, self.__ADD_COMPUTED_COLUMN_FULLNAME):
             return adjust_kwargs
         return None
 
-    def get_class_decorator_hook_2(self, fullname: str) -> Optional[Callable[[ClassDefContext], bool]]:
+    def get_class_decorator_hook_2(self, fullname: str) -> Callable[[ClassDefContext], bool] | None:
         if fullname == self.__UDA_FULLNAME:
             return adjust_uda_methods
         return None

pixeltable/plan.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import dataclasses
 import enum
 from textwrap import dedent
-from typing import Any, Iterable, Literal, Optional, Sequence, cast
+from typing import Any, Iterable, Literal, Sequence, cast
 from uuid import UUID
 
 import pgvector.sqlalchemy  # type: ignore[import-untyped]
@@ -66,7 +66,7 @@ class JoinClause:
     """Corresponds to a single 'JOIN ... ON (...)' clause in a SELECT statement; excludes the joined table."""
 
     join_type: JoinType
-    join_predicate: Optional[exprs.Expr]  # None for join_type == CROSS
+    join_predicate: exprs.Expr | None  # None for join_type == CROSS
 
 
 @dataclasses.dataclass
@@ -86,12 +86,12 @@ class FromClause:
 class SampleClause:
     """Defines a sampling clause for a table."""
 
-    version: Optional[int]
-    n: Optional[int]
-    n_per_stratum: Optional[int]
-    fraction: Optional[float]
-    seed: Optional[int]
-    stratify_exprs: Optional[list[exprs.Expr]]
+    version: int | None
+    n: int | None
+    n_per_stratum: int | None
+    fraction: float | None
+    seed: int | None
+    stratify_exprs: list[exprs.Expr] | None
 
     # The version of the hashing algorithm used for ordering and fractional sampling.
     CURRENT_VERSION = 1
@@ -162,19 +162,19 @@ class Analyzer:
     from_clause: FromClause
     all_exprs: list[exprs.Expr]  # union of all exprs, aside from sql_where_clause
     select_list: list[exprs.Expr]
-    group_by_clause: Optional[list[exprs.Expr]]  # None for non-aggregate queries; [] for agg query w/o grouping
+    group_by_clause: list[exprs.Expr] | None  # None for non-aggregate queries; [] for agg query w/o grouping
     grouping_exprs: list[exprs.Expr]  # [] for non-aggregate queries or agg query w/o grouping
     order_by_clause: OrderByClause
     stratify_exprs: list[exprs.Expr]  # [] if no stratiifcation is required
-    sample_clause: Optional[SampleClause]  # None if no sampling clause is present
+    sample_clause: SampleClause | None  # None if no sampling clause is present
 
     sql_elements: exprs.SqlElementCache
 
     # Where clause of the Select stmt of the SQL scan
-    sql_where_clause: Optional[exprs.Expr]
+    sql_where_clause: exprs.Expr | None
 
     # filter predicate applied to output rows of the SQL scan
-    filter: Optional[exprs.Expr]
+    filter: exprs.Expr | None
 
     agg_fn_calls: list[exprs.FunctionCall]  # grouping aggregation (ie, not window functions)
     window_fn_calls: list[exprs.FunctionCall]
@@ -184,10 +184,10 @@ class Analyzer:
         self,
         from_clause: FromClause,
         select_list: Sequence[exprs.Expr],
-        where_clause: Optional[exprs.Expr] = None,
-        group_by_clause: Optional[list[exprs.Expr]] = None,
-        order_by_clause: Optional[list[tuple[exprs.Expr, bool]]] = None,
-        sample_clause: Optional[SampleClause] = None,
+        where_clause: exprs.Expr | None = None,
+        group_by_clause: list[exprs.Expr] | None = None,
+        order_by_clause: list[tuple[exprs.Expr, bool]] | None = None,
+        sample_clause: SampleClause | None = None,
     ):
         if order_by_clause is None:
             order_by_clause = []
@@ -330,7 +330,7 @@ class Analyzer:
         row_builder.set_slot_idxs(self.agg_fn_calls)
         row_builder.set_slot_idxs(self.agg_order_by)
 
-    def get_window_fn_ob_clause(self) -> Optional[OrderByClause]:
+    def get_window_fn_ob_clause(self) -> OrderByClause | None:
         clause: list[OrderByClause] = []
         for fn_call in self.window_fn_calls:
             # window functions require ordering by the group_by/order_by clauses
@@ -348,7 +348,7 @@ class Analyzer:
 class Planner:
     # TODO: create an exec.CountNode and change this to create_count_plan()
     @classmethod
-    def create_count_stmt(cls, tbl: catalog.TableVersionPath, where_clause: Optional[exprs.Expr] = None) -> sql.Select:
+    def create_count_stmt(cls, tbl: catalog.TableVersionPath, where_clause: exprs.Expr | None = None) -> sql.Select:
         stmt = sql.select(sql.func.count().label('all_count'))
         refd_tbl_ids: set[UUID] = set()
         if where_clause is not None:
@@ -406,7 +406,7 @@ class Planner:
         return plan
 
     @classmethod
-    def rowid_columns(cls, target: TableVersionHandle, num_rowid_cols: Optional[int] = None) -> list[exprs.Expr]:
+    def rowid_columns(cls, target: TableVersionHandle, num_rowid_cols: int | None = None) -> list[exprs.Expr]:
         """Return list of RowidRef for the given number of associated rowids"""
         if num_rowid_cols is None:
             num_rowid_cols = target.get().num_rowid_columns()
@@ -447,7 +447,7 @@ class Planner:
         tbl: catalog.TableVersionPath,
         update_targets: dict[catalog.Column, exprs.Expr],
         recompute_targets: list[catalog.Column],
-        where_clause: Optional[exprs.Expr],
+        where_clause: exprs.Expr | None,
         cascade: bool,
     ) -> tuple[exec.ExecNode, list[str], list[catalog.Column]]:
         """Creates a plan to materialize updated rows.
@@ -477,7 +477,8 @@ class Planner:
         else:
             recomputed_cols = target.get_dependent_columns(updated_cols) if cascade else set()
         # regardless of cascade, we need to update all indices on any updated/recomputed column
-        idx_val_cols = target.get_idx_val_columns(set(updated_cols) | recomputed_cols)
+        modified_base_cols = [c for c in set(updated_cols) | recomputed_cols if c.get_tbl().id == target.id]
+        idx_val_cols = target.get_idx_val_columns(modified_base_cols)
         recomputed_cols.update(idx_val_cols)
         # we only need to recompute stored columns (unstored ones are substituted away)
         recomputed_cols = {c for c in recomputed_cols if c.is_stored}
@@ -487,7 +488,7 @@ class Planner:
         # our query plan
         # - evaluates the update targets and recomputed columns
         # - copies all other stored columns
-        recomputed_base_cols = {col for col in recomputed_cols if col.tbl.id == tbl.tbl_version.id}
+        recomputed_base_cols = {col for col in recomputed_cols if col.get_tbl().id == tbl.tbl_version.id}
         copied_cols = [
             col
             for col in target.cols_by_id.values()
@@ -522,7 +523,7 @@ class Planner:
         plan = cls._add_save_node(plan)
 
         recomputed_user_cols = [c for c in recomputed_cols if c.name is not None]
-        return plan, [f'{c.tbl.name}.{c.name}' for c in updated_cols + recomputed_user_cols], recomputed_user_cols
+        return plan, [f'{c.get_tbl().name}.{c.name}' for c in updated_cols + recomputed_user_cols], recomputed_user_cols
 
     @classmethod
     def __check_valid_columns(
@@ -647,11 +648,12 @@ class Planner:
         updated_cols = batch[0].keys() - target.primary_key_columns()
         recomputed_cols = target.get_dependent_columns(updated_cols) if cascade else set()
         # regardless of cascade, we need to update all indices on any updated column
-        idx_val_cols = target.get_idx_val_columns(updated_cols)
+        modified_base_cols = [c for c in set(updated_cols) | recomputed_cols if c.get_tbl().id == target.id]
+        idx_val_cols = target.get_idx_val_columns(modified_base_cols)
         recomputed_cols.update(idx_val_cols)
         # we only need to recompute stored columns (unstored ones are substituted away)
         recomputed_cols = {c for c in recomputed_cols if c.is_stored}
-        recomputed_base_cols = {col for col in recomputed_cols if col.tbl.id == target.id}
+        recomputed_base_cols = {col for col in recomputed_cols if col.get_tbl().id == target.id}
         copied_cols = [
             col
             for col in target.cols_by_id.values()
@@ -844,7 +846,7 @@ class Planner:
                 raise excs.Error(f'Join predicate {join_clause.join_predicate} not expressible in SQL')
 
     @classmethod
-    def _create_combined_ordering(cls, analyzer: Analyzer, verify_agg: bool) -> Optional[OrderByClause]:
+    def _create_combined_ordering(cls, analyzer: Analyzer, verify_agg: bool) -> OrderByClause | None:
         """Verify that the various ordering requirements don't conflict and return a combined ordering"""
         ob_clauses: list[OrderByClause] = [analyzer.order_by_clause.copy()]
 
@@ -980,7 +982,7 @@ class Planner:
         analyzer: Analyzer,
         eval_ctx: exprs.RowBuilder.EvalCtx,
         columns: list[catalog.Column] | None = None,
-        limit: Optional[exprs.Expr] = None,
+        limit: exprs.Expr | None = None,
         with_pk: bool = False,
         exact_version_only: list[catalog.TableVersionHandle] | None = None,
     ) -> exec.ExecNode:
@@ -1057,7 +1059,7 @@ class Planner:
                 tbl,
                 row_builder,
                 select_list=tbl_scan_exprs,
-                columns=[c for c in columns if c.tbl.id == tbl.tbl_id],
+                columns=[c for c in columns if c.get_tbl().id == tbl.tbl_id],
                 set_pk=with_pk,
                 cell_md_col_refs=cls._cell_md_col_refs(tbl_scan_exprs),
                 exact_version_only=exact_version_only,

pixeltable/share/packager.py

@@ -7,7 +7,7 @@ import urllib.parse
 import urllib.request
 import uuid
 from pathlib import Path
-from typing import Any, Iterator, Optional
+from typing import Any, Iterator
 from uuid import UUID
 
 import more_itertools
@@ -57,7 +57,7 @@ class TablePackager:
     preview_header: dict[str, str]
     preview: list[list[Any]]
 
-    def __init__(self, table: catalog.Table, additional_md: Optional[dict[str, Any]] = None) -> None:
+    def __init__(self, table: catalog.Table, additional_md: dict[str, Any] | None = None) -> None:
         self.table = table
         self.tmp_dir = TempStore.create_path()
         self.media_files = {}
@@ -342,11 +342,11 @@ class TablePackager:
             scaled_img.save(buffer, 'webp')
             return base64.b64encode(buffer.getvalue()).decode()
 
-    def __encode_video(self, video_path: str) -> Optional[str]:
+    def __encode_video(self, video_path: str) -> str | None:
         thumb = Formatter.extract_first_video_frame(video_path)
         return self.__encode_image(thumb) if thumb is not None else None
 
-    def __encode_document(self, doc_path: str) -> Optional[str]:
+    def __encode_document(self, doc_path: str) -> str | None:
         thumb = Formatter.make_document_thumbnail(doc_path)
         return self.__encode_image(thumb) if thumb is not None else None
 
@@ -364,11 +364,11 @@ class TableRestorer:
     """
 
     tbl_path: str
-    md: Optional[dict[str, Any]]
+    md: dict[str, Any] | None
     tmp_dir: Path
     media_files: dict[str, str]  # Mapping from pxtmedia:// URLs to local file:// URLs
 
-    def __init__(self, tbl_path: str, md: Optional[dict[str, Any]] = None) -> None:
+    def __init__(self, tbl_path: str, md: dict[str, Any] | None = None) -> None:
         self.tbl_path = tbl_path
         self.md = md
         self.tmp_dir = TempStore.create_path()
@@ -710,7 +710,7 @@ class TableRestorer:
         self,
         val: Any,
         sql_type: sql.types.TypeEngine[Any],
-        col: Optional[catalog.Column],
+        col: catalog.Column | None,
         is_media_col: bool,
         is_cellmd_col: bool,
     ) -> Any:

pixeltable/share/publish.py

@@ -3,7 +3,7 @@ import sys
 import urllib.parse
 import urllib.request
 from pathlib import Path
-from typing import Literal, Optional
+from typing import Literal
 
 import requests
 from requests.adapters import HTTPAdapter
@@ -159,7 +159,7 @@ def _download_bundle_from_s3(parsed_location: urllib.parse.ParseResult, bundle_f
 
 
 def _create_retry_session(
-    max_retries: int = 3, backoff_factor: float = 1.0, status_forcelist: Optional[list] = None
+    max_retries: int = 3, backoff_factor: float = 1.0, status_forcelist: list | None = None
 ) -> requests.Session:
     """Create a requests session with retry configuration"""
     if status_forcelist is None:
@@ -222,7 +222,7 @@ def _upload_to_presigned_url(file_path: Path, url: str, max_retries: int = 3) ->
 
 
 def _download_from_presigned_url(
-    url: str, output_path: Path, headers: Optional[dict[str, str]] = None, max_retries: int = 3
+    url: str, output_path: Path, headers: dict[str, str] | None = None, max_retries: int = 3
 ) -> None:
     """Download file with progress bar and retries"""
     session = _create_retry_session(max_retries=max_retries)