meerschaum 2.7.0rc1__py3-none-any.whl → 2.7.1__py3-none-any.whl

meerschaum/utils/dtypes/__init__.py

@@ -231,11 +231,11 @@ def attempt_cast_to_bytes(value: Any) -> Any:
     """
     Given a value, attempt to coerce it into a bytestring.
     """
-    if isinstance(value, uuid.UUID):
+    if isinstance(value, bytes):
         return value
     try:
         return (
-            deserialize_base64(str(value))
+            deserialize_bytes_string(str(value))
             if not value_is_null(value)
             else None
         )
@@ -382,9 +382,55 @@ def serialize_bytes(data: bytes) -> str:
     return base64.b64encode(data).decode('utf-8')
 
 
+def deserialize_bytes_string(data: str | None, force_hex: bool = False) -> bytes | None:
+    """
+    Given a serialized ASCII string of bytes data, return the original bytes.
+    The input data may either be base64- or hex-encoded.
+
+    Parameters
+    ----------
+    data: str | None
+        The string to be deserialized into bytes.
+        May be base64- or hex-encoded (prefixed with `'\\x'`).
+
+    force_hex: bool = False
+        If `True`, treat the input string as hex-encoded.
+        If `data` does not begin with the prefix `'\\x'`, set `force_hex` to `True`.
+        This will still strip the leading `'\\x'` prefix if present.
+
+    Returns
+    -------
+    The original bytes used to produce the encoded string `data`.
+    """
+    if not isinstance(data, str) and value_is_null(data):
+        return data
+
+    import binascii
+    import base64
+
+    is_hex = force_hex or data.startswith('\\x')
+
+    if is_hex:
+        if data.startswith('\\x'):
+            data = data[2:]
+        return binascii.unhexlify(data)
+
+    return base64.b64decode(data)
+
+
 def deserialize_base64(data: str) -> bytes:
     """
     Return the original bytestring from the given base64-encoded string.
     """
     import base64
     return base64.b64decode(data)
+
+
+def encode_bytes_for_bytea(data: bytes, with_prefix: bool = True) -> str | None:
+    """
+    Return the given bytes as a hex string for PostgreSQL's `BYTEA` type.
+    """
+    import binascii
+    if not isinstance(data, bytes) and value_is_null(data):
+        return data
+    return ('\\x' if with_prefix else '') + binascii.hexlify(data).decode('utf-8')

meerschaum/utils/dtypes/sql.py

@@ -13,9 +13,8 @@ NUMERIC_PRECISION_FLAVORS: Dict[str, Tuple[int, int]] = {
     'mariadb': (38, 20),
     'mysql': (38, 20),
     'mssql': (28, 10),
-    'duckdb': (15, 3),
-    'sqlite': (15, 4),
 }
+NUMERIC_AS_TEXT_FLAVORS = {'sqlite', 'duckdb'}
 TIMEZONE_NAIVE_FLAVORS = {'oracle', 'mysql', 'mariadb'}
 
 ### MySQL doesn't allow for casting as BIGINT, so this is a workaround.
@@ -102,6 +101,10 @@ DB_TO_PD_DTYPES: Dict[str, Union[str, Dict[str, str]]] = {
     'JSONB': 'json',
     'UUID': 'uuid',
     'UNIQUEIDENTIFIER': 'uuid',
+    'BYTEA': 'bytes',
+    'BLOB': 'bytes',
+    'VARBINARY': 'bytes',
+    'VARBINARY(MAX)': 'bytes',
     'substrings': {
         'CHAR': 'string[pyarrow]',
         'TIMESTAMP': 'datetime64[ns]',
@@ -114,6 +117,9 @@ DB_TO_PD_DTYPES: Dict[str, Union[str, Dict[str, str]]] = {
         'INT': 'int64[pyarrow]',
         'BOOL': 'bool[pyarrow]',
         'JSON': 'json',
+        'BYTE': 'bytes',
+        'LOB': 'bytes',
+        'BINARY': 'bytes',
     },
     'default': 'object',
 }
@@ -256,8 +262,8 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
         'mysql': f'DECIMAL{NUMERIC_PRECISION_FLAVORS["mysql"]}',
         'mssql': f'NUMERIC{NUMERIC_PRECISION_FLAVORS["mssql"]}',
         'oracle': 'NUMBER',
-        'sqlite': f'DECIMAL{NUMERIC_PRECISION_FLAVORS["sqlite"]}',
-        'duckdb': 'NUMERIC',
+        'sqlite': 'TEXT',
+        'duckdb': 'TEXT',
         'citus': 'NUMERIC',
         'cockroachdb': 'NUMERIC',
         'default': 'NUMERIC',
@@ -415,7 +421,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
         'mysql': 'Numeric',
         'mssql': 'Numeric',
         'oracle': 'Numeric',
-        'sqlite': 'Numeric',
+        'sqlite': 'UnicodeText',
         'duckdb': 'Numeric',
         'citus': 'Numeric',
         'cockroachdb': 'Numeric',
@@ -528,7 +534,7 @@ def get_db_type_from_pd_type(
     """
     from meerschaum.utils.warnings import warn
     from meerschaum.utils.packages import attempt_import
-    from meerschaum.utils.dtypes import are_dtypes_equal
+    from meerschaum.utils.dtypes import are_dtypes_equal, MRSM_ALIAS_DTYPES
     from meerschaum.utils.misc import parse_arguments_str
     sqlalchemy_types = attempt_import('sqlalchemy.types')
 
@@ -538,6 +544,9 @@ def get_db_type_from_pd_type(
         else PD_TO_SQLALCHEMY_DTYPES_FLAVORS
     )
 
+    if pd_type in MRSM_ALIAS_DTYPES:
+        pd_type = MRSM_ALIAS_DTYPES[pd_type]
+
     ### Check whether we are able to match this type (e.g. pyarrow support).
     found_db_type = False
     if pd_type not in types_registry:
@@ -594,7 +603,6 @@ def get_db_type_from_pd_type(
         return cls(*cls_args, **cls_kwargs)
 
     if 'numeric' in db_type.lower():
-        numeric_type_str = PD_TO_DB_DTYPES_FLAVORS['numeric'].get(flavor, 'NUMERIC')
         if flavor not in NUMERIC_PRECISION_FLAVORS:
             return sqlalchemy_types.Numeric
         precision, scale = NUMERIC_PRECISION_FLAVORS[flavor]

meerschaum/utils/sql.py

@@ -7,6 +7,7 @@ Flavor-specific SQL tools.
 """
 
 from __future__ import annotations
+
 from datetime import datetime, timezone, timedelta
 import meerschaum as mrsm
 from meerschaum.utils.typing import Optional, Dict, Any, Union, List, Iterable, Tuple
@@ -50,10 +51,12 @@ update_queries = {
         {sets_subquery_none}
         FROM {target_table_name} AS t
         INNER JOIN (SELECT DISTINCT {patch_cols_str} FROM {patch_table_name}) AS p
-            ON {and_subquery_t}
+            ON
+                {and_subquery_t}
         WHERE
             {and_subquery_f}
-            AND {date_bounds_subquery}
+            AND
+            {date_bounds_subquery}
     """,
     'timescaledb-upsert': """
         INSERT INTO {target_table_name} ({patch_cols_str})
@@ -82,9 +85,11 @@ update_queries = {
     'mysql': """
         UPDATE {target_table_name} AS f
         JOIN (SELECT DISTINCT {patch_cols_str} FROM {patch_table_name}) AS p
-        ON {and_subquery_f}
+        ON
+            {and_subquery_f}
         {sets_subquery_f}
-        WHERE {date_bounds_subquery}
+        WHERE
+            {date_bounds_subquery}
     """,
     'mysql-upsert': """
         INSERT {ignore}INTO {target_table_name} ({patch_cols_str})
@@ -96,9 +101,11 @@ update_queries = {
     'mariadb': """
         UPDATE {target_table_name} AS f
         JOIN (SELECT DISTINCT {patch_cols_str} FROM {patch_table_name}) AS p
-        ON {and_subquery_f}
+        ON
+            {and_subquery_f}
         {sets_subquery_f}
-        WHERE {date_bounds_subquery}
+        WHERE
+            {date_bounds_subquery}
     """,
     'mariadb-upsert': """
         INSERT {ignore}INTO {target_table_name} ({patch_cols_str})
@@ -111,8 +118,10 @@ update_queries = {
         {with_temp_date_bounds}
         MERGE {target_table_name} f
             USING (SELECT {patch_cols_str} FROM {patch_table_name}) p
-            ON {and_subquery_f}
-            AND {date_bounds_subquery}
+            ON
+                {and_subquery_f}
+            AND
+                {date_bounds_subquery}
         WHEN MATCHED THEN
             UPDATE
             {sets_subquery_none};
@@ -123,9 +132,10 @@ update_queries = {
         {with_temp_date_bounds}
         MERGE {target_table_name} f
             USING (SELECT {patch_cols_str} FROM {patch_table_name}) p
-            ON {and_subquery_f}
-            AND {date_bounds_subquery}
-        {when_matched_update_sets_subquery_none}
+            ON
+                {and_subquery_f}
+            AND
+                {date_bounds_subquery}{when_matched_update_sets_subquery_none}
         WHEN NOT MATCHED THEN
             INSERT ({patch_cols_str})
             VALUES ({patch_cols_prefixed_str});
@@ -134,14 +144,27 @@ update_queries = {
     ],
     'oracle': """
         MERGE INTO {target_table_name} f
-            USING (SELECT DISTINCT {patch_cols_str} FROM {patch_table_name}) p
+            USING (SELECT {patch_cols_str} FROM {patch_table_name}) p
             ON (
                 {and_subquery_f}
-                AND {date_bounds_subquery}
+                AND
+                {date_bounds_subquery}
             )
-        WHEN MATCHED THEN
-            UPDATE
-            {sets_subquery_none}
+            WHEN MATCHED THEN
+                UPDATE
+                {sets_subquery_none}
+    """,
+    'oracle-upsert': """
+        MERGE INTO {target_table_name} f
+            USING (SELECT {patch_cols_str} FROM {patch_table_name}) p
+            ON (
+                {and_subquery_f}
+                AND
+                {date_bounds_subquery}
+            ){when_matched_update_sets_subquery_none}
+            WHEN NOT MATCHED THEN
+                INSERT ({patch_cols_str})
+                VALUES ({patch_cols_prefixed_str})
     """,
     'sqlite-upsert': """
         INSERT INTO {target_table_name} ({patch_cols_str})
@@ -329,7 +352,11 @@ columns_indices_queries = {
             CASE
                 WHEN kc.type = 'PK' THEN 'PRIMARY KEY'
                 ELSE 'INDEX'
-            END AS [index_type]
+            END AS [index_type],
+            CASE
+                WHEN i.type = 1 THEN CAST(1 AS BIT)
+                ELSE CAST(0 AS BIT)
+            END AS [clustered]
         FROM
             sys.schemas s
         INNER JOIN sys.tables t
@@ -495,7 +522,8 @@ def dateadd_str(
     flavor: str = 'postgresql',
     datepart: str = 'day',
     number: Union[int, float] = 0,
-    begin: Union[str, datetime, int] = 'now'
+    begin: Union[str, datetime, int] = 'now',
+    db_type: Optional[str] = None,
 ) -> str:
     """
     Generate a `DATEADD` clause depending on database flavor.
@@ -534,6 +562,10 @@ def dateadd_str(
     begin: Union[str, datetime], default `'now'`
         Base datetime to which to add dateparts.
 
+    db_type: Optional[str], default None
+        If provided, cast the datetime string as the type.
+        Otherwise, infer this from the input datetime value.
+
     Returns
     -------
     The appropriate `DATEADD` string for the corresponding database flavor.
@@ -545,7 +577,7 @@ def dateadd_str(
     ...     begin = datetime(2022, 1, 1, 0, 0),
     ...     number = 1,
     ... )
-    "DATEADD(day, 1, CAST('2022-01-01 00:00:00' AS DATETIME))"
+    "DATEADD(day, 1, CAST('2022-01-01 00:00:00' AS DATETIME2))"
     >>> dateadd_str(
     ...     flavor = 'postgresql',
     ...     begin = datetime(2022, 1, 1, 0, 0),
@@ -588,7 +620,7 @@ def dateadd_str(
         )
 
     dt_is_utc = begin_time.tzinfo is not None if begin_time is not None else '+' in str(begin)
-    db_type = get_db_type_from_pd_type(
+    db_type = db_type or get_db_type_from_pd_type(
         ('datetime64[ns, UTC]' if dt_is_utc else 'datetime64[ns]'),
         flavor=flavor,
     )
@@ -713,7 +745,7 @@ def get_distinct_col_count(
     result = connector.value(_meta_query, debug=debug)
     try:
         return int(result)
-    except Exception as e:
+    except Exception:
         return None
 
 
@@ -723,12 +755,15 @@ def sql_item_name(item: str, flavor: str, schema: Optional[str] = None) -> str:
 
     Parameters
     ----------
-    item: str :
+    item: str
         The database item (table, view, etc.) in need of quotes.
         
-    flavor: str :
+    flavor: str
         The database flavor (`'postgresql'`, `'mssql'`, `'sqllite'`, etc.).
 
+    schema: Optional[str], default None
+        If provided, prefix the table name with the schema.
+
     Returns
     -------
     A `str` which contains the input `item` wrapped in the corresponding escape characters.
@@ -760,6 +795,8 @@ def sql_item_name(item: str, flavor: str, schema: Optional[str] = None) -> str:
     ### NOTE: SQLite does not support schemas.
     if flavor == 'sqlite':
         schema = None
+    elif flavor == 'mssql' and str(item).startswith('#'):
+        schema = None
 
     schema_prefix = (
         (wrappers[0] + schema + wrappers[1] + '.')
@@ -1115,6 +1152,7 @@ def get_table_cols_types(
     -------
     A dictionary mapping column names to data types.
     """
+    import textwrap
     from meerschaum.connectors import SQLConnector
     sqlalchemy = mrsm.attempt_import('sqlalchemy')
     flavor = flavor or getattr(connectable, 'flavor', None)
@@ -1140,7 +1178,7 @@ def get_table_cols_types(
     )
 
     cols_types_query = sqlalchemy.text(
-        columns_types_queries.get(
+        textwrap.dedent(columns_types_queries.get(
             flavor,
             columns_types_queries['default']
         ).format(
@@ -1151,7 +1189,7 @@ def get_table_cols_types(
             table_upper=table_upper,
             table_upper_trunc=table_upper_trunc,
             db_prefix=db_prefix,
-        )
+        )).lstrip().rstrip()
     )
 
     cols = ['database', 'schema', 'table', 'column', 'type']
@@ -1265,6 +1303,7 @@ def get_table_cols_indices(
     -------
     A dictionary mapping column names to a list of indices.
     """
+    import textwrap
     from collections import defaultdict
     from meerschaum.connectors import SQLConnector
     sqlalchemy = mrsm.attempt_import('sqlalchemy')
@@ -1291,7 +1330,7 @@ def get_table_cols_indices(
     )
 
     cols_indices_query = sqlalchemy.text(
-        columns_indices_queries.get(
+        textwrap.dedent(columns_indices_queries.get(
             flavor,
             columns_indices_queries['default']
         ).format(
@@ -1303,10 +1342,12 @@ def get_table_cols_indices(
             table_upper_trunc=table_upper_trunc,
             db_prefix=db_prefix,
             schema=schema,
-        )
+        )).lstrip().rstrip()
     )
 
     cols = ['database', 'schema', 'table', 'column', 'index', 'index_type']
+    if flavor == 'mssql':
+        cols.append('clustered')
     result_cols_ix = dict(enumerate(cols))
 
     debug_kwargs = {'debug': debug} if isinstance(connectable, SQLConnector) else {}
@@ -1347,7 +1388,6 @@ def get_table_cols_indices(
                 )
             )
         ]
-
         ### NOTE: This may return incorrect columns if the schema is not explicitly stated.
         if cols_types_docs and not cols_types_docs_filtered:
             cols_types_docs_filtered = cols_types_docs
@@ -1363,12 +1403,13 @@ def get_table_cols_indices(
                     else doc['column']
                 )
             )
-            cols_indices[col].append(
-                {
-                    'name': doc.get('index', None),
-                    'type': doc.get('index_type', None),
-                }
-            )
+            index_doc = {
+                'name': doc.get('index', None),
+                'type': doc.get('index_type', None)
+            }
+            if flavor == 'mssql':
+                index_doc['clustered'] = doc.get('clustered', None)
+            cols_indices[col].append(index_doc)
 
         return dict(cols_indices)
     except Exception as e:
@@ -1438,9 +1479,11 @@ def get_update_queries(
     -------
     A list of query strings to perform the update operation.
     """
+    import textwrap
     from meerschaum.connectors import SQLConnector
     from meerschaum.utils.debug import dprint
-    from meerschaum.utils.dtypes.sql import DB_FLAVORS_CAST_DTYPES
+    from meerschaum.utils.dtypes import are_dtypes_equal
+    from meerschaum.utils.dtypes.sql import DB_FLAVORS_CAST_DTYPES, get_pd_type_from_db_type
     flavor = flavor or (connectable.flavor if isinstance(connectable, SQLConnector) else None)
     if not flavor:
         raise ValueError("Provide a flavor if using a SQLAlchemy session.")
@@ -1533,21 +1576,35 @@ def get_update_queries(
     def sets_subquery(l_prefix: str, r_prefix: str):
         if not value_cols:
             return ''
+
+        cast_func_cols = {
+            c_name: (
+                ('', '', '')
+                if (
+                    flavor == 'oracle'
+                    and are_dtypes_equal(get_pd_type_from_db_type(c_type), 'bytes')
+                )
+                else (
+                    ('CAST(', f" AS {c_type.replace('_', ' ')}", ')')
+                    if flavor != 'sqlite'
+                    else ('', '', '')
+                )
+            )
+            for c_name, c_type in value_cols
+        }
         return 'SET ' + ',\n'.join([
             (
                 l_prefix + sql_item_name(c_name, flavor, None)
                 + ' = '
-                + ('CAST(' if flavor != 'sqlite' else '')
-                + r_prefix
-                + sql_item_name(c_name, flavor, None)
-                + (' AS ' if flavor != 'sqlite' else '')
-                + (c_type.replace('_', ' ') if flavor != 'sqlite' else '')
-                + (')' if flavor != 'sqlite' else '')
+                + cast_func_cols[c_name][0]
+                + r_prefix + sql_item_name(c_name, flavor, None)
+                + cast_func_cols[c_name][1]
+                + cast_func_cols[c_name][2]
             ) for c_name, c_type in value_cols
         ])
 
     def and_subquery(l_prefix: str, r_prefix: str):
-        return '\nAND\n'.join([
+        return '\n            AND\n                '.join([
             (
                 "COALESCE("
                 + l_prefix
@@ -1555,7 +1612,7 @@ def get_update_queries(
                 + ", "
                 + get_null_replacement(c_type, flavor)
                 + ")"
-                + ' = '
+                + '\n                =\n                '
                 + "COALESCE("
                 + r_prefix
                 + sql_item_name(c_name, flavor, None)
@@ -1573,15 +1630,13 @@ def get_update_queries(
     min_dt_col_name = f"MIN({dt_col_name})" if flavor != 'mssql' else '[Min_dt]'
     max_dt_col_name = f"MAX({dt_col_name})" if flavor != 'mssql' else '[Max_dt]'
     date_bounds_subquery = (
-        f"""
-        f.{dt_col_name} >= (SELECT {min_dt_col_name} FROM {date_bounds_table})
-        AND f.{dt_col_name} <= (SELECT {max_dt_col_name} FROM {date_bounds_table})
-        """
+        f"""f.{dt_col_name} >= (SELECT {min_dt_col_name} FROM {date_bounds_table})
+            AND
+                f.{dt_col_name} <= (SELECT {max_dt_col_name} FROM {date_bounds_table})"""
         if datetime_col
         else "1 = 1"
     )
-    with_temp_date_bounds = f"""
-    WITH [date_bounds] AS (
+    with_temp_date_bounds = f"""WITH [date_bounds] AS (
         SELECT MIN({dt_col_name}) AS {min_dt_col_name}, MAX({dt_col_name}) AS {max_dt_col_name}
         FROM {patch_table_name}
     )""" if datetime_col else ""
@@ -1598,8 +1653,8 @@ def get_update_queries(
 
     ### NOTE: MSSQL upserts must exclude the update portion if only upserting indices.
     when_matched_update_sets_subquery_none = "" if not value_cols else (
-        "WHEN MATCHED THEN"
-        f"     UPDATE {sets_subquery('', 'p.')}"
+        "\n        WHEN MATCHED THEN\n"
+        f"            UPDATE {sets_subquery('', 'p.')}"
     )
 
     cols_equal_values = '\n,'.join(
@@ -1616,7 +1671,7 @@ def get_update_queries(
     ignore = "IGNORE " if not value_cols else ""
 
     formatted_queries = [
-        base_query.format(
+        textwrap.dedent(base_query.format(
             sets_subquery_none=sets_subquery('', 'p.'),
             sets_subquery_none_excluded=sets_subquery('', 'EXCLUDED.'),
             sets_subquery_f=sets_subquery('f.', 'p.'),
@@ -1637,7 +1692,7 @@ def get_update_queries(
             with_temp_date_bounds=with_temp_date_bounds,
             identity_insert_on=identity_insert_on,
             identity_insert_off=identity_insert_off,
-        )
+        )).lstrip().rstrip()
         for base_query in base_queries
     ]
 
@@ -1681,11 +1736,14 @@ def get_null_replacement(typ: str, flavor: str) -> str:
         )
         return f'CAST({val_to_cast} AS {bool_typ})'
     if 'time' in typ.lower() or 'date' in typ.lower():
-        return dateadd_str(flavor=flavor, begin='1900-01-01')
+        db_type = typ if typ.isupper() else None
+        return dateadd_str(flavor=flavor, begin='1900-01-01', db_type=db_type)
     if 'float' in typ.lower() or 'double' in typ.lower() or typ.lower() in ('decimal',):
         return '-987654321.0'
     if flavor == 'oracle' and typ.lower().split('(', maxsplit=1)[0] == 'char':
         return "'-987654321'"
+    if flavor == 'oracle' and typ.lower() in ('blob', 'bytes'):
+        return '00'
     if typ.lower() in ('uniqueidentifier', 'guid', 'uuid'):
         magic_val = 'DEADBEEF-ABBA-BABE-CAFE-DECAFC0FFEE5'
         if flavor == 'mssql':
@@ -1964,7 +2022,6 @@ def _get_create_table_query_from_cte(
     Create a new table from a CTE query.
     """
     import textwrap
-    from meerschaum.utils.dtypes.sql import AUTO_INCREMENT_COLUMN_FLAVORS
     create_cte = 'create_query'
     create_cte_name = sql_item_name(create_cte, flavor, None)
     new_table_name = sql_item_name(new_table, flavor, schema)
@@ -2052,11 +2109,11 @@ def _get_create_table_query_from_cte(
             ADD PRIMARY KEY ({primary_key_name})
         """
 
-    create_table_query = textwrap.dedent(create_table_query)
+    create_table_query = textwrap.dedent(create_table_query).lstrip().rstrip()
     if not primary_key:
         return [create_table_query]
 
-    alter_type_query = textwrap.dedent(alter_type_query)
+    alter_type_query = textwrap.dedent(alter_type_query).lstrip().rstrip()
 
     return [
         create_table_query,

meerschaum/utils/venv/__init__.py

@@ -218,17 +218,22 @@ def is_venv_active(
 
 verified_venvs = set()
 def verify_venv(
-        venv: str,
-        debug: bool = False,
-    ) -> None:
+    venv: str,
+    debug: bool = False,
+) -> None:
     """
     Verify that the virtual environment matches the expected state.
     """
-    import pathlib, platform, os, shutil, subprocess, sys
+    import pathlib
+    import platform
+    import os
+    import shutil
+    import sys
     from meerschaum.config._paths import VIRTENV_RESOURCES_PATH
     from meerschaum.utils.process import run_process
     from meerschaum.utils.misc import make_symlink, is_symlink
     from meerschaum.utils.warnings import warn
+
     venv_path = VIRTENV_RESOURCES_PATH / venv
     bin_path = venv_path / (
         'bin' if platform.system() != 'Windows' else "Scripts"
@@ -368,16 +373,21 @@ def init_venv(
         return True
 
     import io
-    from contextlib import redirect_stdout, redirect_stderr
-    import sys, platform, os, pathlib, shutil
+    from contextlib import redirect_stdout
+    import sys
+    import platform
+    import os
+    import pathlib
+    import shutil
+
     from meerschaum.config.static import STATIC_CONFIG
     from meerschaum.config._paths import VIRTENV_RESOURCES_PATH, VENVS_CACHE_RESOURCES_PATH
     from meerschaum.utils.packages import is_uv_enabled
+
     venv_path = VIRTENV_RESOURCES_PATH / venv
     vtp = venv_target_path(venv=venv, allow_nonexistent=True, debug=debug)
     docker_home_venv_path = pathlib.Path('/home/meerschaum/venvs/mrsm')
 
-    runtime_env_var = STATIC_CONFIG['environment']['runtime']
     work_dir_env_var = STATIC_CONFIG['environment']['work_dir']
     if (
         not force
@@ -404,10 +414,13 @@ def init_venv(
 
     _venv_success = False
     temp_vtp = VENVS_CACHE_RESOURCES_PATH / str(venv)
-    rename_vtp = vtp.exists()
+    rename_vtp = vtp.exists() and not temp_vtp.exists()
 
     if rename_vtp:
-        vtp.rename(temp_vtp)
+        try:
+            vtp.rename(temp_vtp)
+        except FileExistsError:
+            pass
 
     if uv is not None:
         _venv_success = run_python_package(

{meerschaum-2.7.0rc1.dist-info → meerschaum-2.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: meerschaum
-Version: 2.7.0rc1
+Version: 2.7.1
 Summary: Sync Time-Series Pipes with Meerschaum
 Home-page: https://meerschaum.io
 Author: Bennett Meares