etlplus 0.4.9__tar.gz → 0.5.2__tar.gz

etlplus-0.5.2/MANIFEST.in

@@ -0,0 +1,12 @@
+# MANIFEST.in
+# ETLPlus
+#
+# Copyright © 2026 Dagitali LLC. All rights reserved.
+#
+# Contains commands that allow lists of files to be discovered and manipulated.
+#
+# See:
+# 1. https://setuptools.pypa.io/en/latest/userguide/miscellaneous.html
+
+# Include Jinja template files in the etlplus package
+recursive-include etlplus/templates *.j2

{etlplus-0.4.9/etlplus.egg-info → etlplus-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: etlplus
-Version: 0.4.9
+Version: 0.5.2
 Summary: A Swiss Army knife for simple ETL operations
 Home-page: https://github.com/Dagitali/ETLPlus
 Author: ETLPlus Team
@@ -61,6 +61,8 @@ package and command-line interface for data extraction, validation, transformati
   - [Quickstart](#quickstart)
   - [Usage](#usage)
     - [Command Line Interface](#command-line-interface)
+      - [Inspect Pipelines](#inspect-pipelines)
+      - [Render SQL DDL](#render-sql-ddl)
       - [Extract Data](#extract-data)
       - [Validate Data](#validate-data)
       - [Transform Data](#transform-data)
@@ -169,6 +171,44 @@ etlplus --help
 etlplus --version
 ```
 
+#### Inspect Pipelines
+
+Use `etlplus list` to explore pipeline YAML definitions without running them. The command can print
+job names, summarize configured sources and targets, or drill into specific sections.
+
+List jobs and show a pipeline summary:
+```bash
+etlplus list --config examples/configs/pipeline.yml --jobs
+etlplus list --config examples/configs/pipeline.yml --summary
+```
+
+Show sources or transforms for troubleshooting:
+```bash
+etlplus list --config examples/configs/pipeline.yml --sources
+etlplus list --config examples/configs/pipeline.yml --transforms
+```
+
+#### Render SQL DDL
+
+Use `etlplus render` to turn table schema specs into ready-to-run SQL. Render from a pipeline config
+or from a standalone schema file, and choose the built-in `ddl` or `view` templates (or provide your
+own).
+
+Render all tables defined in a pipeline:
+```bash
+etlplus render --config examples/configs/pipeline.yml --template ddl
+```
+
+Render a single table in that pipeline:
+```bash
+etlplus render --config examples/configs/pipeline.yml --table customers --template view
+```
+
+Render from a standalone table spec to a file:
+```bash
+etlplus render --spec schemas/customer.yml --template view -o temp/customer_view.sql
+```
+
 #### Extract Data
 
 Note: For file sources, the format is normally inferred from the filename extension. Use

{etlplus-0.4.9 → etlplus-0.5.2}/README.md

@@ -19,6 +19,8 @@ package and command-line interface for data extraction, validation, transformati
   - [Quickstart](#quickstart)
   - [Usage](#usage)
     - [Command Line Interface](#command-line-interface)
+      - [Inspect Pipelines](#inspect-pipelines)
+      - [Render SQL DDL](#render-sql-ddl)
       - [Extract Data](#extract-data)
       - [Validate Data](#validate-data)
       - [Transform Data](#transform-data)
@@ -127,6 +129,44 @@ etlplus --help
 etlplus --version
 ```
 
+#### Inspect Pipelines
+
+Use `etlplus list` to explore pipeline YAML definitions without running them. The command can print
+job names, summarize configured sources and targets, or drill into specific sections.
+
+List jobs and show a pipeline summary:
+```bash
+etlplus list --config examples/configs/pipeline.yml --jobs
+etlplus list --config examples/configs/pipeline.yml --summary
+```
+
+Show sources or transforms for troubleshooting:
+```bash
+etlplus list --config examples/configs/pipeline.yml --sources
+etlplus list --config examples/configs/pipeline.yml --transforms
+```
+
+#### Render SQL DDL
+
+Use `etlplus render` to turn table schema specs into ready-to-run SQL. Render from a pipeline config
+or from a standalone schema file, and choose the built-in `ddl` or `view` templates (or provide your
+own).
+
+Render all tables defined in a pipeline:
+```bash
+etlplus render --config examples/configs/pipeline.yml --template ddl
+```
+
+Render a single table in that pipeline:
+```bash
+etlplus render --config examples/configs/pipeline.yml --table customers --template view
+```
+
+Render from a standalone table spec to a file:
+```bash
+etlplus render --spec schemas/customer.yml --template view -o temp/customer_view.sql
+```
+
 #### Extract Data
 
 Note: For file sources, the format is normally inferred from the filename extension. Use

{etlplus-0.4.9 → etlplus-0.5.2}/etlplus/cli/app.py

@@ -25,6 +25,7 @@ Subcommands
 - ``validate``: validate data against rules
 - ``transform``: transform records
 - ``load``: load data to files, databases, or REST APIs
+- ``render``: render SQL DDL from table schema specs
 
 Notes
 -----
@@ -60,6 +61,7 @@ from .handlers import cmd_extract
 from .handlers import cmd_list
 from .handlers import cmd_load
 from .handlers import cmd_pipeline
+from .handlers import cmd_render
 from .handlers import cmd_run
 from .handlers import cmd_transform
 from .handlers import cmd_validate
@@ -258,6 +260,67 @@ PipelineConfigOption = Annotated[
     ),
 ]
 
+RenderConfigOption = Annotated[
+    str | None,
+    typer.Option(
+        '--config',
+        metavar='PATH',
+        help='Pipeline YAML that includes table_schemas for rendering.',
+        show_default=False,
+    ),
+]
+
+RenderOutputOption = Annotated[
+    str | None,
+    typer.Option(
+        '--output',
+        '-o',
+        metavar='PATH',
+        help='Write rendered SQL to PATH (default: stdout).',
+    ),
+]
+
+RenderSpecOption = Annotated[
+    str | None,
+    typer.Option(
+        '--spec',
+        metavar='PATH',
+        help='Standalone table spec file (.yml/.yaml/.json).',
+        show_default=False,
+    ),
+]
+
+RenderTableOption = Annotated[
+    str | None,
+    typer.Option(
+        '--table',
+        metavar='NAME',
+        help='Filter to a single table name from table_schemas.',
+    ),
+]
+
+RenderTemplateOption = Annotated[
+    str,
+    typer.Option(
+        '--template',
+        '-t',
+        metavar='KEY|PATH',
+        help='Template key (ddl/view) or path to a Jinja template file.',
+        show_default=True,
+    ),
+]
+
+RenderTemplatePathOption = Annotated[
+    str | None,
+    typer.Option(
+        '--template-path',
+        metavar='PATH',
+        help=(
+            'Explicit path to a Jinja template file (overrides template key).'
+        ),
+    ),
+]
+
 
 # SECTION: DATA CLASSES ===================================================== #
 
@@ -1001,6 +1064,55 @@ def pipeline_cmd(
     return int(cmd_pipeline(ns))
 
 
+@app.command('render')
+def render_cmd(
+    ctx: typer.Context,
+    config: RenderConfigOption = None,
+    spec: RenderSpecOption = None,
+    table: RenderTableOption = None,
+    template: RenderTemplateOption = 'ddl',
+    template_path: RenderTemplatePathOption = None,
+    output: RenderOutputOption = None,
+) -> int:
+    """
+    Render SQL DDL from table schemas defined in YAML/JSON configs.
+
+    Parameters
+    ----------
+    ctx : typer.Context
+        Typer execution context provided to the command.
+    config : RenderConfigOption, optional
+        Pipeline YAML containing ``table_schemas`` entries.
+    spec : RenderSpecOption, optional
+        Standalone table spec file (.yml/.yaml/.json).
+    table : RenderTableOption, optional
+        Filter to a single table name within the available specs.
+    template : RenderTemplateOption, optional
+        Built-in template key or template file path.
+    template_path : RenderTemplatePathOption, optional
+        Explicit template file path to render with.
+    output : RenderOutputOption, optional
+        Path to write SQL to (stdout when omitted).
+
+    Returns
+    -------
+    int
+        Zero on success.
+    """
+    state = _ensure_state(ctx)
+    ns = _stateful_namespace(
+        state,
+        command='render',
+        config=config,
+        spec=spec,
+        table=table,
+        template=template,
+        template_path=template_path,
+        output=output,
+    )
+    return int(cmd_render(ns))
+
+
 @app.command('run')
 def run_cmd(
     ctx: typer.Context,

{etlplus-0.4.9 → etlplus-0.5.2}/etlplus/cli/handlers.py

@@ -18,6 +18,8 @@ from typing import cast
 
 from ..config import PipelineConfig
 from ..config import load_pipeline_config
+from ..ddl import load_table_spec
+from ..ddl import render_tables
 from ..enums import FileFormat
 from ..extract import extract
 from ..file import File
@@ -38,6 +40,7 @@ __all__ = [
     'cmd_list',
     'cmd_load',
     'cmd_pipeline',
+    'cmd_render',
     'cmd_run',
     'cmd_transform',
     'cmd_validate',
@@ -47,6 +50,37 @@ __all__ = [
 # SECTION: INTERNAL FUNCTIONS =============================================== #
 
 
+def _collect_table_specs(
+    config_path: str | None,
+    spec_path: str | None,
+) -> list[dict[str, Any]]:
+    """
+    Load table schemas from a pipeline config and/or standalone spec.
+
+    Parameters
+    ----------
+    config_path : str | None
+        Path to a pipeline YAML config file.
+    spec_path : str | None
+        Path to a standalone table spec file.
+
+    Returns
+    -------
+    list[dict[str, Any]]
+        Collected table specification mappings.
+    """
+    specs: list[dict[str, Any]] = []
+
+    if spec_path:
+        specs.append(load_table_spec(Path(spec_path)))
+
+    if config_path:
+        cfg = load_pipeline_config(config_path, substitute=True)
+        specs.extend(getattr(cfg, 'table_schemas', []))
+
+    return specs
+
+
 def _emit_json(
     data: Any,
     *,
@@ -75,6 +109,23 @@ def _emit_json(
     print(dumped)
 
 
+def _explicit_cli_format(
+    args: argparse.Namespace,
+) -> str | None:
+    """Return the explicit CLI format hint when provided."""
+
+    if not getattr(args, '_format_explicit', False):
+        return None
+    for attr in ('format', 'target_format', 'source_format'):
+        value = getattr(args, attr, None)
+        if value is None:
+            continue
+        normalized = value.strip().lower()
+        if normalized:
+            return normalized
+    return None
+
+
 def _infer_payload_format(
     text: str,
 ) -> str:
@@ -134,23 +185,6 @@ def _list_sections(
     return sections
 
 
-def _explicit_cli_format(
-    args: argparse.Namespace,
-) -> str | None:
-    """Return the explicit CLI format hint when provided."""
-
-    if not getattr(args, '_format_explicit', False):
-        return None
-    for attr in ('format', 'target_format', 'source_format'):
-        value = getattr(args, attr, None)
-        if value is None:
-            continue
-        normalized = value.strip().lower()
-        if normalized:
-            return normalized
-    return None
-
-
 def _materialize_file_payload(
     source: object,
     *,
@@ -224,7 +258,6 @@ def _parse_text_payload(
     JSONData | str
         The parsed payload as JSON data or raw text.
     """
-
     effective = (fmt or '').strip().lower() or _infer_payload_format(text)
     if effective == 'json':
         return cast(JSONData, json_type(text))
@@ -265,7 +298,8 @@ def _pipeline_summary(
 def _presentation_flags(
     args: argparse.Namespace,
 ) -> tuple[bool, bool]:
-    """Return presentation toggles from the parsed namespace.
+    """
+    Return presentation toggles from the parsed namespace.
 
     Parameters
     ----------
@@ -342,7 +376,6 @@ def _resolve_cli_payload(
         Parsed payload or the original source value when hydration is
         disabled.
     """
-
     if isinstance(source, (os.PathLike, str)) and str(source) == '-':
         text = _read_stdin_text()
         return _parse_text_payload(text, format_hint)
@@ -628,6 +661,67 @@ def cmd_pipeline(
     return 0
 
 
+def cmd_render(
+    args: argparse.Namespace,
+) -> int:
+    """Render SQL DDL statements from table schema specs."""
+
+    _pretty, quiet = _presentation_flags(args)
+
+    template_value = getattr(args, 'template', 'ddl') or 'ddl'
+    template_path = getattr(args, 'template_path', None)
+    table_filter = getattr(args, 'table', None)
+    spec_path = getattr(args, 'spec', None)
+    config_path = getattr(args, 'config', None)
+
+    # If the provided template points to a file, treat it as a path override.
+    file_override = template_path
+    template_key = template_value
+    if template_path is None:
+        candidate_path = Path(template_value)
+        if candidate_path.exists():
+            file_override = str(candidate_path)
+            template_key = None
+
+    specs = _collect_table_specs(config_path, spec_path)
+    if table_filter:
+        specs = [
+            spec
+            for spec in specs
+            if str(spec.get('table')) == table_filter
+            or str(spec.get('name', '')) == table_filter
+        ]
+
+    if not specs:
+        target_desc = table_filter or 'table_schemas'
+        print(
+            'No table schemas found for '
+            f'{target_desc}. Provide --spec or a pipeline --config with '
+            'table_schemas.',
+            file=sys.stderr,
+        )
+        return 1
+
+    rendered_chunks = render_tables(
+        specs,
+        template=template_key,
+        template_path=file_override,
+    )
+    sql_text = (
+        '\n'.join(chunk.rstrip() for chunk in rendered_chunks).rstrip() + '\n'
+    )
+
+    output_path = getattr(args, 'output', None)
+    if output_path and output_path != '-':
+        Path(output_path).write_text(sql_text, encoding='utf-8')
+        if not quiet:
+            print(f'Rendered {len(specs)} schema(s) to {output_path}')
+        return 0
+
+    print(sql_text)
+    return 0
+
+
 def cmd_list(args: argparse.Namespace) -> int:
     """
     Print requested pipeline sections from a YAML configuration.

{etlplus-0.4.9 → etlplus-0.5.2}/etlplus/cli/main.py

@@ -28,6 +28,7 @@ from .handlers import cmd_extract
 from .handlers import cmd_list
 from .handlers import cmd_load
 from .handlers import cmd_pipeline
+from .handlers import cmd_render
 from .handlers import cmd_run
 from .handlers import cmd_transform
 from .handlers import cmd_validate
@@ -441,6 +442,42 @@ def create_parser() -> argparse.ArgumentParser:
     )
     pipe_parser.set_defaults(func=cmd_pipeline)
 
+    render_parser = subparsers.add_parser(
+        'render',
+        help='Render SQL DDL from table schema specs',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    render_parser.add_argument(
+        '--config',
+        help='Pipeline YAML containing table_schemas',
+    )
+    render_parser.add_argument(
+        '-o',
+        '--output',
+        help='Write SQL to this path (stdout when omitted)',
+    )
+    render_parser.add_argument(
+        '--spec',
+        help='Standalone table spec file (.yml/.yaml/.json)',
+    )
+    render_parser.add_argument(
+        '--table',
+        help='Render only the table matching this name',
+    )
+    render_parser.add_argument(
+        '--template',
+        default='ddl',
+        help='Template key (ddl/view) or path to a Jinja template file',
+    )
+    render_parser.add_argument(
+        '--template-path',
+        dest='template_path',
+        help=(
+            'Explicit path to a Jinja template file (overrides template key).'
+        ),
+    )
+    render_parser.set_defaults(func=cmd_render)
+
     list_parser = subparsers.add_parser(
         'list',
         help='List ETL pipeline metadata',

{etlplus-0.4.9 → etlplus-0.5.2}/etlplus/config/pipeline.py

@@ -190,6 +190,8 @@ class PipelineConfig:
         Target connectors, parsed tolerantly.
     jobs : list[JobConfig]
         Job orchestration definitions.
+    table_schemas : list[dict[str, Any]]
+        Optional DDL-style table specifications used by the render command.
     """
 
     # -- Attributes -- #
@@ -208,6 +210,7 @@ class PipelineConfig:
     transforms: dict[str, dict[str, Any]] = field(default_factory=dict)
     targets: list[Connector] = field(default_factory=list)
     jobs: list[JobConfig] = field(default_factory=list)
+    table_schemas: list[dict[str, Any]] = field(default_factory=list)
 
     # -- Class Methods -- #
 
@@ -312,6 +315,13 @@ class PipelineConfig:
         # Jobs
         jobs = _build_jobs(raw)
 
+        # Table schemas (optional, tolerant pass-through structures).
+        table_schemas: list[dict[str, Any]] = []
+        for entry in raw.get('table_schemas', []) or []:
+            spec = maybe_mapping(entry)
+            if spec is not None:
+                table_schemas.append(dict(spec))
+
         return cls(
             name=name,
             version=version,
@@ -325,4 +335,5 @@ class PipelineConfig:
             transforms=transforms,
             targets=targets,
             jobs=jobs,
+            table_schemas=table_schemas,
         )