initial commit

.env

@@ -0,0 +1,2 @@
+SSH_HOST=greystone.westlakeplatform.site
+SSH_USER=root

cli.py

@@ -0,0 +1,57 @@
+"""Timezone Converter — cli for conversion payloads."""
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class TimezoneCli:
+    """Cli for Timezone Converter conversion payloads."""
+
+    _DATE_FIELDS = ("local_time", "converted_at", "abbreviation")
+
+    @classmethod
+    def loads(cls, raw: str) -> Dict[str, Any]:
+        """Deserialise a JSON conversion payload."""
+        data = json.loads(raw)
+        return cls._coerce(data)
+
+    @classmethod
+    def dumps(cls, record: Dict[str, Any]) -> str:
+        """Serialise a conversion record to JSON."""
+        return json.dumps(record, default=str)
+
+    @classmethod
+    def _coerce(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Cast known date fields from ISO strings to datetime objects."""
+        out: Dict[str, Any] = {}
+        for k, v in data.items():
+            if k in cls._DATE_FIELDS and isinstance(v, str):
+                try:
+                    out[k] = datetime.fromisoformat(v)
+                except ValueError:
+                    out[k] = v
+            else:
+                out[k] = v
+        return out
+
+
+def parse_conversions(payload: str) -> List[Dict[str, Any]]:
+    """Parse a JSON array of Conversion payloads."""
+    raw = json.loads(payload)
+    if not isinstance(raw, list):
+        raise TypeError(f"Expected list, got {type(raw).__name__}")
+    return [TimezoneCli._coerce(item) for item in raw]
+
+
+def sync_conversion_to_str(
+    record: Dict[str, Any], indent: Optional[int] = None
+) -> str:
+    """Convenience wrapper — serialise a Conversion to a JSON string."""
+    if indent is None:
+        return TimezoneCli.dumps(record)
+    return json.dumps(record, indent=indent, default=str)

database.py

@@ -0,0 +1,94 @@
+"""Timezone Converter — Offset database layer."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, Iterator, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class TimezoneDatabase:
+    """Offset database for the Timezone Converter application."""
+
+    def __init__(
+        self,
+        store: Any,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self._store = store
+        self._cfg   = config or {}
+        self._utc_offset = self._cfg.get("utc_offset", None)
+        logger.debug("%s initialised", self.__class__.__name__)
+
+    def schedule_offset(
+        self, utc_offset: Any, abbreviation: Any, **extra: Any
+    ) -> Dict[str, Any]:
+        """Create and persist a new Offset record."""
+        now = datetime.now(timezone.utc).isoformat()
+        record: Dict[str, Any] = {
+            "id":         str(uuid.uuid4()),
+            "utc_offset": utc_offset,
+            "abbreviation": abbreviation,
+            "status":     "active",
+            "created_at": now,
+            **extra,
+        }
+        saved = self._store.put(record)
+        logger.info("schedule_offset: created %s", saved["id"])
+        return saved
+
+    def get_offset(self, record_id: str) -> Optional[Dict[str, Any]]:
+        """Retrieve a Offset by its *record_id*."""
+        record = self._store.get(record_id)
+        if record is None:
+            logger.debug("get_offset: %s not found", record_id)
+        return record
+
+    def compare_offset(
+        self, record_id: str, **changes: Any
+    ) -> Dict[str, Any]:
+        """Apply *changes* to an existing Offset."""
+        record = self._store.get(record_id)
+        if record is None:
+            raise KeyError(f"Offset {record_id!r} not found")
+        record.update(changes)
+        record["updated_at"] = datetime.now(timezone.utc).isoformat()
+        return self._store.put(record)
+
+    def display_offset(self, record_id: str) -> bool:
+        """Remove a Offset; returns True on success."""
+        if self._store.get(record_id) is None:
+            return False
+        self._store.delete(record_id)
+        logger.info("display_offset: removed %s", record_id)
+        return True
+
+    def list_offsets(
+        self,
+        status: Optional[str] = None,
+        limit:  int = 50,
+        offset: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """Return paginated Offset records."""
+        query: Dict[str, Any] = {}
+        if status:
+            query["status"] = status
+        results = self._store.find(query, limit=limit, offset=offset)
+        logger.debug("list_offsets: %d results", len(results))
+        return results
+
+    def iter_offsets(
+        self, batch_size: int = 100
+    ) -> Iterator[Dict[str, Any]]:
+        """Yield all Offset records in batches of *batch_size*."""
+        offset = 0
+        while True:
+            page = self.list_offsets(limit=batch_size, offset=offset)
+            if not page:
+                break
+            yield from page
+            if len(page) < batch_size:
+                break
+            offset += batch_size

handler.py

@@ -0,0 +1,85 @@
+"""Timezone Converter — Conversion repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class TimezoneHandler:
+    """Thin repository wrapper for Conversion persistence in Timezone Converter."""
+
+    TABLE = "conversions"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("TimezoneHandler bound to %s", db)
+
+    def insert(self, converted_at: Any, utc_offset: Any, **kwargs: Any) -> str:
+        """Persist a new Conversion row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "converted_at": converted_at,
+            "utc_offset": utc_offset,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Conversion row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Conversion row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Conversion row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query conversions: %d/%d", len(rows), total)
+        return rows, total
+
+    def compare_by_abbreviation(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch conversions filtered by *abbreviation*."""
+        rows, _ = self.query({"abbreviation": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["converted_at"], rec.get("utc_offset"),
+                **{k: v for k, v in rec.items() if k not in ("converted_at", "utc_offset")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert conversions: %d rows", len(ids))
+        return ids

helpers.py

@@ -0,0 +1,61 @@
+"""Timezone Converter — utility helpers for conversion operations."""
+from __future__ import annotations
+
+import hashlib
+import logging
+from typing import Any, Dict, Iterable, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def compare_conversion(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Conversion compare — normalises and validates *data*."""
+    result = {k: v for k, v in data.items() if v is not None}
+    if "utc_offset" not in result:
+        raise ValueError(f"Conversion must include 'utc_offset'")
+    result["id"] = result.get("id") or hashlib.md5(
+        str(result["utc_offset"]).encode()).hexdigest()[:12]
+    return result
+
+
+def sync_conversions(
+    items: Iterable[Dict[str, Any]],
+    *,
+    status: Optional[str] = None,
+    limit: int = 100,
+) -> List[Dict[str, Any]]:
+    """Filter and page a sequence of Conversion records."""
+    out = [i for i in items if status is None or i.get("status") == status]
+    logger.debug("sync_conversions: %d items after filter", len(out))
+    return out[:limit]
+
+
+def display_conversion(record: Dict[str, Any], **overrides: Any) -> Dict[str, Any]:
+    """Return a shallow copy of *record* with *overrides* merged in."""
+    updated = dict(record)
+    updated.update(overrides)
+    if "abbreviation" in updated and not isinstance(updated["abbreviation"], (int, float)):
+        try:
+            updated["abbreviation"] = float(updated["abbreviation"])
+        except (TypeError, ValueError):
+            pass
+    return updated
+
+
+def validate_conversion(record: Dict[str, Any]) -> bool:
+    """Return True when *record* satisfies all Conversion invariants."""
+    required = ["utc_offset", "abbreviation", "dst_active"]
+    for field in required:
+        if field not in record or record[field] is None:
+            logger.warning("validate_conversion: missing field %r", field)
+            return False
+    return isinstance(record.get("id"), str)
+
+
+def schedule_conversion_batch(
+    records: List[Dict[str, Any]],
+    batch_size: int = 50,
+) -> List[List[Dict[str, Any]]]:
+    """Slice *records* into chunks of *batch_size* for bulk schedule."""
+    return [records[i : i + batch_size]
+            for i in range(0, len(records), batch_size)]

main.py

@@ -0,0 +1,61 @@
+"""Timezone Converter — utility helpers for schedule operations."""
+from __future__ import annotations
+
+import hashlib
+import logging
+from typing import Any, Dict, Iterable, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def display_schedule(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Schedule display — normalises and validates *data*."""
+    result = {k: v for k, v in data.items() if v is not None}
+    if "dst_active" not in result:
+        raise ValueError(f"Schedule must include 'dst_active'")
+    result["id"] = result.get("id") or hashlib.md5(
+        str(result["dst_active"]).encode()).hexdigest()[:12]
+    return result
+
+
+def format_schedules(
+    items: Iterable[Dict[str, Any]],
+    *,
+    status: Optional[str] = None,
+    limit: int = 100,
+) -> List[Dict[str, Any]]:
+    """Filter and page a sequence of Schedule records."""
+    out = [i for i in items if status is None or i.get("status") == status]
+    logger.debug("format_schedules: %d items after filter", len(out))
+    return out[:limit]
+
+
+def convert_schedule(record: Dict[str, Any], **overrides: Any) -> Dict[str, Any]:
+    """Return a shallow copy of *record* with *overrides* merged in."""
+    updated = dict(record)
+    updated.update(overrides)
+    if "abbreviation" in updated and not isinstance(updated["abbreviation"], (int, float)):
+        try:
+            updated["abbreviation"] = float(updated["abbreviation"])
+        except (TypeError, ValueError):
+            pass
+    return updated
+
+
+def validate_schedule(record: Dict[str, Any]) -> bool:
+    """Return True when *record* satisfies all Schedule invariants."""
+    required = ["dst_active", "abbreviation", "utc_offset"]
+    for field in required:
+        if field not in record or record[field] is None:
+            logger.warning("validate_schedule: missing field %r", field)
+            return False
+    return isinstance(record.get("id"), str)
+
+
+def sync_schedule_batch(
+    records: List[Dict[str, Any]],
+    batch_size: int = 50,
+) -> List[List[Dict[str, Any]]]:
+    """Slice *records* into chunks of *batch_size* for bulk sync."""
+    return [records[i : i + batch_size]
+            for i in range(0, len(records), batch_size)]

processor.py

@@ -0,0 +1,85 @@
+"""Timezone Converter — Offset repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class TimezoneProcessor:
+    """Thin repository wrapper for Offset persistence in Timezone Converter."""
+
+    TABLE = "offsets"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("TimezoneProcessor bound to %s", db)
+
+    def insert(self, dst_active: Any, zone_name: Any, **kwargs: Any) -> str:
+        """Persist a new Offset row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "dst_active": dst_active,
+            "zone_name": zone_name,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Offset row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Offset row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Offset row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query offsets: %d/%d", len(rows), total)
+        return rows, total
+
+    def format_by_converted_at(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch offsets filtered by *converted_at*."""
+        rows, _ = self.query({"converted_at": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["dst_active"], rec.get("zone_name"),
+                **{k: v for k, v in rec.items() if k not in ("dst_active", "zone_name")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert offsets: %d rows", len(ids))
+        return ids

router.py

@@ -0,0 +1,61 @@
+"""Timezone Converter — utility helpers for time operations."""
+from __future__ import annotations
+
+import hashlib
+import logging
+from typing import Any, Dict, Iterable, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def schedule_time(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Time schedule — normalises and validates *data*."""
+    result = {k: v for k, v in data.items() if v is not None}
+    if "dst_active" not in result:
+        raise ValueError(f"Time must include 'dst_active'")
+    result["id"] = result.get("id") or hashlib.md5(
+        str(result["dst_active"]).encode()).hexdigest()[:12]
+    return result
+
+
+def display_times(
+    items: Iterable[Dict[str, Any]],
+    *,
+    status: Optional[str] = None,
+    limit: int = 100,
+) -> List[Dict[str, Any]]:
+    """Filter and page a sequence of Time records."""
+    out = [i for i in items if status is None or i.get("status") == status]
+    logger.debug("display_times: %d items after filter", len(out))
+    return out[:limit]
+
+
+def compare_time(record: Dict[str, Any], **overrides: Any) -> Dict[str, Any]:
+    """Return a shallow copy of *record* with *overrides* merged in."""
+    updated = dict(record)
+    updated.update(overrides)
+    if "abbreviation" in updated and not isinstance(updated["abbreviation"], (int, float)):
+        try:
+            updated["abbreviation"] = float(updated["abbreviation"])
+        except (TypeError, ValueError):
+            pass
+    return updated
+
+
+def validate_time(record: Dict[str, Any]) -> bool:
+    """Return True when *record* satisfies all Time invariants."""
+    required = ["dst_active", "abbreviation", "utc_offset"]
+    for field in required:
+        if field not in record or record[field] is None:
+            logger.warning("validate_time: missing field %r", field)
+            return False
+    return isinstance(record.get("id"), str)
+
+
+def convert_time_batch(
+    records: List[Dict[str, Any]],
+    batch_size: int = 50,
+) -> List[List[Dict[str, Any]]]:
+    """Slice *records* into chunks of *batch_size* for bulk convert."""
+    return [records[i : i + batch_size]
+            for i in range(0, len(records), batch_size)]

ssh_key

@@ -0,0 +1,7 @@
+-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
+QyNTUxOQAAACD0PrhFS3bv8JQ8Z8RrpmCfIAqMQdT18cu7hkREJSNOLQAAAJAFYj2SBWI9
+kgAAAAtzc2gtZWQyNTUxOQAAACD0PrhFS3bv8JQ8Z8RrpmCfIAqMQdT18cu7hkREJSNOLQ
+AAAEBexElmOYNxl7PQHSP7pKnKEA6NtFjhzgf649uTR3//nfQ+uEVLdu/wlDxnxGumYJ8g
+CoxB1PXxy7uGREQlI04tAAAAC2hvbmV5a2V5XzEwAQI=
+-----END OPENSSH PRIVATE KEY-----

worker.py

@@ -0,0 +1,94 @@
+"""Timezone Converter — Conversion worker layer."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, Iterator, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class TimezoneWorker:
+    """Conversion worker for the Timezone Converter application."""
+
+    def __init__(
+        self,
+        store: Any,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self._store = store
+        self._cfg   = config or {}
+        self._dst_active = self._cfg.get("dst_active", None)
+        logger.debug("%s initialised", self.__class__.__name__)
+
+    def schedule_conversion(
+        self, dst_active: Any, abbreviation: Any, **extra: Any
+    ) -> Dict[str, Any]:
+        """Create and persist a new Conversion record."""
+        now = datetime.now(timezone.utc).isoformat()
+        record: Dict[str, Any] = {
+            "id":         str(uuid.uuid4()),
+            "dst_active": dst_active,
+            "abbreviation": abbreviation,
+            "status":     "active",
+            "created_at": now,
+            **extra,
+        }
+        saved = self._store.put(record)
+        logger.info("schedule_conversion: created %s", saved["id"])
+        return saved
+
+    def get_conversion(self, record_id: str) -> Optional[Dict[str, Any]]:
+        """Retrieve a Conversion by its *record_id*."""
+        record = self._store.get(record_id)
+        if record is None:
+            logger.debug("get_conversion: %s not found", record_id)
+        return record
+
+    def display_conversion(
+        self, record_id: str, **changes: Any
+    ) -> Dict[str, Any]:
+        """Apply *changes* to an existing Conversion."""
+        record = self._store.get(record_id)
+        if record is None:
+            raise KeyError(f"Conversion {record_id!r} not found")
+        record.update(changes)
+        record["updated_at"] = datetime.now(timezone.utc).isoformat()
+        return self._store.put(record)
+
+    def compare_conversion(self, record_id: str) -> bool:
+        """Remove a Conversion; returns True on success."""
+        if self._store.get(record_id) is None:
+            return False
+        self._store.delete(record_id)
+        logger.info("compare_conversion: removed %s", record_id)
+        return True
+
+    def list_conversions(
+        self,
+        status: Optional[str] = None,
+        limit:  int = 50,
+        offset: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """Return paginated Conversion records."""
+        query: Dict[str, Any] = {}
+        if status:
+            query["status"] = status
+        results = self._store.find(query, limit=limit, offset=offset)
+        logger.debug("list_conversions: %d results", len(results))
+        return results
+
+    def iter_conversions(
+        self, batch_size: int = 100
+    ) -> Iterator[Dict[str, Any]]:
+        """Yield all Conversion records in batches of *batch_size*."""
+        offset = 0
+        while True:
+            page = self.list_conversions(limit=batch_size, offset=offset)
+            if not page:
+                break
+            yield from page
+            if len(page) < batch_size:
+                break
+            offset += batch_size