tradedangerous 12.7.6__py3-none-any.whl

tradedangerous/csvexport.py

@@ -0,0 +1,234 @@
+from pathlib import Path
+import csv
+
+from sqlalchemy import inspect, text
+from sqlalchemy.orm import Session
+
+from .tradeexcept import TradeException
+from .db import utils as db_utils
+
+
+######################################################################
+# TradeDangerous :: Modules :: CSV Exporter
+#
+# Generate CSV files for database tables.
+#
+# Assumptions:
+#   * Each table has at most one UNIQUE index.
+#   * Referenced tables also have a UNIQUE index.
+#   * Only single-column foreign keys are supported.
+#   * Single-column primary keys are inferred automatically by SQLAlchemy.
+#
+# CAUTION: If the schema changes this module may require updates.
+######################################################################
+
+######################################################################
+# Default values
+
+# For some tables the first two columns will be reversed
+reverseList = []
+
+######################################################################
+# Helpers
+######################################################################
+
+def search_keyList(items, val):
+    for row in items:
+        if row['from'] == row['to'] == val:
+            return row
+    return None
+
+
+def getUniqueIndex(session, tableName):
+    """Return all unique columns via SQLAlchemy inspector."""
+    inspector = inspect(session.get_bind())
+    unqIndex = []
+    for idx in inspector.get_indexes(tableName):
+        if idx.get("unique"):
+            unqIndex.extend(idx.get("column_names", []))
+    return unqIndex
+
+
+def getFKeyList(session, tableName):
+    """Return all single-column foreign keys via SQLAlchemy inspector."""
+    inspector = inspect(session.get_bind())
+    keyList = []
+    for fk in inspector.get_foreign_keys(tableName):
+        cols = fk.get("constrained_columns", [])
+        referred = fk.get("referred_columns", [])
+        if len(cols) == 1 and len(referred) == 1:
+            keyList.append({
+                "table": fk.get("referred_table"),
+                "from": cols[0],
+                "to": referred[0],
+            })
+    return keyList
+
+
+def buildFKeyStmt(session, tableName, key):
+    """
+    Resolve the FK constraint against the UNIQUE index of the
+    referenced table.
+    
+    Multicolumn UNIQUEs are allowed, but only the last column
+    may be treated as a single-column join target.
+    """
+    unqIndex = getUniqueIndex(session, key["table"])
+    keyList = getFKeyList(session, key["table"])
+    keyStmt = []
+    
+    for colName in unqIndex:
+        # If this unique column is itself a foreign key, recurse
+        keyKey = search_keyList(keyList, colName)
+        if keyKey:
+            keyStmt.extend(buildFKeyStmt(session, key["table"], keyKey))
+        else:
+            keyStmt.append({
+                "table": tableName,
+                "column": colName,
+                "joinTable": key["table"],
+                "joinColumn": key["to"],
+            })
+    
+    return keyStmt
+
+
+######################################################################
+# Code
+######################################################################
+
+def exportTableToFile(tdb_or_session, tdenv, tableName, csvPath=None):
+    """
+    Generate the CSV file for tableName in csvPath.
+    Returns (lineCount, exportPath).
+    
+    Behaviour:
+    - Prefix unique columns with "unq:".
+    - Foreign keys are exported as "<col>@<joinTable>.<uniqueCol>".
+    - Datetime-like values for 'modified' columns are exported as
+      "YYYY-MM-DD HH:MM:SS" (no microseconds).
+    
+    Compatible with either:
+      * a SQLAlchemy Session
+      * a TradeDB wrapper exposing .engine
+    """
+    
+    # --- Resolve a SQLAlchemy session ---
+    if hasattr(tdb_or_session, "engine"):
+        # Likely a TradeDB instance
+        engine = tdb_or_session.engine
+        session = Session(engine)
+    elif hasattr(tdb_or_session, "get_bind"):
+        # Already a Session
+        session = tdb_or_session
+    else:
+        raise TradeException(
+            f"Unsupported DB object passed to exportTableToFile: {type(tdb_or_session)}"
+        )
+    
+    csvPath = csvPath or Path(tdenv.csvDir)
+    if not Path(csvPath).is_dir():
+        raise TradeException(f"Save location '{csvPath}' not found.")
+    
+    uniquePfx = "unq:"
+    exportPath = (Path(csvPath) / Path(tableName)).with_suffix(".csv")
+    tdenv.DEBUG0(f"Export Table '{tableName}' to '{exportPath}'")
+    
+    def _fmt_ts(val) -> str:
+        if (formatter := getattr(val, "strftime", None)):
+            try:
+                return formatter("%Y-%m-%d %H:%M:%S")
+            except Exception:
+                pass
+        
+        if isinstance(val, str) and len(val) >= 19:
+            if val[10] == "T":  # Indicates timezone awareness, and if no timezone, utc
+                val = f"{val[:10]} {val[11:]}"
+            # check the punctuation in  YYYY-MM-DD HH:mm:ss
+            #                               4  7  0  3  6
+            #                           0123 56 89 12 45 78
+            if val[4] == "-" and val[7] == "-" and val[10] == " " and val[13] == ":" and val[16] == ":":
+                return val[:19]
+        
+        return val
+    
+    lineCount = 0
+    with exportPath.open("w", encoding="utf-8", newline="\n") as exportFile:
+        exportOut = csv.writer(
+            exportFile,
+            delimiter=",",
+            quotechar="'",
+            doublequote=True,
+            quoting=csv.QUOTE_NONNUMERIC,
+            lineterminator="\n",
+        )
+        
+        bind = session.get_bind()
+        inspector = inspect(bind)
+        
+        try:
+            unique_cols = db_utils.get_unique_columns(session, tableName)
+            fk_list = db_utils.get_foreign_keys(session, tableName)
+        except Exception as e:
+            raise TradeException(f"Failed to introspect table '{tableName}': {e!r}") from None
+        
+        csvHead = []
+        stmtColumn = []
+        stmtTable = [tableName]
+        stmtOrder = []
+        is_modified_col = []
+        
+        for col in inspector.get_columns(tableName):
+            col_name = col["name"]
+            fk = next((fk for fk in fk_list if fk["from"] == col_name), None)
+            if fk:
+                joinTable = fk["table"]
+                joinColumn = fk["to"]
+                join_unique_cols = db_utils.get_unique_columns(session, joinTable)
+                if not join_unique_cols:
+                    raise TradeException(
+                        f"No unique column found in referenced table '{joinTable}'"
+                    )
+                export_col = join_unique_cols[0]
+                csvPfx = uniquePfx if col_name in unique_cols else ""
+                csvHead.append(f"{csvPfx}{col_name}@{joinTable}.{export_col}")
+                stmtColumn.append(f"{joinTable}.{export_col}")
+                is_modified_col.append(export_col == "modified")
+                nullable = bool(col.get("nullable", True))
+                join_type = "LEFT OUTER JOIN" if nullable else "INNER JOIN"
+                stmtTable.append(
+                    f"{join_type} {joinTable} ON {tableName}.{col_name} = {joinTable}.{joinColumn}"
+                )
+                stmtOrder.append(f"{joinTable}.{export_col}")
+            else:
+                if col_name in unique_cols:
+                    csvHead.append(uniquePfx + col_name)
+                    stmtOrder.append(f"{tableName}.{col_name}")
+                else:
+                    csvHead.append(col_name)
+                stmtColumn.append(f"{tableName}.{col_name}")
+                is_modified_col.append(col_name == "modified")
+        
+        sqlStmt = f"SELECT {','.join(stmtColumn)} FROM {' '.join(stmtTable)}"
+        if stmtOrder:
+            sqlStmt += f" ORDER BY {','.join(stmtOrder)}"
+        tdenv.DEBUG1(f"SQL: {sqlStmt}")
+        
+        exportFile.write(f"{','.join(csvHead)}\n")
+        
+        for row in session.execute(text(sqlStmt)):
+            lineCount += 1
+            row_out = [
+                _fmt_ts(val) if is_modified_col[i] else val
+                for i, val in enumerate(row)
+            ]
+            tdenv.DEBUG2(f"{lineCount}: {row_out}")
+            exportOut.writerow(row_out)
+        
+        tdenv.DEBUG1(f"{lineCount} {tableName}s exported")
+    
+    # Close session if we created it
+    if hasattr(tdb_or_session, "engine"):
+        session.close()
+    
+    return lineCount, exportPath

tradedangerous/db/__init__.py

@@ -0,0 +1,27 @@
+"""TradeDangerous SQLAlchemy bootstrap package (Stage 3A, Part 1).
+
+Side-effect free on import. Provides a minimal, cross-platform API
+for config loading, path resolution, and engine/session bootstrap.
+
+Usage:
+    from tradedangerous.db import (
+        load_config, resolve_data_dir, resolve_tmp_dir, ensure_dir, resolve_db_config_path,
+        make_engine_from_config, get_session_factory, healthcheck,
+    )
+"""
+from .config import load_config
+from .paths import resolve_data_dir, resolve_tmp_dir, ensure_dir, resolve_db_config_path
+from .engine import make_engine_from_config, get_session_factory, healthcheck
+from .lifecycle import ensure_fresh_db
+
+__all__ = [
+    "load_config",
+    "resolve_data_dir",
+    "resolve_tmp_dir",
+    "ensure_dir",
+    "resolve_db_config_path",
+    "make_engine_from_config",
+    "get_session_factory",
+    "healthcheck",
+    "ensure_fresh_db",
+]

tradedangerous/db/adapter.py

@@ -0,0 +1,192 @@
+# tradedangerous/db/adapter.py
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Dict, Generator, Iterable, Optional, Tuple
+import configparser
+import os
+
+from sqlalchemy import select, func
+from sqlalchemy.engine import Engine
+
+# Local engine + ORM (authoritative)
+from .engine import make_engine_from_config, get_session_factory  # uses env/CWD-resolved db_config.ini by default
+from .orm_models import System, Station, Item, StationItem  # canonical models
+from .paths import resolve_db_config_path
+
+
+# ---- Public factory ---------------------------------------------------------
+
+def get_adapter_if_enabled(cfg_path: Optional[str] = None) -> "TradeDBReadAdapter | None":
+    """
+    Return an adapter when [database] backend != 'sqlite', else None.
+    - No engine/session created at import: construction is lazy.
+    - This is called by tradedb.py (thin gate).
+    """
+    if cfg_path is None:
+        cfg_path = str(resolve_db_config_path())
+    cfg = configparser.ConfigParser()
+    if not os.path.exists(cfg_path):
+        return None
+    with open(cfg_path, "r", encoding="utf-8") as fh:
+        cfg.read_file(fh)
+    backend = (cfg.get("database", "backend", fallback="sqlite") or "sqlite").strip().lower()
+    if backend == "sqlite":
+        return None
+    
+    # Engine is created lazily via the property below to honour "no side-effects at import".
+    return TradeDBReadAdapter(cfg_path)
+
+# ---- Adapter (read-only) ----------------------------------------------------
+
+class TradeDBReadAdapter:
+    """
+    Very small, read-only façade over SQLAlchemy for legacy TradeDB reads:
+      - systems() list
+      - lookup system by name (case-insensitive)
+      - station by (system_id, station_name) (case-insensitive)
+      - average selling/buying prices (used by trade_cmd at detail>1)
+    """
+    def __init__(self, cfg_path: str):
+        self._cfg_path = cfg_path
+        self._engine: Optional[Engine] = None
+        self._Session = None  # sessionmaker
+    
+    # Lazy engine/session factory (no import-time work)
+    @property
+    def Session(self):
+        if self._Session is None:
+            engine = make_engine_from_config(self._cfg_path)
+            self._engine = engine
+            self._Session = get_session_factory(engine)
+        return self._Session
+    
+    @contextmanager
+    def session(self) -> Generator[Session, None, None]:
+        Session = self.Session
+        with Session() as s:
+            yield s
+    
+    # ---- Reads mapped to ORM ------------------------------------------------
+    
+    def list_system_rows(self) -> Iterable[Tuple[int, str, float, float, float, Optional[int]]]:
+        """
+        Shape matches legacy _loadSystems SELECT:
+        (system_id, name, pos_x, pos_y, pos_z, added_id)
+        """
+        with self.session() as s:
+            rows = s.execute(
+                select(
+                    System.system_id,
+                    System.name,
+                    System.pos_x,
+                    System.pos_y,
+                    System.pos_z,
+                    System.added_id,
+                )
+            )
+            for r in rows:
+                yield (r.system_id, r.name, r.pos_x, r.pos_y, r.pos_z, r.added_id)
+    
+    def system_by_name(self, name_ci: str) -> Optional[Tuple[int, str, float, float, float, Optional[int]]]:
+        """
+        Case-insensitive name match for System.
+        """
+        with self.session() as s:
+            row = s.execute(
+                select(
+                    System.system_id, System.name, System.pos_x, System.pos_y, System.pos_z, System.added_id
+                ).where(func.upper(System.name) == func.upper(func.trim(func.cast(name_ci, System.name.type))))
+            ).first()
+            if not row:
+                return None
+            return (row.system_id, row.name, row.pos_x, row.pos_y, row.pos_z, row.added_id)
+    
+    def station_by_system_and_name(
+        self, system_id: int, station_name_ci: str
+    ) -> Optional[Tuple[int, int, str, int, str, str, str, str, str, str, str, str, str, int]]:
+        """
+        Return the single Station row by system + name (CI).
+        Shape matches legacy _loadStations row consumed by Station(...):
+          (station_id, system_id, name,
+           ls_from_star, market, blackmarket, shipyard,
+           max_pad_size, outfitting, rearm, refuel, repair, planetary, type_id)
+        """
+        with self.session() as s:
+            r = s.execute(
+                select(
+                    Station.station_id,
+                    Station.system_id,
+                    Station.name,
+                    Station.ls_from_star,
+                    Station.market,
+                    Station.blackmarket,
+                    Station.shipyard,
+                    Station.max_pad_size,
+                    Station.outfitting,
+                    Station.rearm,
+                    Station.refuel,
+                    Station.repair,
+                    Station.planetary,
+                    Station.type_id,
+                ).where(
+                    Station.system_id == system_id,
+                    func.upper(Station.name) == func.upper(func.trim(func.cast(station_name_ci, Station.name.type))),
+                )
+            ).first()
+            if not r:
+                return None
+            return (
+                r.station_id,
+                r.system_id,
+                r.name,
+                r.ls_from_star,
+                r.market,
+                r.blackmarket,
+                r.shipyard,
+                r.max_pad_size,
+                r.outfitting,
+                r.rearm,
+                r.refuel,
+                r.repair,
+                r.planetary,
+                r.type_id,
+            )
+    
+    def average_selling(self) -> Dict[int, int]:
+        """
+        {item_id: avg_supply_price>0}
+        Mirrors the legacy SQL used in TradeDB.getAverageSelling.
+        """
+        with self.session() as s:
+            rows = s.execute(
+                select(
+                    Item.item_id,
+                    func.IFNULL(func.avg(StationItem.supply_price), 0),
+                )
+                .select_from(Item.__table__.outerjoin(
+                    StationItem, (Item.item_id == StationItem.item_id) & (StationItem.supply_price > 0)
+                ))
+                .where(StationItem.supply_price > 0)
+                .group_by(Item.item_id)
+            )
+            return {int(item_id): int(avg_cr) for (item_id, avg_cr) in rows}
+    
+    def average_buying(self) -> Dict[int, int]:
+        """
+        {item_id: avg_demand_price>0}
+        Mirrors the legacy SQL used in TradeDB.getAverageBuying.
+        """
+        with self.session() as s:
+            rows = s.execute(
+                select(
+                    Item.item_id,
+                    func.IFNULL(func.avg(StationItem.demand_price), 0),
+                )
+                .select_from(Item.__table__.outerjoin(
+                    StationItem, (Item.item_id == StationItem.item_id) & (StationItem.demand_price > 0)
+                ))
+                .where(StationItem.demand_price > 0)
+                .group_by(Item.item_id)
+            )
+            return {int(item_id): int(avg_cr) for (item_id, avg_cr) in rows}

tradedangerous/db/config.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+import configparser
+from pathlib import Path
+from typing import Any, Dict
+
+DEFAULTS: Dict[str, Dict[str, Any]] = {
+    "database": {"backend": "sqlite"},
+    "mariadb": {
+        "host": "127.0.0.1",
+        "port": 3306,
+        "user": "",
+        "password": "",
+        "name": "tradedangerous",
+        "driver": "mariadbconnector",  # or 'pymysql'
+        "charset": "utf8mb4",
+    },
+    "sqlite": {"sqlite_filename": "TradeDangerous.db"},
+    "paths": {"data_dir": "./data", "tmp_dir": "./tmp"},
+    "engine": {
+        "pool_size": 10,
+        "max_overflow": 20,
+        "pool_timeout": 30,
+        "pool_recycle": 1800,
+        "isolation_level": "READ COMMITTED",
+        "echo": False,
+        "connect_timeout": 10,
+    },
+}
+# --- Runtime default path correction ----------------------------------------
+# Convert relative defaults ("./data", "./tmp") into absolute paths under the
+# current working directory. This prevents first-run installs from resolving
+# relative to the package install directory or venv when no db_config.ini exists.
+try:
+    _cwd = Path.cwd()
+    DEFAULTS["paths"]["data_dir"] = str((_cwd / "data").resolve())
+    DEFAULTS["paths"]["tmp_dir"]  = str((_cwd / "tmp").resolve())
+except Exception:
+    # Best effort; fall back to shipped defaults if CWD is inaccessible
+    pass
+# ---------------------------------------------------------------------------
+
+# Hardened parser: allow inline comments and disable interpolation
+CFG_KW = {"inline_comment_prefixes": (";", "#"), "interpolation": None}
+
+def _parse_bool(s: str) -> bool:
+    return str(s).strip().lower() in {"1", "true", "yes", "on"}
+
+def _as_int(s: str, default: int | None = None) -> int | None:
+    try:
+        return int(str(s).strip())
+    except (TypeError, ValueError):
+        return default
+
+def _coerce_types(d: Dict[str, Any]) -> Dict[str, Any]:
+    eng = d.get("engine", {})
+    if "echo" in eng:
+        eng["echo"] = _parse_bool(eng["echo"]) if isinstance(eng["echo"], str) else bool(eng["echo"])
+    for k in ("pool_size", "max_overflow", "pool_timeout", "pool_recycle", "connect_timeout"):
+        if k in eng:
+            eng[k] = _as_int(eng[k], DEFAULTS["engine"][k])
+    if "mariadb" in d and "port" in d["mariadb"]:
+        d["mariadb"]["port"] = _as_int(d["mariadb"]["port"], DEFAULTS["mariadb"]["port"])
+    return d
+
+def load_config(path: str | Path | None = None) -> Dict[str, Any]:
+    """Load configuration as a dict with typed values.
+    Search order:
+      1) explicit *path* if provided
+      2) TD_DB_CONFIG env (if file exists)
+      3) ./db_config.ini (cwd)
+      4) in-code DEFAULTS
+    """
+    cfg_path: Path | None = None
+    if path is not None:
+        p = Path(path)
+        if p.exists():
+            cfg_path = p
+    else:
+        # Prefer environment variable if it points to an existing file
+        try:
+            from .paths import resolve_db_config_path
+            env_candidate = resolve_db_config_path()
+            if env_candidate.exists():
+                cfg_path = env_candidate
+        except Exception:
+            # If anything goes wrong resolving the env, fall back to defaults below
+            pass
+        
+        # Fall back to local file in CWD
+        if cfg_path is None:
+            p = Path.cwd() / "db_config.ini"
+            if p.exists():
+                cfg_path = p
+    
+    # start with defaults
+    result: Dict[str, Any] = {k: (v.copy() if isinstance(v, dict) else v) for k, v in DEFAULTS.items()}
+    
+    if cfg_path:
+        parser = configparser.ConfigParser(**CFG_KW)
+        with cfg_path.open("r", encoding="utf-8") as fh:
+            parser.read_file(fh)
+        for section in parser.sections():
+            result.setdefault(section, {})
+            for key, val in parser.items(section):
+                result[section][key] = val
+    
+    return _coerce_types(result)