e6data-python-connector 2.3.12rc32__tar.gz → 2.3.13__tar.gz

{e6data_python_connector-2.3.12rc32/e6data_python_connector.egg-info → e6data_python_connector-2.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.12rc32
+Version: 2.3.13
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -39,7 +39,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.12rc32-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.13-blue.svg)
 
 ## Introduction
 
@@ -54,6 +54,10 @@ yum install python3-devel gcc-c++ -y
 # Ubuntu/Debian dependencies
 apt install python3-dev g++ -y
 
+# Windows dependencies
+# Install Visual C++ Build Tools from:
+# https://visualstudio.microsoft.com/visual-cpp-build-tools/
+# Select the "Desktop Development with C++" option during installation.
 
 # Pip dependencies
 pip install wheel

{e6data_python_connector-2.3.12rc32 → e6data_python_connector-2.3.13}/README.md

@@ -1,6 +1,6 @@
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.12rc32-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.13-blue.svg)
 
 ## Introduction
 
@@ -15,6 +15,10 @@ yum install python3-devel gcc-c++ -y
 # Ubuntu/Debian dependencies
 apt install python3-dev g++ -y
 
+# Windows dependencies
+# Install Visual C++ Build Tools from:
+# https://visualstudio.microsoft.com/visual-cpp-build-tools/
+# Select the "Desktop Development with C++" option during installation.
 
 # Pip dependencies
 pip install wheel

{e6data_python_connector-2.3.12rc32 → e6data_python_connector-2.3.13}/e6data_python_connector/cluster_manager.py

@@ -9,27 +9,9 @@ import multiprocessing
 
 logger = logging.getLogger(__name__)
 
+from e6data_python_connector.common import get_ssl_credentials
 from e6data_python_connector.strategy import _get_active_strategy, _set_active_strategy, _set_pending_strategy, \
-    _get_grpc_header as _get_strategy_header
-
-
-def _get_grpc_header(engine_ip=None, cluster=None, strategy=None):
-    """
-    Generate gRPC metadata headers for the request.
-
-    This function creates a list of metadata headers to be used in gRPC requests.
-    It includes optional headers for the engine IP, cluster UUID, and deployment strategy.
-
-    Args:
-        engine_ip (str, optional): The IP address of the engine. Defaults to None.
-        cluster (str, optional): The UUID of the cluster. Defaults to None.
-        strategy (str, optional): The deployment strategy (blue/green). Defaults to None.
-
-    Returns:
-        list: A list of tuples representing the gRPC metadata headers.
-    """
-    # Use the strategy module's implementation
-    return _get_strategy_header(engine_ip=engine_ip, cluster=cluster, strategy=strategy)
+    _get_grpc_header
 
 
 class _StatusLock:
@@ -173,45 +155,6 @@ class ClusterManager:
         self._debug = debug
         self._ssl_cert = ssl_cert
 
-    def _get_ssl_credentials(self):
-        """
-        Get SSL credentials for secure gRPC channel.
-
-        Handles three scenarios:
-        1. ssl_cert is a string (file path): Read the PEM certificate from the file
-        2. ssl_cert is bytes: Use the certificate content directly
-        3. ssl_cert is None: Use system default CA bundle
-
-        Returns:
-            grpc.ChannelCredentials: SSL credentials for secure channel
-
-        Raises:
-            FileNotFoundError: If ssl_cert is a file path but the file doesn't exist
-            IOError: If ssl_cert file cannot be read
-        """
-        if self._ssl_cert is None:
-            # Use system default CA bundle
-            return grpc.ssl_channel_credentials()
-        elif isinstance(self._ssl_cert, str):
-            # ssl_cert is a file path - read the certificate from file
-            try:
-                with open(self._ssl_cert, 'rb') as cert_file:
-                    root_ca_cert = cert_file.read()
-                return grpc.ssl_channel_credentials(root_certificates=root_ca_cert)
-            except FileNotFoundError:
-                logger.error(f"SSL certificate file not found: {self._ssl_cert}")
-                raise
-            except IOError as e:
-                logger.error(f"Failed to read SSL certificate file {self._ssl_cert}: {e}")
-                raise
-        elif isinstance(self._ssl_cert, bytes):
-            # ssl_cert is certificate content as bytes
-            return grpc.ssl_channel_credentials(root_certificates=self._ssl_cert)
-        else:
-            # Invalid type - log warning and use system default
-            logger.warning(f"Invalid ssl_cert type: {type(self._ssl_cert)}. Using system default CA bundle.")
-            return grpc.ssl_channel_credentials()
-
     @property
     def _get_connection(self):
         """
@@ -226,7 +169,7 @@ class ClusterManager:
             self._channel = grpc.secure_channel(
                 target='{}:{}'.format(self._host, self._port),
                 options=self._grpc_options,
-                credentials=self._get_ssl_credentials()
+                credentials=get_ssl_credentials(self._ssl_cert)
             )
         else:
             self._channel = grpc.insecure_channel(

{e6data_python_connector-2.3.12rc32 → e6data_python_connector-2.3.13}/e6data_python_connector/common.py

@@ -15,6 +15,7 @@ from builtins import int
 from builtins import object
 from builtins import str
 
+import grpc
 from future.utils import with_metaclass
 from past.builtins import basestring
 
@@ -267,3 +268,46 @@ class UniversalSet(object):
 
     def __contains__(self, item):
         return True
+
+
+def get_ssl_credentials(ssl_cert):
+    """
+    Get SSL credentials for secure gRPC channel.
+
+    Handles three scenarios:
+    1. ssl_cert is a string (file path): Read the PEM certificate from the file
+    2. ssl_cert is bytes: Use the certificate content directly
+    3. ssl_cert is None: Use system default CA bundle
+
+    Parameters:
+        ssl_cert (str or bytes or None): SSL certificate as file path, bytes, or None
+
+    Returns:
+        grpc.ChannelCredentials: SSL credentials for gRPC channel
+
+    Raises:
+        FileNotFoundError: If ssl_cert is a file path but the file doesn't exist
+        IOError: If ssl_cert file cannot be read
+    """
+    if ssl_cert is None:
+        # Use system default CA bundle
+        return grpc.ssl_channel_credentials()
+    elif isinstance(ssl_cert, str):
+        # ssl_cert is a file path - read the certificate from file
+        try:
+            with open(ssl_cert, 'rb') as cert_file:
+                root_ca_cert = cert_file.read()
+            return grpc.ssl_channel_credentials(root_certificates=root_ca_cert)
+        except FileNotFoundError:
+            _logger.error("SSL certificate file not found: {}".format(ssl_cert))
+            raise
+        except IOError as e:
+            _logger.error("Failed to read SSL certificate file {}: {}".format(ssl_cert, e))
+            raise
+    elif isinstance(ssl_cert, bytes):
+        # ssl_cert is certificate content as bytes
+        return grpc.ssl_channel_credentials(root_certificates=ssl_cert)
+    else:
+        # Invalid type - fall back to system default CA bundle with warning
+        _logger.warning("Invalid ssl_cert type: {}. Using system default CA bundle.".format(type(ssl_cert)))
+        return grpc.ssl_channel_credentials()

e6data_python_connector-2.3.13/e6data_python_connector/constants.py

@@ -0,0 +1,56 @@
+import pytz
+
+# Type definitions
+PRIMITIVE_TYPES = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 20, 21}
+COMPLEX_TYPES = {10, 11, 12, 13, 14}
+COLLECTION_TYPES = {10, 11}
+TYPE_NAMES = {
+    0: "BOOLEAN",
+    1: "TINYINT",
+    2: "SMALLINT",
+    3: "INT",
+    4: "BIGINT",
+    5: "FLOAT",
+    6: "DOUBLE",
+    7: "STRING",
+    8: "TIMESTAMP",
+    9: "BINARY",
+    10: "ARRAY",
+    11: "MAP",
+    12: "STRUCT",
+    13: "UNIONTYPE",
+    15: "DECIMAL",
+    16: "NULL",
+    17: "DATE",
+    18: "VARCHAR",
+    19: "CHAR",
+    20: "INTERVAL_YEAR_MONTH",
+    21: "INTERVAL_DAY_TIME",
+}
+CHARACTER_MAXIMUM_LENGTH = "characterMaximumLength"
+PRECISION = "precision"
+SCALE = "scale"
+ZONE = pytz.timezone('UTC')
+
+# Retry and timeout constants
+MAX_RETRY_ATTEMPTS = 5
+RETRY_SLEEP_SECONDS = 0.2
+STRATEGY_CACHE_TIMEOUT_SECONDS = 300  # 5 minutes
+DEFAULT_GRPC_PREPARE_TIMEOUT_SECONDS = 600  # 10 minutes
+DEFAULT_AUTO_RESUME_TIMEOUT_SECONDS = 300  # 5 minutes
+CLUSTER_STATUS_CHECK_SLEEP_SECONDS = 5
+LOCK_TIMEOUT_MS = 500
+
+# Connection pool constants
+POOL_GET_TIMEOUT_SECONDS = 0.1
+POOL_RETRY_SLEEP_SECONDS = 0.1
+
+# Blue-green deployment strategy constants
+STRATEGY_BLUE = 'blue'
+STRATEGY_GREEN = 'green'
+VALID_STRATEGIES = {STRATEGY_BLUE, STRATEGY_GREEN}
+
+# gRPC error codes and messages
+GRPC_ERROR_STRATEGY_MISMATCH = 'status: 456'
+GRPC_ERROR_SERVICE_UNAVAILABLE = 'status: 503'
+GRPC_ERROR_ACCESS_DENIED = 'Access denied'

{e6data_python_connector-2.3.12rc32 → e6data_python_connector-2.3.13}/e6data_python_connector/datainputstream.py

@@ -10,7 +10,13 @@ from thrift.transport import TTransport
 
 from e6data_python_connector.e6x_vector.ttypes import Chunk, Vector, VectorType
 from e6data_python_connector.constants import ZONE
-from e6data_python_connector.date_time_utils import floor_div, floor_mod, timezone_from_offset
+from e6data_python_connector.date_time_utils import (
+    floor_div,
+    floor_mod,
+    timezone_from_offset,
+    format_iso_date_from_epoch_micros,
+    format_iso_datetime_from_epoch_micros,
+)
 
 # Try to import fastbinary - it's optional but provides better performance
 _fastbinary_available = False
@@ -463,16 +469,11 @@ def read_values_from_array(query_columns_description: list, dis: DataInputStream
             if dtype == "LONG":
                 value_array.append(dis.read_long())
             elif dtype == "DATE":
-                epoch_seconds = floor_div(dis.read_long(), 1000_000)
-                date = datetime.fromtimestamp(epoch_seconds, ZONE)
-                value_array.append(date.strftime("%Y-%m-%d"))
+                value_array.append(format_iso_date_from_epoch_micros(dis.read_long()))
             elif dtype == "DATETIME":
-                epoch_micros = dis.read_long()
-                epoch_seconds = floor_div(epoch_micros, 1000_000)
-                micros_of_the_day = floor_mod(epoch_micros, 1000_000)
-                date_time = datetime.fromtimestamp(epoch_seconds, ZONE)
-                date_time = date_time + timedelta(microseconds=micros_of_the_day)
-                value_array.append(date_time.strftime("%Y-%m-%d %H:%M:%S"))
+                value_array.append(format_iso_datetime_from_epoch_micros(
+                    dis.read_long(), tz=ZONE, separator=' ',
+                    include_millis=False, include_offset=False))
             elif dtype == "STRING" or dtype == "ARRAY" or dtype == "MAP" or dtype == "STRUCT":
                 value_array.append(dis.read_utf().decode())
             elif dtype == "INT":
@@ -560,27 +561,38 @@ def get_column_from_chunk(vector: Vector) -> list:
                 value_array.append(vector.data.int64Data.data[
                                        row] if not vector.isConstantVector else vector.data.numericConstantData.data)
         elif d_type == VectorType.DATE:
+            # Use the JDBC-parity formatter so years > 9999 emit "+YYYYY-MM-DD"
+            # instead of raising. Per-row try/except keeps a single bad value
+            # from truncating the column (which previously cascaded to an
+            # IndexError in read_rows_from_chunk).
             for row in range(vector.size):
                 if get_null(vector, row):
                     value_array.append(None)
                     continue
-                epoch_seconds = floor_div(vector.data.dateData.data[
-                                              row] if not vector.isConstantVector else vector.data.dateConstantData.data,
-                                          1000_000)
-                date = datetime.fromtimestamp(epoch_seconds, zone)
-                value_array.append(date.strftime("%Y-%m-%d"))
+                try:
+                    raw = (vector.data.dateData.data[row]
+                           if not vector.isConstantVector
+                           else vector.data.dateConstantData.data)
+                    value_array.append(format_iso_date_from_epoch_micros(raw))
+                except Exception as e:
+                    _logger.error("Failed to parse DATE row=%s: %s", row, e)
+                    value_array.append('Failed to parse.')
         elif d_type == VectorType.DATETIME:
+            # Default formatter knobs reproduce the prior datetime.isoformat
+            # output ("YYYY-MM-DDTHH:MM:SS.sss+HH:MM"). See DATE branch above
+            # for the rationale on per-row try/except.
             for row in range(vector.size):
                 if get_null(vector, row):
                     value_array.append(None)
                     continue
-                epoch_micros = vector.data.timeData.data[
-                    row] if not vector.isConstantVector else vector.data.timeConstantData.data
-                epoch_seconds = floor_div(epoch_micros, 1000_000)
-                micros_of_the_day = floor_mod(epoch_micros, 1000_000)
-                date_time = datetime.fromtimestamp(epoch_seconds, zone)
-                date_time = date_time + timedelta(microseconds=micros_of_the_day)
-                value_array.append(date_time.isoformat(timespec='milliseconds'))
+                try:
+                    epoch_micros = (vector.data.timeData.data[row]
+                                    if not vector.isConstantVector
+                                    else vector.data.timeConstantData.data)
+                    value_array.append(format_iso_datetime_from_epoch_micros(epoch_micros, tz=zone))
+                except Exception as e:
+                    _logger.error("Failed to parse DATETIME row=%s: %s", row, e)
+                    value_array.append('Failed to parse.')
         elif d_type == VectorType.STRING or d_type == VectorType.ARRAY or d_type == VectorType.MAP or d_type == VectorType.STRUCT:
             for row in range(vector.size):
                 if get_null(vector, row):
@@ -627,22 +639,27 @@ def get_column_from_chunk(vector: Vector) -> list:
             for row in range(vector.size):
                 value_array.append(None)
         elif d_type == VectorType.TIMESTAMP_TZ:
+            # row_zone is scoped to the row (not the outer `zone`) so a
+            # per-row zone resolution doesn't leak into later iterations.
             for row in range(vector.size):
                 if get_null(vector, row):
                     value_array.append(None)
                     continue
-                epoch_micros = vector.data.timeData.data[
-                    row] if not vector.isConstantVector else vector.data.timeConstantData.data
-                if ((vector.isConstantVector and vector.data.timeConstantData.zoneData is not None) or
-                        (not vector.isConstantVector and vector.data.timeData.zoneData is not None)):
-                    zone_id = vector.data.timeData.zoneData[
-                        row] if not vector.isConstantVector else vector.data.timeConstantData.zoneData
-                    zone = timezone_from_offset(zone_id)
-                epoch_seconds = floor_div(epoch_micros, 1000_000)
-                micros_of_the_day = floor_mod(epoch_micros, 1000_000)
-                date_time = datetime.fromtimestamp(epoch_seconds, zone)
-                date_time = date_time + timedelta(microseconds=micros_of_the_day)
-                value_array.append(date_time.isoformat(timespec='milliseconds'))
+                try:
+                    epoch_micros = (vector.data.timeData.data[row]
+                                    if not vector.isConstantVector
+                                    else vector.data.timeConstantData.data)
+                    row_zone = zone
+                    if ((vector.isConstantVector and vector.data.timeConstantData.zoneData is not None) or
+                            (not vector.isConstantVector and vector.data.timeData.zoneData is not None)):
+                        zone_id = (vector.data.timeData.zoneData[row]
+                                   if not vector.isConstantVector
+                                   else vector.data.timeConstantData.zoneData)
+                        row_zone = timezone_from_offset(zone_id)
+                    value_array.append(format_iso_datetime_from_epoch_micros(epoch_micros, tz=row_zone))
+                except Exception as e:
+                    _logger.error("Failed to parse TIMESTAMP_TZ row=%s: %s", row, e)
+                    value_array.append('Failed to parse.')
         elif d_type == VectorType.DECIMAL128:
             # Handle both constant and non-constant vectors following Java implementation
             if vector.isConstantVector:
@@ -679,6 +696,12 @@ def get_column_from_chunk(vector: Vector) -> list:
         else:
             value_array.append(None)
     except Exception as e:
-        _logger.error(e)
-        value_array.append('Failed to parse.')
+        # Safety net: if anything escapes the per-row try/excepts above (or
+        # comes from a branch without one), pad value_array to vector.size so
+        # read_rows_from_chunk's columns[colIndex][rowIndex] access can never
+        # IndexError on a short column.
+        _logger.error("get_column_from_chunk failed (vectorType=%s, parsed=%s/%s): %s",
+                      d_type, len(value_array), vector.size, e)
+        while len(value_array) < vector.size:
+            value_array.append('Failed to parse.')
     return value_array

{e6data_python_connector-2.3.12rc32 → e6data_python_connector-2.3.13}/e6data_python_connector/date_time_utils.py

@@ -160,6 +160,177 @@ def floor_mod(x, y):
     return r
 
 
+_SECONDS_PER_DAY = 86400
+
+
+def _civil_from_days(z):
+    """
+    Convert days since 1970-01-01 (UTC) to proleptic Gregorian (year, month, day).
+
+    Howard Hinnant's algorithm
+    (http://howardhinnant.github.io/date_algorithms.html#civil_from_days).
+    Pure-integer math: works for any year representable by a Python int, so it
+    does not overflow like datetime.fromtimestamp (capped at year 9999). The
+    e6data engine emits dates that decode to years up to ~10^9 (matching Java's
+    LocalDate range); this is the only conversion path that can represent them.
+
+    Args:
+        z (int): Days since 1970-01-01 (negative = before epoch).
+
+    Returns:
+        tuple[int, int, int]: (year, month, day) in the proleptic Gregorian calendar.
+    """
+    z = z + 719468
+    era = (z if z >= 0 else z - 146096) // 146097
+    doe = z - era * 146097
+    yoe = (doe - doe // 1460 + doe // 36524 - doe // 146096) // 365
+    y = yoe + era * 400
+    doy = doe - (365 * yoe + yoe // 4 - yoe // 100)
+    mp = (5 * doy + 2) // 153
+    d = doy - (153 * mp + 2) // 5 + 1
+    m = mp + 3 if mp < 10 else mp - 9
+    if m <= 2:
+        y += 1
+    return y, m, d
+
+
+def _format_iso_year(year):
+    """
+    Render the year component of an ISO-8601 date the way Java's
+    DateTimeFormatter.ISO_LOCAL_DATE does, so connector output matches the
+    e6data JDBC driver byte-for-byte:
+
+      - 0 <= year <= 9999  -> "YYYY"        (zero-padded, no prefix)
+      - year > 9999        -> "+YYYYY..."   (variable width, '+' prefix)
+      - year < 0           -> "-YYYY..."    (zero-padded if 4 digits, '-' prefix)
+    """
+    if 0 <= year <= 9999:
+        return "{:04d}".format(year)
+    if year > 9999:
+        return "+{}".format(year)
+    return "-{:04d}".format(abs(year)) if abs(year) <= 9999 else "-{}".format(abs(year))
+
+
+def _tz_offset_minutes(tz, ref_seconds=0):
+    """
+    Best-effort extraction of a UTC offset (in whole minutes) from a pytz tzinfo.
+
+    Used by the datetime formatter to apply the zone numerically, instead of
+    constructing a Python datetime (which can't represent years > 9999). Tries
+    tz.utcoffset(None) first — works directly for pytz.UTC and pytz.FixedOffset,
+    which is what timezone_from_offset() actually returns in practice. Falls
+    back to probing tz.utcoffset(<reference datetime>) for named zones, with
+    the probe seconds clamped to [0, year-9999] so it never hits the Python
+    datetime ceiling.
+
+    Args:
+        tz: A tzinfo / pytz timezone object, or None.
+        ref_seconds (int): Epoch seconds used to construct the probe datetime
+            for named zones. Ignored for fixed-offset / UTC.
+
+    Returns:
+        int: Offset minutes east of UTC. 0 when tz is None or cannot be probed.
+    """
+    if tz is None:
+        return 0
+    try:
+        offset = tz.utcoffset(None)
+        if offset is not None:
+            return int(offset.total_seconds() // 60)
+    except (TypeError, AttributeError, ValueError):
+        pass
+    # Fallback for named timezones: probe with a reference datetime.
+    try:
+        from datetime import datetime as _dt
+        probe = _dt.utcfromtimestamp(max(0, min(ref_seconds, 253370764800)))  # clamp to year 9999
+        offset = tz.utcoffset(probe)
+        if offset is not None:
+            return int(offset.total_seconds() // 60)
+    except Exception:
+        pass
+    return 0
+
+
+def format_iso_date_from_epoch_micros(epoch_micros):
+    """
+    Format epoch microseconds (UTC) as an ISO-8601 date string with Java
+    LocalDate-style expanded-year support.
+
+    Pipeline: micros -> seconds -> days -> (year, month, day) -> string.
+    All steps are pure-int, so this never raises ValueError on year overflow
+    the way datetime.fromtimestamp(...).strftime(...) does for years > 9999.
+
+    Examples:
+        format_iso_date_from_epoch_micros(1770854400000000) -> "2026-02-12"
+        format_iso_date_from_epoch_micros(308847859200000000) -> "+11756-12-31"
+        format_iso_date_from_epoch_micros(0) -> "1970-01-01"
+
+    Args:
+        epoch_micros (int): Microseconds since 1970-01-01T00:00:00Z (may be negative).
+
+    Returns:
+        str: ISO-8601 date. Years 0-9999 unprefixed, others with '+' / '-'.
+    """
+    epoch_seconds = floor_div(epoch_micros, 1_000_000)
+    days = floor_div(epoch_seconds, _SECONDS_PER_DAY)
+    y, mo, d = _civil_from_days(days)
+    return "{}-{:02d}-{:02d}".format(_format_iso_year(y), mo, d)
+
+
+def format_iso_datetime_from_epoch_micros(epoch_micros, tz=None, separator='T',
+                                          include_millis=True, include_offset=True):
+    """
+    Format epoch microseconds as an ISO-8601 datetime string with Java
+    LocalDateTime / OffsetDateTime-style expanded-year support.
+
+    The zone is applied numerically via _tz_offset_minutes(), so we never need
+    to construct a Python datetime — that's what allows the formatter to handle
+    years outside [1, 9999] without raising.
+
+    Single function with knobs to cover the three format variants the connector
+    historically emitted from datetime.strftime / datetime.isoformat:
+
+      - Row-wise DATETIME (read_values_from_array):
+            separator=' ', include_millis=False, include_offset=False
+            -> "2026-02-12 00:00:00"
+
+      - Chunk-wise DATETIME / TIMESTAMP_TZ (get_column_from_chunk), defaults:
+            separator='T', include_millis=True, include_offset=True
+            -> "2026-02-12T00:00:00.123+00:00"
+            -> "+11756-12-31T00:00:00.000+00:00"  (year-overflow case)
+
+    Args:
+        epoch_micros (int): Microseconds since 1970-01-01T00:00:00Z.
+        tz: pytz timezone (UTC / FixedOffset / named); None means UTC.
+        separator (str): Between date and time (typically 'T' or ' ').
+        include_millis (bool): Append '.sss' from sub-second microseconds.
+        include_offset (bool): Append '+HH:MM' / '-HH:MM' UTC offset suffix.
+
+    Returns:
+        str: ISO-8601 datetime string.
+    """
+    epoch_seconds_utc = floor_div(epoch_micros, 1_000_000)
+    offset_minutes = _tz_offset_minutes(tz, ref_seconds=epoch_seconds_utc)
+    local_micros = epoch_micros + offset_minutes * 60 * 1_000_000
+    epoch_seconds = floor_div(local_micros, 1_000_000)
+    micros_of_second = floor_mod(local_micros, 1_000_000)
+    days = floor_div(epoch_seconds, _SECONDS_PER_DAY)
+    sec_of_day = floor_mod(epoch_seconds, _SECONDS_PER_DAY)
+    y, mo, d = _civil_from_days(days)
+    h = sec_of_day // 3600
+    mi = (sec_of_day % 3600) // 60
+    s = sec_of_day % 60
+    out = "{}-{:02d}-{:02d}{}{:02d}:{:02d}:{:02d}".format(
+        _format_iso_year(y), mo, d, separator, h, mi, s)
+    if include_millis:
+        out += ".{:03d}".format(micros_of_second // 1000)
+    if include_offset:
+        sign = '+' if offset_minutes >= 0 else '-'
+        tot = abs(offset_minutes)
+        out += "{}{:02d}:{:02d}".format(sign, tot // 60, tot % 60)
+    return out
+
+
 def timezone_from_offset(offset_string) -> pytz:
     # Parse the offset string into hours and minutes
     sign = -1 if offset_string[0] == "-" else 1