mooring-data-generator 0.11.0__py3-none-any.whl

mooring_data_generator/builder.py

@@ -0,0 +1,340 @@
+import json
+import logging
+import random
+from math import ceil
+
+from .models import BentData, BerthData, HookData, PortData, RadarData, ShipData
+
+logger = logging.getLogger(__name__)
+
+# A list of well-known Western Australian port names
+WA_PORT_NAMES: list[str] = [
+    "Port Hedland",
+    "Dampier",
+    "Fremantle",
+    "Kwinana",
+    "Bunbury",
+    "Esperance",
+    "Albany",
+    "Geraldton",
+    "Broome",
+    "Wyndham",
+    "Derby",
+    "Carnarvon",
+]
+
+
+NAUTICAL_SUPERLATIVES: list[str] = [
+    "Majestic",
+    "Sovereign",
+    "Resolute",
+    "Valiant",
+    "Vigilant",
+    "Dauntless",
+    "Liberty",
+    "Enduring",
+    "Gallant",
+    "Noble",
+    "Guardian",
+    "Intrepid",
+    "Courageous",
+    "Steadfast",
+    "Regal",
+    "Stalwart",
+    "Indomitable",
+    "Invincible",
+    "Triumphant",
+    "Victorious",
+    "Glorious",
+    "Fearless",
+    "Mighty",
+    "Bold",
+    "Brave",
+    "Formidable",
+    "Relentless",
+    "Valorous",
+    "Audacious",
+    "Diligent",
+    "Implacable",
+    "Indefatigable",
+    "Prosperous",
+    "Seaborne",
+    "Seagoing",
+    "Oceanic",
+    "Maritime",
+    "Coastal",
+    "Pelagic",
+    "Windward",
+    "Leeward",
+    "Tempestuous",
+    "Sturdy",
+]
+
+NAUTICAL_BASE_NAMES: list[str] = [
+    # Western
+    "Amelia",
+    "Charlotte",
+    "Olivia",
+    "Sophia",
+    "Emily",
+    "Grace",
+    # East Asian
+    "Hana",
+    "Mei",
+    "Yuna",
+    "Sakura",
+    "Aiko",
+    "Keiko",
+    # South Asian
+    "Asha",
+    "Priya",
+    "Anika",
+    "Riya",
+    "Sana",
+    "Neha",
+    # Southeast Asian
+    "Linh",
+    "Thao",
+    "Trang",
+    "Ngoc",
+    "Anh",
+    "Nicha",
+    # Latin (Spanish/Portuguese/LatAm)
+    "Camila",
+    "Valentina",
+    "Isabela",
+    "Gabriela",
+    "Lucia",
+    "Paula",
+]
+
+
+BENT_NAMES: list[str] = [f"BNT{x:03d}" for x in range(1, 999)]
+
+SHIP_IDS: list[str] = [f"{x:04d}" for x in range(1, 9999)]
+
+
+MEAN_TENSIONS = 6
+STDEV_TENSIONS = 5
+MEAN_DISTANCES = 9.38
+STDEV_DISTANCES = 6.73
+MEAN_CHANGES = 0.68
+STDEV_CHANGES = 2.6
+
+BENT_COUNT_MIN = 9
+BENT_COUNT_MAX = 15
+
+HOOK_COUNT_MULTIPLIER = 3
+
+
+def random_single_use_choice(list_of_strings: list[str]) -> str:
+    """Source a one-time random string from a list of strings"""
+    random_str = random.choice(list_of_strings)
+    list_of_strings.remove(random_str)
+    return random_str
+
+
+def random_ship_name() -> str:
+    """Generate a random ship name by combining a nautical superlative with a potential ship name.
+
+    The format will be "<Superlative> <Name>". Example: "Majestic Amelia" or "Valiant Sophia".
+    """
+    global NAUTICAL_SUPERLATIVES
+    global NAUTICAL_BASE_NAMES
+    return f"{random_single_use_choice(NAUTICAL_SUPERLATIVES)} {random_single_use_choice(NAUTICAL_BASE_NAMES)}"
+
+
+def random_wa_port_name() -> str:
+    """Return a random Western Australian port name.
+    Preventing the option from being selected in the future."""
+    global WA_PORT_NAMES
+    return random_single_use_choice(WA_PORT_NAMES)
+
+
+def random_bent_name() -> str:
+    """Return a random bent name."""
+    global BENT_NAMES
+    return random_single_use_choice(BENT_NAMES)
+
+
+def generate_ship() -> ShipData:
+    """Generate a ship data instance with unique random name and unique id"""
+    global SHIP_IDS
+    return ShipData(
+        name=random_ship_name(),
+        vessel_id=random_single_use_choice(SHIP_IDS),
+    )
+
+
+class HookWorker:
+    """a worker class for generating and managing changes in Hook data."""
+
+    def __init__(self, hook_number: int, attached_line: str):
+        self.name: str = f"Hook {hook_number}"
+        self.active: bool = random.choice([True, False, False])
+        # a 5% change of being in fault state
+        self.fault: bool = random.choices([True, False], weights=[0.05, 0.95])[0]
+        self.attached_line = None
+        self.tension = None
+        if self.active:
+            self.attached_line = attached_line
+            self.update()
+
+    def update(self):
+        if self.active:
+            self.tension = abs(ceil(random.gauss(MEAN_CHANGES, STDEV_CHANGES)))
+
+    @property
+    def data(self) -> HookData:
+        # noinspection PyTypeChecker
+        return HookData(
+            name=self.name,
+            tension=self.tension,
+            faulted=self.fault,
+            attached_line=self.attached_line,
+        )
+
+
+class BentWorker:
+    """a worker class for managing bents and cascading data"""
+
+    def __init__(self, bent_number: int, total_bents: int):
+        self.bent_number: int = bent_number
+        self.name = random_bent_name()
+        self.hooks: list[HookWorker] = []
+        bent_position = bent_number / total_bents
+        if bent_position < 0.2:
+            attached_line = "HEAD"
+        elif 0.8 < bent_position:
+            attached_line = "STERN"
+        elif 0.4 < bent_position < 0.6:
+            attached_line = "BREAST"
+        else:
+            attached_line = "SPRING"
+        hook_count_start: int = (
+            (self.bent_number * HOOK_COUNT_MULTIPLIER) - HOOK_COUNT_MULTIPLIER + 1
+        )
+        for hook_number in range(hook_count_start, hook_count_start + HOOK_COUNT_MULTIPLIER):
+            self.hooks.append(HookWorker(hook_number, attached_line=attached_line))
+
+    def update(self):
+        """update the bent and cascading data"""
+        for hook in self.hooks:
+            hook.update()
+
+    @property
+    def data(self) -> BentData:
+        return BentData(
+            name=self.name,
+            hooks=[hook.data for hook in self.hooks],
+        )
+
+
+class RadarWorker:
+    """a worker class for generating and managing changes in Radar data."""
+
+    def __init__(self, name: str):
+        self.name: str = name
+        self.active: bool = random.choice([True, False, False])
+        self.distance: float | None = None
+        self.change: float | None = None
+        if self.active:
+            self.distance: float = abs(random.gauss(MEAN_DISTANCES, STDEV_DISTANCES))
+            self.change: float = abs(random.gauss(MEAN_CHANGES, STDEV_CHANGES))
+
+    def update(self) -> tuple[float, float]:
+        if self.active:
+            new_distance: float = abs(random.gauss(MEAN_TENSIONS, STDEV_TENSIONS))
+            new_change: float = abs(self.distance - new_distance)
+            self.distance = new_distance
+            self.change = new_change
+        return self.distance, self.change
+
+    @property
+    def data(self) -> RadarData:
+        # noinspection PyTypeChecker
+        return RadarData(
+            name=self.name,
+            ship_distance=self.distance,
+            distance_change=self.change,
+            distance_status="ACTIVE" if self.active else "INACTIVE",
+        )
+
+
+class BerthWorker:
+    """a worker class for generating and managing changes in Berth data."""
+
+    def __init__(self, berth_code: str):
+        self.berth_code: str = berth_code
+        self.bent_count: int = random.randint(BENT_COUNT_MIN, BENT_COUNT_MAX)
+        self.hook_count: int = self.bent_count * HOOK_COUNT_MULTIPLIER
+        self.ship: ShipData = generate_ship()
+        self.radars: list[RadarWorker] = []
+        for radar_num in range(1, random.choice([5, 6, 6, 6]) + 1):
+            radar_name = f"B{berth_code}RD{radar_num}"
+            self.radars.append(RadarWorker(radar_name))
+
+        self.bents: list[BentWorker] = []
+        for bent_num in range(1, self.bent_count + 1):
+            self.bents.append(BentWorker(bent_num, self.bent_count))
+
+    @property
+    def name(self) -> str:
+        return f"Berth {self.berth_code}"
+
+    def update(self):
+        for radar in self.radars:
+            radar.update()
+        for bent in self.bents:
+            bent.update()
+
+    @property
+    def data(self) -> BerthData:
+        return BerthData(
+            name=self.name,
+            bent_count=self.bent_count,
+            hook_count=self.hook_count,
+            ship=self.ship,
+            radars=[radar.data for radar in self.radars],
+            bents=[bent.data for bent in self.bents],
+        )
+
+
+class PortWorker:
+    """a worker class for generating and managing change of ports"""
+
+    def __init__(self):
+        self.name: str = random_wa_port_name()
+        self.berth_count: int = random.randint(1, 8)
+        self.berths: list[BerthWorker] = []
+        for berth_num in range(1, self.berth_count + 1):
+            berth_code: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[berth_num]
+            self.berths.append(BerthWorker(berth_code))
+
+    def update(self):
+        for berth in self.berths:
+            berth.update()
+
+    @property
+    def data(self) -> PortData:
+        return PortData(
+            name=self.name,
+            berths=[berth.data for berth in self.berths],
+        )
+
+
+def build_random_port() -> PortWorker:
+    """Construct a `PortData` instance with a random WA port name."""
+    return PortWorker()
+
+
+def main() -> None:
+    """Generate a single random WA port and print it as JSON."""
+    port = build_random_port()
+    # Use Pydantic's by_alias to apply PascalCase field names from BasePayloadModel
+    payload = port.data.model_dump(by_alias=True)
+    logger.info(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

mooring_data_generator/cli.py

@@ -0,0 +1,56 @@
+import argparse
+import logging
+from pathlib import Path
+
+from . import file_worker, http_worker
+from .openapi import generate_openapi_spec
+
+logger = logging.getLogger(__name__)
+
+parser = argparse.ArgumentParser(description="Mooring data generator")
+parser.add_argument(
+    "url", nargs="?", help="HTTP endpoint URL (required if --file is not provided)"
+)
+parser.add_argument("--file", type=str, help="Path to output JSON file (e.g., path/filename.json)")
+parser.add_argument(
+    "--openapi",
+    action="store_true",
+    help="Output OpenAPI specification for the data output instead of running the generator",
+)
+
+
+def main() -> None:
+    """Run the cli tooling for mooring data generator"""
+    args = parser.parse_args()
+
+    # Handle --openapi flag
+    if args.openapi:
+        spec = generate_openapi_spec()
+        print(spec)
+        return
+
+    # Validate that either url or --file is provided
+    if not args.url and not args.file:
+        parser.error("Either url or --file must be provided")
+
+    if args.url and args.file:
+        parser.error("Cannot use both url and --file at the same time")
+
+    if args.file:
+        # Use file_worker
+        file_path = Path(args.file)
+        logger.info(f"Starting mooring data generator and will save to files: {file_path}")
+        print(f"Starting mooring data generator and will save to files: {file_path}")
+        print("Press CTRL+C to stop mooring data generator.")
+        file_worker.run(file_path)
+    else:
+        # Use http_worker
+        url: str = args.url
+        logger.info(f"Starting mooring data generator and will HTTP POST to {url}")
+        print(f"Starting mooring data generator and will HTTP POST to {url}")
+        print("Press CTRL+C to stop mooring data generator.")
+        http_worker.run(url)
+
+
+if __name__ == "__main__":
+    main()

mooring_data_generator/file_worker.py

@@ -0,0 +1,75 @@
+import json
+import logging
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+from .builder import build_random_port
+
+logger = logging.getLogger(__name__)
+
+
+def run(path: Path) -> None:
+    """Continuously generate port data and save to JSON files every 2 seconds.
+
+    - Builds a random port via builder.build_random_port(), store in variable `port`.
+    - Forever loop until interrupted (Ctrl+C):
+        - Generate filename using pattern: path.parent / f"{path.stem}_{timestamp}{path.suffix}"
+        - Save JSON payload from `port.data.model_dump(by_alias=True)` to the file.
+          If the file write fails, print a message to stdout and continue.
+        - Call `port.update()` to mutate the generated data for next iteration.
+        - Sleep for 2 seconds.
+
+    Args:
+        path: Pathlib Path object used to build the output filename pattern
+    """
+    port = build_random_port()
+    loops = 0
+    payloads = 1
+    try:
+        while True:
+            loops += 1
+            try:
+                print(f"    loop: {loops:<8} saving payload: {payloads}", end="\r")
+                payload = port.data.model_dump(by_alias=True)
+
+                # Build filename with timestamp
+                timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+                output_file = path.parent / f"{path.stem}_{timestamp}{path.suffix}"
+
+                # Ensure parent directory exists
+                output_file.parent.mkdir(parents=True, exist_ok=True)
+
+                # Write JSON to file
+                with open(output_file, "w", encoding="utf-8") as f:
+                    json.dump(payload, f, indent=2)
+
+                payloads += 1
+            except (OSError, IOError) as e:
+                # Notify stdout on failure but continue processing
+                logger.error(f"File write failed: {e}")
+
+            except Exception as e:
+                logger.error(f"Unknown Error: {e}")
+                logger.exception(e)
+            finally:
+                # Update model and wait regardless of write success
+                try:
+                    port.update()
+                except Exception as e:  # Defensive: updating should not kill the loop
+                    logger.error(f"Port update failed: {e}")
+                    logger.exception(e)
+                    raise e
+                time.sleep(2)
+    except KeyboardInterrupt:
+        # Graceful shutdown on Ctrl+C
+        logger.info("Interrupted by user. Exiting.")
+
+
+if __name__ == "__main__":
+    # Allow running this module directly: python -m mooring_data_generator.file_worker <PATH>
+    if len(sys.argv) != 2:
+        print("Usage: file_worker.py <PATH>")
+        sys.exit(1)
+    run(Path(sys.argv[1]))

mooring_data_generator/http_worker.py

@@ -0,0 +1,69 @@
+import json
+import logging
+import sys
+import time
+import urllib.error
+import urllib.request
+
+from .builder import build_random_port
+
+logger = logging.getLogger(__name__)
+
+
+def run(url: str) -> None:
+    """Continuously POST generated port data to the given URL every 2 seconds.
+
+    - Builds a random port via builder.build_random_port(), store in variable `port`.
+    - Forever loop until interrupted (Ctrl+C):
+        - Send JSON payload from `port.data.model_dump(by_alias=True)` to the URL.
+          If the HTTP request fails, print a message to stdout and continue.
+        - Call `port.update()` to mutate the generated data for next iteration.
+        - Sleep for 2 seconds.
+    """
+    port = build_random_port()
+    loops = 0
+    payloads = 1
+    try:
+        while True:
+            loops += 1
+            try:
+                print(f"    loop: {loops:<8} sending payload: {payloads}", end="\r")
+                payload = port.data.model_dump(by_alias=True)
+                data_bytes = json.dumps(payload).encode("utf-8")
+                req = urllib.request.Request(
+                    url,
+                    data=data_bytes,
+                    headers={"Content-Type": "application/json"},
+                    method="POST",
+                )
+                with urllib.request.urlopen(req, timeout=10) as resp:  # noqa: S310 (stdlib only)
+                    # We don't need to print on success; quietly proceed.
+                    _ = resp.read()
+                payloads += 1
+            except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError, OSError) as e:
+                # Notify stdout on failure but continue processing
+                logger.error(f"HTTP send failed: {e}")
+
+            except Exception as e:
+                logger.error(f"Unknown Error: {e}")
+                logger.exception(e)
+            finally:
+                # Update model and wait regardless of send success
+                try:
+                    port.update()
+                except Exception as e:  # Defensive: updating should not kill the loop
+                    logger.error(f"Port update failed: {e}")
+                    logger.exception(e)
+                    raise e
+                time.sleep(2)
+    except KeyboardInterrupt:
+        # Graceful shutdown on Ctrl+C
+        logger.info("Interrupted by user. Exiting.")
+
+
+if __name__ == "__main__":
+    # Allow running this module directly: python -m mooring_data_generator.http_worker <URL>
+    if len(sys.argv) != 2:
+        print("Usage: http_worker.py <URL>")
+        sys.exit(1)
+    run(sys.argv[1])

mooring_data_generator/models.py

@@ -0,0 +1,73 @@
+from typing import Annotated, Literal, TypedDict
+
+from pydantic import AliasGenerator, BaseModel, ConfigDict, Field, alias_generators
+
+
+class TensionLimits(TypedDict):
+    high_tension: int
+    medium_tension: int
+    low_tension: int
+
+
+TENSION_LIMITS: dict[str, TensionLimits] = {
+    "default": TensionLimits(
+        high_tension=24,
+        medium_tension=14,
+        low_tension=4,
+    ),
+    "Berth A": TensionLimits(
+        high_tension=25,
+        medium_tension=15,
+        low_tension=5,
+    ),
+}
+
+
+class BasePayloadModel(BaseModel):
+    model_config = ConfigDict(
+        alias_generator=AliasGenerator(
+            serialization_alias=alias_generators.to_pascal,
+        )
+    )
+
+
+class ShipData(BasePayloadModel):
+    name: str
+    vessel_id: Annotated[str, Field(pattern=r"^[0-9]{4}$")]
+
+
+class RadarData(BasePayloadModel):
+    name: Annotated[str, Field(pattern=r"^B[A-Z]RD[0-9]$")]
+    # Radar Should share the name of the Berth, Berth A Radar 1 = BARD1
+    ship_distance: Annotated[float, Field(ge=0, lt=100)] | None
+    # min 2.8 - 6.7 | max 3.4 - 30.7
+    distance_change: Annotated[float, Field(gt=-100, lt=100)] | None
+    # min 0.0007 - 0.06 | max 0.029 - 5.76
+    distance_status: Literal["INACTIVE", "ACTIVE"]
+
+
+class HookData(BasePayloadModel):
+    name: Annotated[str, Field(pattern=r"^Hook [1-9][0-9]?$")]
+    tension: Annotated[int, Field(ge=0, lt=99)] | None
+    faulted: bool
+    attached_line: Literal["BREAST", "HEAD", "SPRING", "STERN"] | None
+
+
+class BentData(BasePayloadModel):
+    name: Annotated[str, Field(pattern=r"^BNT[0-9]{3}$")]
+    # naming convention BNT + unique id
+    hooks: list[HookData]
+
+
+class BerthData(BasePayloadModel):
+    name: Annotated[str, Field(pattern=r"^Berth [A-Z]$")]
+    bent_count: Annotated[int, Field(gt=0, lt=40)]  # the count of bents: min 9 | max 15
+    hook_count: Annotated[int, Field(gt=0, lt=60)]  # the count of hooks: min 27 | max 48
+    ship: ShipData
+    radars: list[RadarData]
+    bents: list[BentData]
+
+
+class PortData(BasePayloadModel):
+    name: str  # the name of the port
+    berths: list[BerthData]

mooring_data_generator/openapi.py

@@ -0,0 +1,52 @@
+import json
+
+from .models import PortData
+
+
+def generate_openapi_spec() -> str:
+    """Generate an OpenAPI 3.0 specification for the mooring data output.
+
+    Returns:
+        JSON string of the OpenAPI specification
+    """
+    # Get the Pydantic model's JSON schema
+    port_schema = PortData.model_json_schema()
+
+    # Build OpenAPI 3.0 specification
+    openapi_spec = {
+        "openapi": "3.0.3",
+        "info": {
+            "title": "Mooring Data Generator API",
+            "description": "API specification for mooring data generated by mooring-data-generator",
+            "version": "1.0.0",
+        },
+        "paths": {
+            "/": {
+                "post": {
+                    "summary": "Receive mooring data",
+                    "description": "Endpoint that receives generated mooring data via HTTP POST",
+                    "requestBody": {
+                        "required": True,
+                        "content": {
+                            "application/json": {
+                                "schema": {"$ref": "#/components/schemas/PortData"}
+                            }
+                        },
+                    },
+                    "responses": {"200": {"description": "Successfully received mooring data"}},
+                }
+            }
+        },
+        "components": {"schemas": {}},
+    }
+
+    # Extract all schemas from the Pydantic model
+    # The model_json_schema() includes all nested models in $defs
+    if "$defs" in port_schema:
+        openapi_spec["components"]["schemas"] = port_schema["$defs"]
+
+    # Add the main PortData schema
+    port_data_schema = {k: v for k, v in port_schema.items() if k != "$defs"}
+    openapi_spec["components"]["schemas"]["PortData"] = port_data_schema
+
+    return json.dumps(openapi_spec, indent=2)

mooring_data_generator/receiver.py

@@ -0,0 +1,185 @@
+import argparse
+import json
+import sys
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+DEFAULT_PORT = 8000
+MAX_SHOW = 1024 * 1
+
+
+class PrintingRequestHandler(BaseHTTPRequestHandler):
+    """A very simple request handler that prints the full request and responds 200.
+
+    - Prints: client address, method, path, HTTP version, headers, and body (if any)
+    - Responds: 200 OK with a small text/plain body
+    - Avoids using any external packages
+    """
+
+    # Max bytes of body to show; set to None for full body
+    max_show: int = MAX_SHOW
+
+    # Format mode: None for default, "json" for JSON output
+    format_mode: bool = False
+
+    # Disable default logging to stderr; we print our own structured output
+    def log_message(self, format: str, *args) -> None:  # noqa: A003 - match BaseHTTPRequestHandler
+        return
+
+    def _read_body(self) -> bytes:
+        length = int(self.headers.get("Content-Length", 0) or 0)
+        if length > 0:
+            return self.rfile.read(length)
+        return b""
+
+    def _print_body(self, body: bytes, content_type: str) -> None:
+        """Safely limit body printout size (unless max_show is None"""
+        if self.format_mode:
+            if content_type == "application/json":
+                body = json.dumps(json.loads(body.decode("utf-8")), indent=2).encode("utf-8")
+        if self.max_show is None:
+            shown = body
+        else:
+            shown = body[: self.max_show]
+        try:
+            print(shown.decode("utf-8", errors="replace"))
+        except Exception as e:
+            print(f"-- {e}")
+            print(repr(shown))
+        if self.max_show is not None and len(body) > self.max_show:
+            print(f"-- {len(body) - self.max_show} more bytes not shown --")
+
+    def _print_request(self, body: bytes) -> None:
+        """print the request to stdoutmo"""
+        # First line
+        http_version = {
+            9: "HTTP/0.9",
+            10: "HTTP/1.0",
+            11: "HTTP/1.1",
+        }.get(self.protocol_version_number(), self.protocol_version)
+
+        client_host, client_port = self.client_address
+        print("=" * 80)
+        print(f"Client: {client_host}:{client_port}")
+        print(f"Request: {self.command} {self.path} {http_version}")
+        print("-- Headers --")
+        for k, v in self.headers.items():
+            print(f"{k}: {v}")
+        if body:
+            print("-- Body (bytes) --")
+            content_type = self.headers.get("Content-Type", "")
+            self._print_body(body, content_type)
+        else:
+            print("-- No Body --")
+        print("=" * 80)
+        sys.stdout.flush()
+
+    def _respond_ok(self) -> None:
+        message = b"OK\n"
+        self.send_response(200, "OK")
+        self.send_header("Content-Type", "text/plain; charset=utf-8")
+        self.send_header("Content-Length", str(len(message)))
+        self.end_headers()
+        self.wfile.write(message)
+
+    # Map common methods to the same handler
+    def do_GET(self) -> None:  # noqa: N802 - required by BaseHTTPRequestHandler
+        body = self._read_body()
+        self._print_request(body)
+        self._respond_ok()
+
+    def do_POST(self) -> None:  # noqa: N802
+        body = self._read_body()
+        self._print_request(body)
+        self._respond_ok()
+
+    def do_PUT(self) -> None:  # noqa: N802
+        body = self._read_body()
+        self._print_request(body)
+        self._respond_ok()
+
+    def do_PATCH(self) -> None:  # noqa: N802
+        body = self._read_body()
+        self._print_request(body)
+        self._respond_ok()
+
+    def do_DELETE(self) -> None:  # noqa: N802
+        body = self._read_body()
+        self._print_request(body)
+        self._respond_ok()
+
+    def do_OPTIONS(self) -> None:  # noqa: N802
+        # Minimal CORS-friendly response
+        self.send_response(200, "OK")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "*, Content-Type, Authorization")
+        self.end_headers()
+
+    # Helper to expose numeric protocol version (for display)
+    def protocol_version_number(self) -> int:
+        try:
+            return int(self.protocol_version.split("/")[-1].replace(".", ""))
+        except Exception:
+            return 11  # assume HTTP/1.1 if unknown
+
+
+def serve(port: int = DEFAULT_PORT, host: str = "0.0.0.0") -> tuple[str, int]:
+    """Start the HTTP server and block forever.
+
+    Returns the actual bound address (host, port). Useful when passing port=0.
+    """
+    server = ThreadingHTTPServer((host, port), PrintingRequestHandler)
+    bound_host, bound_port = server.server_address
+    print(f"Listening on http://{bound_host}:{bound_port} (press Ctrl+C to stop)")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("Shutting down...")
+    finally:
+        server.server_close()
+    return bound_host, bound_port
+
+
+def cli(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="Simple HTTP request printer")
+    parser.add_argument(
+        "--port",
+        "-p",
+        type=int,
+        default=DEFAULT_PORT,
+        help=f"Port to listen on (default: {DEFAULT_PORT})",
+    )
+    parser.add_argument(
+        "--host",
+        "-H",
+        default="0.0.0.0",
+        help="Host/interface to bind (default: 0.0.0.0)",
+    )
+    parser.add_argument(
+        "--full",
+        action="store_true",
+        help="Print full request bodies without truncation",
+    )
+    parser.add_argument(
+        "--format",
+        action="store_true",
+        help="Output format for request content (json uses json.dumps, otherwise content as received)",
+    )
+
+    args = parser.parse_args(argv)
+
+    # Configure handler truncation behavior
+    if args.full:
+        PrintingRequestHandler.max_show = None  # show full body
+    else:
+        PrintingRequestHandler.max_show = MAX_SHOW
+
+    # Configure output format
+    if args.format:
+        PrintingRequestHandler.format_mode = args.format
+
+    serve(port=args.port, host=args.host)
+
+
+if __name__ == "__main__":
+    cli()

mooring_data_generator-0.11.0.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.3
+Name: mooring-data-generator
+Version: 0.11.0
+Summary: Random-data generator to simulate fictional port data flows for use at a Hackathon
+Author: Ben Fitzhardinge
+Author-email: Ben Fitzhardinge <ben@benjamin.dog>
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing :: Traffic Generation
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: pydantic>=2.8
+Maintainer: Ben Fitzhardinge
+Maintainer-email: Ben Fitzhardinge <ben@benjamin.dog>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Mooring Data Generator
+
+A simple script to generate fake mooring data for use in a hackathon.
+This script will send data payloads to and endpoint to simulate the data which might exist.
+
+These will be http POST queries to the url provided as an argument at run time.
+
+The script will run forever until the user sends a Ctrl+C command to end the script.
+
+## Install
+
+### With UV (recommended)
+
+If you don't have UV on your system, read [the install instructions for UV](https://docs.astral.sh/uv/getting-started/installation/)
+
+```shell
+uv tool install -U mooring-data-generator
+```
+
+### Vanilla python (If you don't want UV)
+
+```shell
+pip install -U mooring-data-generator
+```
+
+## Usage
+
+### Running the package
+
+#### Sending data via HTTP POST
+
+```shell
+mooring-data-generator http://127.0.0.1:8000/my/endpoint/
+```
+
+> [!IMPORTANT]
+> replace `http://127.0.0.1:8000/my/endpoint/` with the appropriate url for your system
+
+#### Saving data to a file
+
+You can also save the generated mooring data to a JSON file instead of sending it via HTTP:
+
+```shell
+mooring-data-generator --file output.json
+```
+
+This will continuously generate mooring data and save it to the specified file.
+
+> [!NOTE]
+> You can only use either the URL (HTTP POST) or `--file` option, not both at the same time
+
+#### Getting the OpenAPI specification
+
+You can output an OpenAPI 3.0 specification for the mooring data format:
+
+```shell
+mooring-data-generator --openapi
+```
+
+This will print a complete OpenAPI specification in JSON format
+that describes the structure of the mooring data being generated.
+This is useful for:
+
+- Understanding the data format
+- Generating client libraries
+- API documentation
+- Integration planning
+
+The specification can be saved to a file for use with OpenAPI tools:
+
+```shell
+mooring-data-generator --openapi > openapi.json
+```
+
+## Testing data is being sent
+
+There's a helper application included in this package
+to allow you to check that the data is being sent.
+
+`mooring-data-receiver` will display to the console all http traffic it receives.
+
+```shell
+mooring-data-receiver
+```
+
+By default it will run listening to any traffic `0.0.0.0` on port `8000`
+
+You can adjust this if needed by using a commend like
+
+```shell
+mooring-data-receiver --host 127.0.0.1 --port 5000
+```
+
+### Formatting output
+
+You can use the `--format` flag to control how the request body is displayed:
+
+```shell
+mooring-data-receiver --format
+```
+
+When `--format` is used, the request body content
+will be formatted using `json.dumps(indent=2)` for better readability.
+Without this flag, the content is displayed as received.
+
+## Troubleshooting
+
+### Command not found
+
+If you are having trouble with the command not being found,
+you can attempt to run it as a module calling python
+
+```shell
+python -m mooring-data-generator http://127.0.0.1:8000/my/endpoint/
+```
+
+### Pip not found
+
+If `pip` can't be found on your system.
+
+First, make sure you have Python installed.
+
+```shell
+python --version
+```
+
+you can call `pip` from python directly as a module.
+
+```shell
+python -m pip install -U mooring-data-generator
+```
+
+## Release a new version
+
+### Be sure the tests pass
+
+```shell
+uv sync --all-groups
+uv run ruff format
+uv run ruff check
+uv run tox
+```
+
+### bump version and tag new release
+
+```shell
+uv version --bump minor
+git commit -am "Release version v$(uv version --short)"
+git tag -a "v$(uv version --short)" -m "v$(uv version --short)"
+```
+
+### push to github
+
+```shell
+git push
+git push --tags
+```

mooring_data_generator-0.11.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+mooring_data_generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mooring_data_generator/builder.py,sha256=CzNLpNvBaRDWfcbNFdiL-HFqLK5a4xoCn3dLzmNo9NQ,9096
+mooring_data_generator/cli.py,sha256=H6jILYMEa6M-cwmHuD1UhGqSbiiH4FRQ8RxUtxxfa1Q,1821
+mooring_data_generator/file_worker.py,sha256=PbXF7oWNaqsUCFzxRK5QETg6oDtHl7cUNYqWa8cyw5g,2721
+mooring_data_generator/http_worker.py,sha256=4Aa9jkpNAOIXZFJtfUI8Orn2RmZE2UDmsiRV6-Pd56Y,2586
+mooring_data_generator/models.py,sha256=TaJcnZ5SAzhgmaIdrZAMuzB_pUQqJtK04OcIgomb3aI,2087
+mooring_data_generator/openapi.py,sha256=zLkBYRu5n0RuoTkoUwGx4zEGKSWktbFoQ86AXGoisvk,1799
+mooring_data_generator/receiver.py,sha256=IevBKmdJket4qMb4zW41GDeBSjvyDriBJDjmyHIVFtg,6186
+mooring_data_generator-0.11.0.dist-info/WHEEL,sha256=DpNsHFUm_gffZe1FgzmqwuqiuPC6Y-uBCzibcJcdupM,78
+mooring_data_generator-0.11.0.dist-info/entry_points.txt,sha256=ZfpADZ8zW3FjJOgNafj14t_Va-Ga0ddlL9WEAYXHnjM,136
+mooring_data_generator-0.11.0.dist-info/METADATA,sha256=ivbU4yLIxvbv_j914a7Spip9HzautsxYvBs4bC7h-pM,4369
+mooring_data_generator-0.11.0.dist-info/RECORD,,

mooring_data_generator-0.11.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.8
+Root-Is-Purelib: true
+Tag: py3-none-any

mooring_data_generator-0.11.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+mooring-data-generator = mooring_data_generator.cli:main
+mooring-data-receiver = mooring_data_generator.receiver:cli
+