fabricks 3.0.5.2__tar.gz → 3.0.7__tar.gz

{fabricks-3.0.5.2 → fabricks-3.0.7}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: fabricks
-Version: 3.0.5.2
+Version: 3.0.7
 Author-email: BMS DWH Team <bi_support@bmsuisse.ch>
 Requires-Python: <4,>=3.9
 Requires-Dist: azure-data-tables<13,>=12.5.0
 Requires-Dist: azure-identity>=1.10.0
 Requires-Dist: azure-storage-blob>=12.14.1
 Requires-Dist: azure-storage-queue<13,>=12.10.0
+Requires-Dist: databricks-cli>=0.18.0
 Requires-Dist: databricks-sdk>=0.20.0
 Requires-Dist: importlib-metadata>=8.6.1
 Requires-Dist: jinja2>=2.11.3

{fabricks-3.0.5.2 → fabricks-3.0.7}/docs/helpers/init.md

@@ -1,36 +1,36 @@
-# Initialize Fabricks
+# Initialize Fabricks
 
 This helper explains how to initialize Fabricks on a Databricks cluster or local environment by:
 
 - Installing the Fabricks library
 - Pointing Fabricks to your runtime
-- Running the armageddon script to bootstrap metadata and objects
+- Running the ``armageddon`` script to bootstrap metadata and objects
 
 ## 1) Install Fabricks
 
 You need the Fabricks package available on your cluster or local environment.
 
 - Databricks cluster (recommended)
-  - Libraries → Install new → Python PyPI → fabricks (or install a wheel/artifact you build)
+  - Libraries → Install new → Python PyPI → `fabricks` (or install a wheel/artifact you build)
   - Alternatively, attach a workspace library artifact built from this repository
 
 - Local development (optional)
-  - pip install fabricks
-  - or from source (for development): pip install -e .[dev,test]
+  - `pip install fabricks`
+  - or from source (for development): `pip install -e .[dev,test]`
 
 Python >=3.9,<4 is recommended; align with your Databricks LTS runtime.
 
 ## 2) Point Fabricks to your runtime
 
-Fabricks discovers its runtime via either environment variables or [tool.fabricks] in your pyproject.toml. The core lookup logic is implemented in fabricks/context/runtime.py.
+Fabricks discovers its runtime via either environment variables or `[tool.fabricks]` in your `pyproject.toml`. The core lookup logic is implemented in `fabricks/context/runtime.py`.
 
-*Option A*: Configure via pyproject.toml (preferred for repo-managed projects):
+*Option A*: Configure via `pyproject.toml` (preferred for repo-managed projects):
 ```toml
 [tool.fabricks]
 runtime = "path/to/your/runtime"                   # e.g., tests/integration/runtime or examples/runtime
 notebooks = "fabricks/api/notebooks"               # optional: helpers shipped with Fabricks
 job_config_from_yaml = true                        # optional
-loglevel = "info"                                  # optional: DEBUG|INFO|WARNING|ERROR|CRITICAL
+loglevel = "info"                                  # optional: `DEBUG`|`INFO`|`WARNING`|`ERROR`|`CRITICAL`
 debugmode = false                                  # optional
 config = "path/to/your/runtime/fabricks/conf.fabricks.yml"  # main runtime YAML
 ```
@@ -42,16 +42,12 @@ config = "path/to/your/runtime/fabricks/conf.fabricks.yml"  # main runtime YAML
 # FABRICKS_CONFIG: full path to your main conf.fabricks.yml (if not set, Fabricks tries to infer a conf.uc.<orgId>.yml)
 # FABRICKS_NOTEBOOKS: optional helper notebook path
 # FABRICKS_IS_JOB_CONFIG_FROM_YAML, FABRICKS_LOGLEVEL, FABRICKS_IS_DEBUGMODE: optional toggles
-```
-
-Example on Databricks (Cluster → Configuration → Advanced options → Environment variables):
+```Example\non Databricks (Cluster → Configuration → Advanced options → Environment variables):
 ```
 FABRICKS_RUNTIME=/Workspace/Repos/your/repo/examples/runtime
 FABRICKS_CONFIG=/Workspace/Repos/your/repo/examples/runtime/fabricks/conf.fabricks.yml
 FABRICKS_LOGLEVEL=INFO
-```
-
-You can also set env vars in a notebook before importing Fabricks:
+```You\ncan also set env vars in a notebook before importing Fabricks:
 ```python
 import os
 os.environ["FABRICKS_RUNTIME"] = "/Workspace/Repos/your/repo/examples/runtime"
@@ -60,20 +56,20 @@ os.environ["FABRICKS_CONFIG"] = "/Workspace/Repos/your/repo/examples/runtime/fab
 # os.environ["FABRICKS_LOGLEVEL"] = "INFO"
 ```
 
-## 3) Run armageddon
+## 3) Run ``armageddon``
 
-armageddon performs a one-shot setup aligned with your runtime configuration (e.g., preparing databases/metadata, registering views).
+``armageddon`` performs a one-time setup based on your runtime configuration (e.g., preparing databases/metadata, registering views).
 
 Import and call:
 ```python
 # Databricks or local
-from fabricks.core.scripts.armageddon import armageddon
+from fabricks.core.scripts.`armageddon` import `armageddon`
 
-# You may pass one or more steps (bronze, silver, gold, semantic, transf, ...)
+# You may pass one or more steps (`bronze`, `silver`, `gold`, `semantic`, `transf`, ...)
 # Examples:
-armageddon(steps="gold")                      # single step
-armageddon(steps=["bronze", "silver", "gold"])  # multiple steps
-armageddon(steps=None)                        # default behavior, follow runtime config
+`armageddon`(steps="gold")                      # single step
+`armageddon`(steps=["bronze", "silver", "gold"])  # multiple steps
+`armageddon`(steps=None)                        # default behavior, follow runtime config
 ```
 
 ## Example: Databricks Notebook: Initialize
@@ -87,30 +83,29 @@ Create a new notebook (Python) named initialize and include:
 # os.environ["FABRICKS_CONFIG"] = "/Workspace/Repos/your/repo/examples/runtime/fabricks/conf.fabricks.yml"
 # os.environ["FABRICKS_LOGLEVEL"] = "INFO"
 
-from fabricks.core.scripts.armageddon import armageddon
+from fabricks.core.scripts.`armageddon` import `armageddon`
 # Run for all default steps from your runtime config:
-armageddon()
-```
-
-Attach the Fabricks library to the cluster before running the notebook.
+`armageddon`()
+```Attach\nthe Fabricks library to the cluster before running the notebook.
 
 ## Troubleshooting
 
 - Missing env/config:
-  - ValueError: Must have at least a pyproject.toml or set FABRICKS_RUNTIME
-  - Fix by setting FABRICKS_RUNTIME or adding [tool.fabricks] to pyproject.toml
+  - `ValueError`: Must have at least a `pyproject.toml` or set `FABRICKS_RUNTIME`
+  - Fix by setting `FABRICKS_RUNTIME` or adding `[tool.fabricks]` to `pyproject.toml`
 
 - Unity Catalog:
-  - Ensure options.unity_catalog is true and options.catalog is set in conf.fabricks.yml
+  - Ensure `options.unity_catalog` is true and `options.catalog` is set in `conf.fabricks.yml`
 
 - Paths and storage:
-  - conf.fabricks.yml must define path_options.storage and per-step runtime/storage paths; Fabricks uses these to resolve PATHS_RUNTIME and PATHS_STORAGE
+  - `conf.fabricks.yml` must define `path_options.storage` and per-step runtime/storage paths; Fabricks uses these to resolve `PATHS_RUNTIME` and `PATHS_STORAGE`
 
 - Logging:
-  - Set FABRICKS_LOGLEVEL or tool.fabricks.loglevel to control verbosity
+  - Set `FABRICKS_LOGLEVEL` or `tool.fabricks.loglevel` to control verbosity
 
 ## Related topics
 
-- Runtime configuration: ../helpers/runtime.md
-- Step Helper: ./step.md
-- Job Helper: ./job.md
+- Runtime configuration: `../helpers/runtime.md`
+- Step Helper: `./step.md`
+- Job Helper: `./job.md`
+

{fabricks-3.0.5.2 → fabricks-3.0.7}/docs/helpers/job.md

@@ -1,4 +1,4 @@
-# Job Helper
+# Job Helper
 
 This helper describes a widget-driven approach to manage a Fabricks job.
 
@@ -24,7 +24,7 @@ j.run()
 # Other common operations:
 j.update_schema()
 j.overwrite_schema()
-j.register()
+j.`register`()
 
 j.create()
 
@@ -59,17 +59,17 @@ dbutils.widgets.multiselect(
     "run",
     [
         "drop",                   -- Drop the job
-        "register",               -- Register the table
+        "`register`",               -- Register the table
         "create",                 -- Create the job
         "truncate",               -- Truncate the table
         "run",                    -- Run the job 
         "for-each-run",           -- Run the job (excluding the invoker(s) and the check(s))
         "overwrite",              -- Overwrite the schema and run the job
-        "pre-run-invoke",         -- Run the pre-run invoker(s)
+        "pre-run-`invoke`",         -- Run the pre-run invoker(s)
         "pre-run-check",          -- Run the pre-run check(s)
-        "post-run-invoke",        -- Run the post-run invoker(s)
+        "post-run-`invoke`",        -- Run the post-run invoker(s)
         "post-run-check",         -- Run the post-run check(s)
-        "update-schema",          -- Update the schema
+        "`update`-schema",          -- Update the schema
         "overwrite-schema",       -- Overwrite the schema
     ],
     label="5 - Action(s)"
@@ -125,10 +125,7 @@ from fabricks.core.jobs import Gold  # noqa: E402
 actions = dbutils.widgets.get("actions").split(",")
 actions = [a.strip() for a in actions]
 
-# COMMAND ----------
-
-
-def do(job: str) -> None:
+# COMMAND ----------`n`ndef do(job: str) -> None:
     j = get_job(job=job)
     todos: dict[str, Callable] = {}
 
@@ -139,11 +136,11 @@ def do(job: str) -> None:
     if "drop" in actions:
         todos["drop"] = j.drop
 
-    if "register" in actions:
-        todos["register"] = j.register
+    if "`register`" in actions:
+        todos["`register`"] = j.`register`
 
-    if "pre-run-invoke" in actions:
-        todos["pre-run-invoke"] = j.invoke_pre_run
+    if "pre-run-`invoke`" in actions:
+        todos["pre-run-`invoke`"] = j.invoke_pre_run
 
     if "pre-run-check" in actions:
         todos["pre-run-check"] = j.check_pre_run
@@ -151,8 +148,8 @@ def do(job: str) -> None:
     if "create" in actions:
         todos["create"] = j.create
 
-    if "update-schema" in actions:
-        todos["update-schema"] = j.update_schema
+    if "`update`-schema" in actions:
+        todos["`update`-schema"] = j.update_schema
 
     if "overwrite-schema" in actions:
         todos["overwrite-schema"] = j.overwrite_schema
@@ -172,8 +169,8 @@ def do(job: str) -> None:
     if "post-run-check" in actions:
         todos["post-run-check"] = j.check_post_run
 
-    if "post-run-invoke" in actions:
-        todos["post-run-invoke"] = j.invoke_post_run
+    if "post-run-`invoke`" in actions:
+        todos["post-run-`invoke`"] = j.invoke_post_run
 
     for key, func in todos.items():
         func()
@@ -185,7 +182,7 @@ jobs = [s.strip() for s in dbutils.widgets.get("jobs").split(",")]
 jobs = [[j.strip() for j in job.split("//")] if "//" in job else job for job in jobs]
 
 for job in jobs:
-    DEFAULT_LOGGER.warning(", ".join(actions), extra={"job": job})
+    DEFAULT_LOGGER.warning(", ".join(actions), extra={"label": job})
 
 # COMMAND ----------
 
@@ -203,8 +200,9 @@ dbutils.notebook.exit("exit (0)")  # type: ignore
 
 ## Related topics
 
-- Steps: [Bronze](../steps/bronze.md) • [Silver](../steps/silver.md) • [Gold](../steps/gold.md)
+- Steps: [Bronze](../steps/bronze.md) | [Silver](../steps/silver.md) | [Gold](../steps/gold.md)
 - Runtime overview and sample runtime: [Runtime](../helpers/runtime.md)
 - Checks & Data Quality: [Checks and Data Quality](../reference/checks-data-quality.md)
 - Table options and storage layout: [Table Options](../reference/table-options.md)
 - Extenders, UDFs & Views: [Extenders, UDFs & Views](../reference/extenders-udfs-parsers.md)
+

{fabricks-3.0.5.2 → fabricks-3.0.7}/docs/helpers/runtime.md

@@ -1,4 +1,4 @@
-# Runtime Configuration
+# Runtime Configuration
 
 The Fabricks runtime is the folder where your Lakehouse project lives (configs, SQL, jobs, UDFs, extenders, views). This page explains how to point Fabricks to your runtime, how to structure it, and how to configure schedules and step paths.
 
@@ -19,7 +19,7 @@ This quick path gets a working runtime running end-to-end using the sample inclu
   ```
 
 2) Inspect the sample runtime
-- Directory: `examples/runtime` (see structure in “Sample runtime” below).
+- Directory: `examples/runtime` (see structure in “Sample runtime” below).
 - It contains a minimal schedule and a Gold `hello_world.sql` full-refresh job.
 
 3) Run a schedule
@@ -29,11 +29,11 @@ This quick path gets a working runtime running end-to-end using the sample inclu
 Expected outputs
 - Tables/views:
   - A Gold table for the `hello_world` job (full refresh).
-  - If using memory mode jobs, temporary views are registered for downstream steps.
+  - If using ``memory`` mode jobs, temporary views are registered for downstream steps.
 - Logs:
   - A completion line indicating job success; warnings/errors surfaced from checks/contracts if configured.
 - Data quality (if enabled):
-  - Built-in bound violations or contract `__action = 'fail'` causes a non‑zero exit and, for physical tables, an automatic rollback to the last successful version.
+  - Built-in bound violations or contract `__action = 'fail'` causes a nonâ€'zero exit and, for physical tables, an automatic rollback to the last successful version.
   - Contract `__action = 'warning'` logs the message and the run continues.
 
 Tip: If your environment uses different storage locations or workspace setup, adjust `path_options` and `spark_options` in the runtime YAML before running.
@@ -99,9 +99,7 @@ gold:
     path_options:
       runtime: src/steps/gold
       storage: abfss://gold@youraccount.blob.core.windows.net
-```
-
-Key concepts:
+```Key\nconcepts:
 - options: global project config (secrets, timeouts, worker count)
 - path_options: shared storage/config paths
 - spark_options: default Spark SQL options applied for jobs
@@ -136,9 +134,7 @@ Schedules group jobs and define step order. Place schedules in your runtime (com
       variables:
         var1: 1
         var2: 2
-```
-
-Pass the schedule name when running the shipped notebooks or the Databricks bundle job.
+```Pass\nthe schedule name when running the shipped notebooks or the Databricks bundle job.
 
 ## Typical runtime structure
 
@@ -191,9 +187,7 @@ examples/runtime/
       hello_world.sql
   semantic/
     _config.example.yml
-```
-
-Key files and purpose
+```Key\nfiles and purpose
 - `fabricks/conf.fabricks.yml`: project-level configuration (secret scope, timeouts, workers, storage paths, schedules path)
 - `fabricks/schedules/schedule.yml`: minimal schedule to run the gold step
 - `gold/gold/_config.example.yml`: defines a simple Gold job
@@ -207,7 +201,8 @@ How to use this sample
 
 ## Related topics
 
-- Steps: [Bronze](../steps/bronze.md) • [Silver](../steps/silver.md) • [Gold](../steps/gold.md)
+- Steps: [Bronze](../steps/bronze.md) | [Silver](../steps/silver.md) | [Gold](../steps/gold.md)
 - Data quality checks and contracts: [Checks & Data Quality](../reference/checks-data-quality.md)
 - Table properties and physical layout: [Table Options](../reference/table-options.md)
 - Custom logic integration: [Extenders, UDFs & Views](../reference/extenders-udfs-parsers.md)
+

{fabricks-3.0.5.2 → fabricks-3.0.7}/docs/helpers/schedule.md

@@ -1,24 +1,24 @@
-# Schedules
+# Schedules
 
 Views provide a simple, declarative way to define a set of jobs to run in a schedule. Instead of listing jobs manually, you create a SQL view that filters the canonical `fabricks.jobs` table, and then reference that view by name from a schedule.
 
 Typical use cases:
 - Run all jobs for a given domain/topic (e.g., monarch)
 - Run only certain steps (e.g., all Gold jobs)
-- Run a curated subset of jobs for ad‑hoc backfills or smoke tests
+- Run a curated subset of jobs for adâ€'hoc backfills or smoke tests
 
 ---
 
 ## Types of views in Fabricks
 
-- Data views (user‑authored):
+- Data views (userâ€'authored):
   - You place `.sql` files under your runtime `views` path (see below).
   - Each file defines one SQL view created under the `fabricks` schema.
   - These are typically simple filters over `fabricks.jobs`.
 
-- Schedule views (framework‑generated):
+- Schedule views (frameworkâ€'generated):
   - For each `schedule` defined in your runtime YAML, Fabricks can generate a companion view named `fabricks.<schedule_name>_schedule`.
-  - A schedule view selects `j.*` from `fabricks.jobs` and applies optional filters from the schedule’s options (`view`, `steps`, `tag`), excluding manual jobs.
+  - A schedule view selects `j.*` from `fabricks.jobs` and applies optional filters from the schedule’s options (`view`, `steps`, `tag`), excluding manual jobs.
 
 Both kinds of views are useful: data views define job subsets; schedule views expose the final, resolved set for each schedule.
 
@@ -30,7 +30,7 @@ Both kinds of views are useful: data views define job subsets; schedule views ex
 - Data views: Your SQL selects a subset from `fabricks.jobs` (recommended: `select *`).
 - Schedules:
   - In `schedule.yml`, you can set `options.view: <data_view_name>`.
-  - Fabricks resolves the schedule’s membership via the data view (and optional `steps` / `tag` filters).
+  - Fabricks resolves the schedule’s membership via the data view (and optional `steps` / `tag` filters).
   - Fabricks can also materialize a schedule view `fabricks.<schedule_name>_schedule` for inspection and tooling.
 
 ---
@@ -59,9 +59,7 @@ Create a file `monarch.sql` in your runtime `views` directory:
 select *
 from fabricks.jobs j
 where j.topic = 'monarch'
-```
-
-This will create a view called `fabricks.monarch`. You can then reference this view in a schedule.
+```This\nwill create a view called `fabricks.monarch`. You can then reference this view in a schedule.
 
 ---
 
@@ -79,7 +77,7 @@ This will create a view called `fabricks.monarch`. You can then reference this v
 
 Behavior:
 - Fabricks loads all jobs returned by `fabricks.monarch` and further filters by `steps` and `tag` if provided.
-- Schedule‑level options like `variables`, `timeouts`, etc., still apply to execution.
+- Scheduleâ€'level options like `variables`, `timeouts`, etc., still apply to execution.
 - In most cases the view alone defines the job set; `steps`/`tag` refine it.
 
 ---
@@ -141,7 +139,7 @@ You can (re)create both data views and schedule views programmatically.
   ```
 
 - Initialization path:
-  - The bootstrap script (“armageddon”) calls both data view and schedule view builders so your environment is in sync with runtime configs and SQL view files.
+  - The bootstrap script (“armageddon”) calls both data view and schedule view builders so your environment is in sync with runtime configs and SQL view files.
 
 ---
 
@@ -152,24 +150,18 @@ Filter by step:
 select *
 from fabricks.jobs j
 where j.step = 'gold'
-```
-
-Filter by a set of topics:
+```Filter\nby a set of topics:
 ```sql title:core_topics.sql
 select *
 from fabricks.jobs j
 where j.topic in ('sales', 'finance', 'marketing')
-```
-
-Filter by both step and topic pattern:
+```Filter\nby both step and topic pattern:
 ```sql title:gold_sales_like.sql
 select *
 from fabricks.jobs j
 where j.step = 'gold'
   and j.topic like 'sales_%'
-```
-
-Curate explicit jobs:
+```Curate\nexplicit jobs:
 ```sql title:curated_selection.sql
 select *
 from fabricks.jobs j
@@ -186,7 +178,7 @@ Tip:
 
 - Keep view logic simple: use filters, avoid heavy joins or transformations.
 - Align views with business domains or execution scopes (by step, topic family, tags).
-- Use explicit OR lists for one‑off backfills to keep intent clear and auditable.
+- Use explicit OR lists for oneâ€'off backfills to keep intent clear and auditable.
 - Favor stable view names; schedules reference the view name.
 
 ## Related topics
@@ -196,3 +188,4 @@ Tip:
 - Steps overview (Bronze/Silver/Gold): ../steps/gold.md and siblings
 - Data quality checks: ./checks-data-quality.md
 - Table options and storage layout: ./table-options.md
+

{fabricks-3.0.5.2 → fabricks-3.0.7}/docs/helpers/step.md

@@ -1,4 +1,4 @@
-# Step Helper (Databricks Notebook)
+# Step Helper (Databricks Notebook)
 
 This helper describes a widget-driven approach in a Databricks notebook to manage a Fabricks step (bronze, silver, gold). 
 
@@ -28,8 +28,7 @@ s.update_dependencies(progress_bar=False)
 
 ## Helper Notebook
 
-``` python
-# Databricks notebook source
+```python\n# Databricks notebook source
 import os
 from multiprocessing import Pool
 from typing import Callable, List
@@ -41,15 +40,15 @@ from databricks.sdk.runtime import dbutils, spark
 dbutils.widgets.text("steps", "---", label="6 - Step(s)")
 dbutils.widgets.multiselect(
     "actions",
-    "update-configurations",
+    "``update``-configurations",
     [
-        "update-configurations",    -- Update job configurations
+        "``update``-configurations",    -- Update job configurations
         "add-missing-jobs",         -- Create any missing jobs
-        "update-dependencies",      -- Update job dependencies
-        "update-lists",             -- Update lists of jobs/tables/views
-        "update-tables-list",       -- Update the list of tables
-        "update-views-list",        -- Update the list of views
-        "update"                    -- Update the step
+        "``update``-dependencies",      -- Update job dependencies
+        "``update``-lists",             -- Update lists of jobs/tables/views
+        "``update``-tables-list",       -- Update the list of tables
+        "``update``-views-list",        -- Update the list of views
+        "``update``"                    -- Update the step
     ],
     label="5 - Action(s)"
 )
@@ -103,30 +102,27 @@ from fabricks.api.log import DEFAULT_LOGGER  # noqa: E402
 actions = dbutils.widgets.get("actions").split(",")
 actions = [a.strip() for a in actions]
 
-# COMMAND ----------
-
-
-def do(step: str) -> None:
+# COMMAND ----------`n`ndef do(step: str) -> None:
     s = get_step(step=step)
     todos: dict[str, Callable] = {}
 
-    if "update-configurations" in actions:
-        todos["update-configurations"] = s.update_jobs
+    if "``update``-configurations" in actions:
+        todos["``update``-configurations"] = s.update_jobs
 
     if "add-missing-jobs" in actions:
         todos["add-missing-jobs"] = s.create_jobs
 
-    if "update-views-list" in actions or "update-lists" in actions:
-        todos["update-views-list"] = s.update_views
+    if "``update``-views-list" in actions or "``update``-lists" in actions:
+        todos["``update``-views-list"] = s.update_views
 
-    if "update-tables-list" in actions or "update-lists" in actions:
-        todos["update-tables-list"] = s.update_tables
+    if "``update``-tables-list" in actions or "``update``-lists" in actions:
+        todos["``update``-tables-list"] = s.update_tables
 
-    if "update" in actions and len(actions) == 1:
-        todos["update"] = s.update
+    if "``update``" in actions and len(actions) == 1:
+        todos["``update``"] = s.``update``
 
-    if "update-dependencies" in actions:
-        todos["update-dependencies"] = s.update_dependencies
+    if "``update``-dependencies" in actions:
+        todos["``update``-dependencies"] = s.update_dependencies
 
     for key, func in todos.items():
         func()
@@ -138,7 +134,7 @@ steps = [s.strip() for s in dbutils.widgets.get("steps").split(",")]
 steps = [[j.strip() for j in job.split("//")] if "//" in job else job for job in steps]
 
 for step in steps:
-    DEFAULT_LOGGER.warning(", ".join(actions), extra={"step": step})
+    DEFAULT_LOGGER.warning(", ".join(actions), extra={"label": step})
 
 # COMMAND ----------
 
@@ -158,8 +154,9 @@ dbutils.notebook.exit("exit (0)")  # type: ignore
 
 ## Related topics
 
-- Steps: [Bronze](../steps/bronze.md) • [Silver](../steps/silver.md) • [Gold](../steps/gold.md)
+- Steps: [Bronze](../steps/bronze.md) | [Silver](../steps/silver.md) | [Gold](../steps/gold.md)
 - Runtime overview and sample runtime: [Runtime](../helpers/runtime.md)
 - Checks & Data Quality: [Checks and Data Quality](../reference/checks-data-quality.md)
 - Table options and storage layout: [Table Options](../reference/table-options.md)
 - Extenders, UDFs & Views: [Extenders, UDFs & Views](../reference/extenders-udfs-parsers.md)
+

fabricks-3.0.7/docs/index.md

@@ -0,0 +1,51 @@
+# Fabricks User Guide
+
+Fabricks is a pragmatic framework to build Databricks Lakehouse pipelines using YAML for orchestration and SQL for transformations.
+It standardizes jobs, steps, schedules, CDC, and checks while keeping development SQL-first.
+
+---
+
+# Steps Overview
+
+Fabricks organizes your Lakehouse into clear layers. Each step has a dedicated reference with modes, options, and examples.
+
+### Bronze
+
+Raw ingestion from source systems (files, streams, existing tables). Keep logic light; land data for downstream processing.
+
+- Typical modes: ``memory``, ``append``, ``register``
+- Focus: lightweight parsing/landing; no business logic
+- Output: raw tables or temporary views
+
+Read the full reference: [Bronze Step](steps/bronze.md)
+
+### Silver
+
+Standardize, clean, and enrich data; optionally apply CDC (SCD1/SCD2). Produces conformed datasets and convenience views.
+
+- Typical modes: ``memory``, ``append``, ``latest``, ``update``, ``combine``
+- CDC: ``nocdc``, ``scd1``, ``scd2`` with built-in helpers and views
+- Output: conformed tables and curated views
+
+Read the full reference: [Silver Step](steps/silver.md)
+
+### Gold
+
+Curated business models for analytics and reporting; dimensional or mart-style outputs. Can also `invoke` notebooks when needed.
+
+- Typical modes: ``memory``, ``append``, ``complete``, ``update``, ``invoke`` (notebooks)
+- Focus: dimensional models, marts, KPI-ready data
+- Output: business-consumption tables and views
+
+Read the full reference: [Gold Step](steps/gold.md)
+
+---
+
+## Where to Configure
+
+- Project configuration, schedules, and runtime structure: [Runtime](helpers/runtime.md)
+- Data quality and rollback behavior: [Checks & Data Quality](reference/checks-data-quality.md)
+- Table properties, clustering, and layout: [Table Options](reference/table-options.md)
+- Custom logic and reusable SQL assets: [Extenders, UDFs & Parsers](reference/extenders-udfs-parsers.md)
+- Change Data Capture (CDC): [CDC](reference/cdc.md)
+

{fabricks-3.0.5.2 → fabricks-3.0.7}/docs/introduction/layers.md

@@ -1,10 +1,10 @@
-# Layers (Bronze → Silver → Gold)
+# Layers (Bronze â†' Silver â†' Gold)
 
 Fabricks organizes pipelines into layered steps to keep responsibilities clear and composable. Use this page to decide where logic belongs and how to structure data flow.
 
 Layer summary
 
-- Bronze: Land raw data “as-is” from files/streams/tables. Keep it light.
+- Bronze: Land raw data “as-is” from files/streams/tables. Keep it light.
 - Silver: Standardize, clean, enrich; optionally apply CDC (SCD1/SCD2). Provide conformed datasets and convenience views.
 - Gold: Build consumption-ready models (facts/dims/marts), possibly with CDC merges or full refreshes.
 
@@ -13,23 +13,23 @@ When to use each layer
 - Bronze
     - Ingest from external sources with minimal logic
     - Keep provenance and raw fidelity
-    - Typical modes: memory, append, register
+    - Typical modes: ``memory``, ``append``, ``register``
 
 - Silver
     - Standardize schemas, apply business keys, deduplicate
-    - Apply CDC: scd1/scd2 with convenience views (e.g., table__current)
-    - Typical modes: memory, append, latest, update, combine
+    - Apply CDC: ``scd1``/``scd2`` with convenience views (e.g., table__current)
+    - Typical modes: ``memory``, ``append``, ``latest``, ``update``, ``combine``
 
 - Gold
     - Aggregate, reshape, and model data for analytics/reporting
     - Implement SCD patterns at the desired consumption grain
-    - Typical modes: memory, append, complete, update, invoke (notebook)
+    - Typical modes: ``memory``, ``append``, ``complete``, ``update``, ``invoke`` (notebook)
 
 Data flow
 
-- Bronze: raw sources → (light parsing, optional filters/calculated columns) → raw tables/views
-- Silver: bronze tables/views → (standardize/enrich, optional CDC) → conformed tables + {table}__current view
-- Gold: silver conformed outputs → (marts/dim/fact, SCD merges or complete refresh) → business-consumption tables/views
+- Bronze: raw sources â†' (light parsing, optional filters/calculated columns) â†' raw tables/views
+- Silver: bronze tables/views â†' (standardize/enrich, optional CDC) â†' conformed tables + {table}__current view
+- Gold: silver conformed outputs â†' (marts/dim/fact, SCD merges or ``complete`` refresh) â†' business-consumption tables/views
 
 Quality and governance
 
@@ -44,3 +44,4 @@ Related
 - CDC reference: ../reference/cdc.md
 - Data quality checks: ../reference/checks-data-quality.md
 - Table options: ../reference/table-options.md
+