Python Fundamentals and Core Syntax Questions

row = next(cursor)
user_count = users_df['user_id'].nunique()
avg_session_time = sessions_df['duration'].mean()
DEFAULT_DATE_RANGE = ('2025-01-01', '2025-12-31')
_temp_df = df.dropna()

import json
import logging
import sys

# Configure logger to stderr
logger = logging.getLogger("read_jsonlines")
if not logger.handlers:
    h = logging.StreamHandler(stream=sys.stderr)
    h.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
    logger.addHandler(h)
logger.setLevel(logging.WARNING)

def read_jsonlines(path, encoding="utf-8"):
    """
    Yield parsed JSON objects from a file where each line is a JSON document.
    - Replaces invalid UTF-8 bytes (errors='replace').
    - Skips malformed JSON lines and logs their line numbers to stderr.
    - Uses only the standard library.
    """
    with open(path, "r", encoding=encoding, errors="replace") as f:
        for lineno, line in enumerate(f, start=1):
            line = line.strip()
            if not line:
                continue  # skip empty lines
            try:
                yield json.loads(line)
            except json.JSONDecodeError as e:
                logger.warning("Malformed JSON at line %d: %s", lineno, e.msg)
                continue

import time
import logging
import functools
from typing import Callable, Tuple, Type

logger = logging.getLogger(__name__)

def retry(
    retries: int = 3,
    initial_delay: float = 1.0,
    multiplier: float = 2.0,
    exceptions: Tuple[Type[BaseException], ...] = (Exception,),
    logger_obj: logging.Logger = logger
) -> Callable:
    """
    Decorator to retry a function with exponential backoff.

    Params:
    - retries: total attempts (including first). If <=1, runs once.
    - initial_delay: seconds to wait before first retry.
    - multiplier: factor to multiply delay after each failure.
    - exceptions: tuple of exception classes to catch and retry.
    - logger_obj: logger for structured messages.
    """
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            attempt = 0
            delay = float(initial_delay)
            last_exc = None
            max_attempts = max(1, int(retries))
            while attempt < max_attempts:
                try:
                    attempt += 1
                    logger_obj.debug("Attempt %d/%d: calling %s", attempt, max_attempts, func.__name__)
                    return func(*args, **kwargs)
                except exceptions as exc:
                    last_exc = exc
                    logger_obj.warning(
                        "Attempt %d/%d failed for %s: %s",
                        attempt, max_attempts, func.__name__, exc, exc_info=True
                    )
                    if attempt >= max_attempts:
                        logger_obj.error("All %d attempts failed for %s; re-raising.", max_attempts, func.__name__)
                        raise
                    logger_obj.info("Sleeping %.2fs before next retry (multiplier=%s).", delay, multiplier)
                    time.sleep(delay)
                    delay *= multiplier
            # Shouldn't reach here, but re-raise last exception defensively
            if last_exc:
                raise last_exc
            return None
        return wrapper
    return decorator

import psycopg2
from psycopg2 import OperationalError

@retry(retries=5, initial_delay=2.0, multiplier=2.0, exceptions=(OperationalError, TimeoutError))
def load_dim_customers():
    # code that connects to DB or API and loads customers into staging
    conn = psycopg2.connect(...)  # may raise OperationalError
    # perform query, transform, load...

import csv
from datetime import datetime
from collections import Counter, defaultdict
import dateutil.parser as dp

def try_datetime(s):
    try:
        dt = dp.parse(s)
        # Distinguish date-only vs datetime by presence of time components
        if dt.hour == 0 and dt.minute == 0 and dt.second == 0 and "T" not in s and ":" not in s:
            return 'date'
        return 'datetime'
    except Exception:
        return None

def infer_schema(csv_path, sample_size=1000):
    """
    Returns dict: {column_name: inferred_type} where type in
    {'integer','float','date','datetime','boolean','string'}
    """
    counts = defaultdict(Counter)
    total = defaultdict(int)
    bool_true = {'true','t','yes','y','1'}
    bool_false = {'false','f','no','n','0'}

    with open(csv_path, newline='', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for i,row in enumerate(reader):
            if i >= sample_size:
                break
            for col,val in row.items():
                val = (val or "").strip()
                if val == "" or val.lower() in {'null','none','nan'}:
                    counts[col]['null'] += 1
                    continue
                total[col] += 1
                # Try boolean
                low = val.lower()
                if low in bool_true or low in bool_false:
                    counts[col]['boolean'] += 1
                    continue
                # Try int
                try:
                    if '.' not in val and val.lstrip('-').isdigit():
                        int(val)
                        counts[col]['integer'] += 1
                        continue
                except Exception:
                    pass
                # Try float
                try:
                    float(val)
                    counts[col]['float'] += 1
                    continue
                except Exception:
                    pass
                # Try date/datetime via dateutil
                dt_kind = try_datetime(val)
                if dt_kind:
                    counts[col][dt_kind] += 1
                    continue
                # fallback string
                counts[col]['string'] += 1

    schema = {}
    for col,c in counts.items():
        tot = total.get(col, 0)
        # If no non-null samples -> string by default
        if tot == 0:
            schema[col] = 'string'
            continue
        # If mostly integers
        if c['integer'] / tot >= 0.9:
            schema[col] = 'integer'
            continue
        # integer+float -> float if floats present
        if (c['integer'] + c['float']) / tot >= 0.9:
            schema[col] = 'float' if c['float'] > 0 else 'integer'
            continue
        # datetime/date preference if >=50% parsed
        if c['datetime'] / tot >= 0.5:
            schema[col] = 'datetime'
            continue
        if c['date'] / tot >= 0.5:
            schema[col] = 'date'
            continue
        # boolean if majority boolean-like
        if c['boolean'] / tot >= 0.9:
            schema[col] = 'boolean'
            continue
        # Mixed small numeric + strings -> string
        schema[col] = 'string'

    return schema