WIP - Improved bctides

.gitignore

@@ -81,6 +81,7 @@ target/
 # Jupyter Notebook
 .ipynb_checkpoints
 
+
 # IPython
 profile_default/
 ipython_config.py
@@ -139,8 +140,16 @@ dmypy.json
 !.vscode/launch.json
 !.vscode/extensions.json
 *.code-workspace
+.windsurf/*
+.zed/*
 
 # Notebook data
 notebooks/tmp
 
 *.png
+
+**/**/schism_declaritive
+**/**/schism_demo_output
+**/**/model_run
+
+#any directory with schism_declarative in it

docs/source/cli.rst

@@ -0,0 +1,124 @@
+.. _cli:
+
+Command Line Interface
+======================
+
+The ROMPY Command Line Interface (CLI) provides a convenient way to run ocean, wave, and hydrodynamic models with configuration files.
+
+Basic Usage
+------------
+
+The basic syntax for running a model is:
+
+.. code-block:: bash
+
+    rompy <model> <config-file> [OPTIONS]
+
+Where:
+- ``<model>``: The type of model to run (e.g., swan, schism)
+- ``<config-file>``: Path to a YAML or JSON configuration file
+
+Available Models
+-----------------
+
+To list all available models, run:
+
+.. code-block:: bash
+
+    rompy --version
+
+This will display the ROMPY version and a list of available models.
+
+Options
+-------
+
+.. program:: rompy
+.. option:: --zip, --no-zip
+
+    Create a zip archive of the model files (default: False)
+
+.. option:: -v, --verbose
+
+    Increase verbosity (can be used multiple times for more detail)
+
+.. option:: --log-dir PATH
+
+    Directory to save log files
+
+.. option:: --show-warnings
+
+    Show Python warnings (default: False)
+
+.. option:: --ascii-only
+
+    Use ASCII-only characters in output (default: False)
+
+.. option:: --simple-logs
+
+    Use simple log format without timestamps and module names (default: False)
+
+.. option:: --version
+
+    Show version information and exit
+
+Examples
+--------
+
+Run a SWAN model with a configuration file:
+
+.. code-block:: bash
+
+    rompy swan config.yml
+
+Run with increased verbosity and save logs to a directory:
+
+.. code-block:: bash
+
+    rompy swan config.yml -v --log-dir ./logs
+
+Run with ASCII-only output and simple logging format:
+
+.. code-block:: bash
+
+    rompy swan config.yml --ascii-only --simple-logs
+
+Environment Variables
+----------------------
+
+You can set the following environment variables as an alternative to command-line options:
+
+- ``ROMPY_MODEL``: Default model to use
+- ``ROMPY_CONFIG``: Default configuration file
+- ``ROMPY_ZIP``: Set to "1" to enable zip output
+- ``ROMPY_LOG_DIR``: Directory for log files
+- ``ROMPY_ASCII_ONLY``: Set to "1" for ASCII-only output
+- ``ROMPY_SIMPLE_LOGS``: Set to "1" for simple log format
+
+Configuration File Format
+--------------------------
+
+The configuration file can be in either YAML or JSON format. The structure depends on the specific model being used. Refer to the model's documentation for details.
+
+Example YAML configuration:
+
+.. code-block:: yaml
+
+    model_type: "swan"
+    start_time: "2023-01-01T00:00:00"
+    end_time: "2023-01-02T00:00:00"
+    time_step: 3600
+    grid:
+        nx: 100
+        ny: 100
+        dx: 1000
+        dy: 1000
+    # Additional model-specific parameters...
+
+Exit Codes
+----------
+
+The CLI uses the following exit codes:
+
+- ``0``: Success
+- ``1``: Error running the model
+- ``2``: Invalid arguments or configuration

docs/source/core_concepts.rst

@@ -2,6 +2,11 @@
 Core Concepts
 =================================
 
+.. note::
+   For information about Rompy's formatting and logging system, see :doc:`formatting_and_logging`.
+
+   For details on using the command line interface, see :doc:`cli`.
+
 Rompy is a Python library for generating ocean model control files and required input
 data ready for ingestion into the model. The framework is separated into two broad
 concepts:
@@ -12,7 +17,7 @@ concepts:
     :toctree: _generated/
 
     rompy.model.ModelRun
-    rompy.core.BaseConfig
+    rompy.core.config.BaseConfig
 
 There is information about each of these in the documentation of each object, but at a
 high level, ModelRun is the high level framework that renders the config object and controls the

docs/source/formatting_and_logging.rst

@@ -0,0 +1,216 @@
+============================
+Formatting and Logging
+============================
+
+Overview
+--------
+
+ROMPY provides a comprehensive framework for consistent formatting and logging across the codebase. This framework ensures that:
+
+1. Log messages are consistent and configurable
+2. String representations of objects are clear and hierarchical
+3. Output formatting is visually appealing and consistent
+4. Configuration is flexible and environment-aware
+
+Core Components
+--------------
+
+The framework consists of several key components:
+
+1. **Centralized Logging System**
+   - Consistent log formatting and handling
+   - Environment variable configuration
+   - Multiple log levels and output formats
+
+2. **Hierarchical String Representation**
+   - Clean, readable output of complex objects
+   - Recursive handling of nested structures
+   - Type-specific formatting
+
+3. **Formatted Output**
+   - Boxes and visual elements
+   - Consistent headers and footers
+   - Progress indicators
+
+Logging System
+-------------
+
+ROMPY's logging system is built on Python's standard `logging` module but provides additional features and consistency.
+
+Basic Usage
+~~~~~~~~~~
+
+.. code-block:: python
+
+    from rompy.core.logging import get_logger
+
+    # Get a logger for your module
+    logger = get_logger(__name__)
+
+    # Log messages at different levels
+    logger.debug("Detailed debug information")
+    logger.info("Informational message")
+    logger.warning("Warning message")
+    logger.error("Error message")
+    logger.critical("Critical error")
+
+Configuration
+~~~~~~~~~~~~~
+
+Logging can be configured via environment variables:
+
+.. list-table::
+   :widths: 25 15 60
+   :header-rows: 1
+
+   * - Variable
+     - Default
+     - Description
+   * - ``ROMPY_LOG_LEVEL``
+     - ``INFO``
+     - Minimum log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+   * - ``ROMPY_LOG_FORMAT``
+     - ``detailed``
+     - Log format style (``simple`` or ``detailed``)
+   * - ``ROMPY_LOG_FILE``
+     - None
+     - Optional file path for log output
+
+Programmatic configuration is also available:
+
+.. code-block:: python
+
+    from rompy.core.logging import configure_logging
+
+    configure_logging(
+        level="DEBUG",
+        format="detailed",
+        log_file="rompy.log"
+    )
+
+Hierarchical String Representation
+--------------------------------
+
+All ROMPY models include a hierarchical string representation for better readability of complex objects.
+
+Basic Usage
+~~~~~~~~~~
+
+.. code-block:: python
+
+    class MyModel(RompyBaseModel):
+        name: str
+        value: float
+        nested: dict
+
+    obj = MyModel(name="test", value=42.0, nested={"a": 1, "b": 2})
+    print(obj)
+
+Output:
+
+.. code-block:: text
+
+    MyModel:
+      name: test
+      value: 42.0
+      nested:
+        a: 1
+        b: 2
+
+Custom Formatting
+~~~~~~~~~~~~~~~~
+
+Customize formatting by overriding the `_format_value` method:
+
+.. code-block:: python
+
+    class CustomModel(RompyBaseModel):
+        timestamp: datetime
+
+        def _format_value(self, obj: Any) -> Optional[str]:
+            if isinstance(obj, datetime):
+                return obj.strftime("%Y-%m-%d %H:%M")
+            return None
+
+Formatted Output
+---------------
+
+ROMPY provides utilities for creating consistent, visually appealing output.
+
+Boxes and Sections
+~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    from rompy.core.formatting import box, section
+
+    # Create a simple box
+    print(box("Important Message"))
+
+    # Create a section with content
+    print(section("Processing Results", ["Item 1", "Item 2", "Item 3"]))
+
+Progress Indicators
+~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    from rompy.core.formatting import ProgressBar
+    import time
+
+    with ProgressBar("Processing", total=100) as pbar:
+        for i in range(100):
+            time.sleep(0.1)
+            pbar.update(1)
+
+Best Practices
+-------------
+
+1. **Logging**
+   - Use appropriate log levels (DEBUG for detailed info, INFO for normal operations, etc.)
+   - Include relevant context in log messages
+   - Use structured logging for machine-readable output
+
+2. **String Representation**
+   - Keep string representations concise but informative
+   - Include all relevant attributes
+   - Handle nested objects appropriately
+
+3. **Formatting**
+   - Be consistent with formatting across the codebase
+   - Use the provided utilities for common formatting needs
+   - Consider readability in different output contexts (CLI, logs, etc.)
+
+Example Integration
+------------------
+
+Here's how these components work together in a typical ROMPY module:
+
+.. code-block:: python
+
+    from rompy.core.logging import get_logger
+    from rompy.core.formatting import section
+    from rompy.core.types import RompyBaseModel
+
+    logger = get_logger(__name__)
+
+    class DataProcessor(RompyBaseModel):
+        """Process data with logging and formatted output."""
+
+        def process(self, data):
+            logger.info("Starting data processing")
+
+            with section("Processing Data"):
+                # Process data here
+                logger.debug(f"Processing {len(data)} items")
+
+                # Log progress
+                for i, item in enumerate(data, 1):
+                    self._process_item(item)
+                    logger.debug(f"Processed item {i}/{len(data)}")
+
+            logger.info("Processing complete")
+
+        def _process_item(self, item):
+            # Process individual items
+            pass