dbt-tui 0.1.0__py3-none-any.whl

dbt_tui-0.1.0.dist-info/METADATA

@@ -0,0 +1,271 @@
+Metadata-Version: 2.4
+Name: dbt-tui
+Version: 0.1.0
+Summary: Terminal UI for exploring and managing dbt projects
+License: MIT
+Keywords: dbt,tui,terminal,data,analytics,sql
+Author: Mike
+Author-email: sortia@protonmail.com
+Requires-Python: >=3.12, <4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Dist: jinja2 (>=3.0)
+Requires-Dist: networkx (>=3.0)
+Requires-Dist: platformdirs (>=4.5.0,<5.0.0)
+Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
+Requires-Dist: textual[syntax] (>=6.5.0,<7.0.0)
+Project-URL: Homepage, https://github.com/sortia/dbt-tui
+Project-URL: Repository, https://github.com/sortia/dbt-tui
+Description-Content-Type: text/markdown
+
+# dbtui
+
+A Terminal User Interface (TUI) for navigating and managing [dbt (data build tool)](https://www.getdbt.com/) projects.
+
+**dbtui** provides an interactive command-line interface for exploring dbt models, their relationships, and configurations without leaving your terminal.
+
+## Features
+
+- **Model Explorer**: Browse all models in your dbt project with search capabilities
+- **Dependency Visualization**: View parent and child relationships for any model
+- **Model Preview**: Read model SQL and configuration inline
+- **Quick Navigation**: Jump between related models with keyboard shortcuts
+- **New Model Creation**: Create new models with automatic ref() generation
+- **Property Discovery**: View effective configurations from all sources (dbt_project.yml, schema.yml, model config)
+- **Session Persistence**: Automatically saves and restores your last viewed project and model
+- **External Editor Integration**: Open models in your preferred editor
+
+## Installation
+
+### Requirements
+
+- Python 3.12 or higher
+- A dbt project to explore
+
+### Install from source
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd dbtui
+
+# Install dependencies using pip
+pip install -e .
+
+# Or using poetry
+poetry install
+```
+
+## Usage
+
+### Basic Usage
+
+Navigate to a dbt project directory and run:
+
+```bash
+python -m dbtui
+```
+
+Or if installed via poetry:
+
+```bash
+poetry run python -m dbtui
+```
+
+### First Launch
+
+On first launch, dbtui will:
+1. Load the test project (if no cached project exists)
+2. Open the model search screen
+3. Allow you to search for and select a model
+
+### Keyboard Shortcuts
+
+#### Global Bindings
+
+| Key | Action | Description |
+|-----|--------|-------------|
+| `o` | Options | Open options/settings screen |
+| `f` | Find Model | Open model search screen |
+| `p` | Project Search | Select a different dbt project |
+| `q` | Quit | Exit the application |
+
+#### Model View Screen
+
+| Key | Action | Description |
+|-----|--------|-------------|
+| `E` | External Edit | Open current model in external editor |
+| `n` | New Model | Create a new model that refs the current one |
+| `Tab` | Switch Focus | Cycle between parents list, model content, and children list |
+| `↑↓` | Navigate Lists | Move up/down in parent/child lists |
+| `Enter` | Select Model | Navigate to the selected parent/child model |
+
+#### Model Search Screen
+
+| Key | Action | Description |
+|-----|--------|-------------|
+| Type to search | Live Search | Filter models by name as you type |
+| `↑↓` | Navigate Results | Move through search results |
+| `Enter` | Select Model | Open the selected model |
+
+#### New Model Screen
+
+| Key | Action | Description |
+|-----|--------|-------------|
+| Type path | Enter Path | Specify relative path for new model (e.g., `models/staging/stg_users.sql`) |
+| `Enter` | Create Model | Create the model and open it |
+| `Esc` | Cancel | Close modal without creating |
+
+## Configuration
+
+### Cache and Settings
+
+dbtui stores its configuration in your system's cache directory:
+
+- **Linux**: `~/.cache/dbtui/cache.json`
+- **macOS**: `~/Library/Caches/dbtui/cache.json`
+- **Windows**: `%LOCALAPPDATA%\dbtui\cache.json`
+
+The cache stores:
+- Last opened project path
+- Last viewed model
+- External editor command (default: `vi`)
+
+### External Editor
+
+To configure your preferred external editor, open the options screen (`o` key) and set the editor command. Examples:
+
+- `code` - Visual Studio Code
+- `vim` or `vi` - Vim
+- `nano` - Nano
+- `subl` - Sublime Text
+
+## Project Structure
+
+```
+dbtui/
+├── src/
+│   ├── backend/          # Core dbt project logic
+│   │   ├── project.py    # DbtProject class
+│   │   ├── model.py      # DbtModel class
+│   │   ├── fetch.py      # Property fetching utilities
+│   │   ├── property_claim.py      # Property precedence logic
+│   │   └── property_discovery.py  # Property discovery from configs
+│   ├── frontend/         # TUI screens and widgets
+│   │   ├── main.py       # Main application
+│   │   ├── model_search/ # Model search interface
+│   │   ├── model_tree/   # Model dependency tree view
+│   │   ├── new_model/    # New model creation
+│   │   └── options/      # Settings screen
+│   └── common/           # Shared abstractions and utilities
+│       ├── model.py      # Abstract model interface
+│       ├── project.py    # Abstract project interface
+│       └── cache.py      # Configuration persistence
+├── tests/                # Test suite
+│   └── testing/          # Test dbt project
+└── pyproject.toml        # Project dependencies
+```
+
+## Architecture
+
+### Backend
+
+The backend implements the core dbt project parsing logic:
+
+- **DbtProject**: Represents a dbt project, loads models from configured model-paths
+- **DbtModel**: Represents a single model, parses Jinja2 templates to extract refs and configs
+- **PropertyClaim**: Represents a property claim from any configuration source
+- **Property Discovery**: Collects properties from dbt_project.yml, schema.yml, and model SQL
+
+### Frontend
+
+Built with [Textual](https://textual.textualize.io/), the frontend provides:
+
+- **Screen-based navigation**: Each feature is a separate screen
+- **Reactive state management**: Changes to project/model automatically update UI
+- **Keyboard-driven workflow**: All actions accessible via keyboard
+
+### Property Precedence
+
+dbtui correctly implements dbt's configuration precedence rules:
+
+1. **Model-level** (highest): `{{ config(...) }}` in SQL files
+2. **Schema-level**: `config:` blocks in schema.yml
+3. **Project-level** (lowest): `models:` section in dbt_project.yml
+   - More specific paths override general ones
+   - Example: `models.project.staging.stg_users` > `models.project.staging` > `models.project`
+
+## Development
+
+### Running Tests
+
+```bash
+# Run all tests
+pytest
+
+# Run specific test file
+pytest tests/test_property_claims.py
+
+# Run with coverage
+pytest --cov=src
+
+# Run with verbose output
+pytest -v
+```
+
+### Test Project
+
+The `tests/testing/` directory contains a sample dbt project used for testing:
+
+- Multiple model directories (vanilla, complex_config, invalid)
+- Models with various configurations
+- Schema.yml files with properties and configs
+- Project-level configurations in dbt_project.yml
+
+### Adding New Features
+
+1. **Backend changes**: Extend DbtProject or DbtModel in `src/backend/`
+2. **Frontend changes**: Create new screens/widgets in `src/frontend/`
+3. **Add tests**: Write tests in `tests/` following existing patterns
+4. **Update abstractions**: Modify `src/common/` interfaces if needed
+
+## Roadmap
+
+- [ ] Enhanced model search (fuzzy matching, filters)
+- [ ] Property viewer showing all effective configs with sources
+- [ ] DAG visualization (ASCII graph)
+- [ ] Model execution (dbt run, dbt test)
+- [ ] Column-level lineage
+- [ ] Documentation viewer
+- [ ] Git integration
+- [ ] Multiple project workspace
+
+## Contributing
+
+Contributions are welcome! Please:
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass (`pytest`)
+5. Submit a pull request
+
+## License
+
+[Add your license here]
+
+## Acknowledgments
+
+Built with:
+- [Textual](https://textual.textualize.io/) - TUI framework
+- [Jinja2](https://jinja.palletsprojects.com/) - Template parsing
+- [NetworkX](https://networkx.org/) - Graph operations
+- [PyYAML](https://pyyaml.org/) - YAML parsing
+

dbt_tui-0.1.0.dist-info/RECORD

@@ -0,0 +1,49 @@
+dbtui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dbtui/__main__.py,sha256=wCZFzGy8hZ-lRt_wJzwUZkWLSSUWtRo6GsufIcBQroA,1602
+dbtui/backend/__init__.py,sha256=ZACjlyjPvAXWDxBWEmSCrHxPO38sOBFTt0Zpm-wAMCU,87
+dbtui/backend/fetch.py,sha256=-_MvLbP8ehpkF5jaEeuTfk92EpuSKmssx1XutIZ-Md8,5362
+dbtui/backend/model.py,sha256=QC95HeyH4kspNG6_BRUFfHbyu-ZfB5ymJL0vJoZYT2o,3005
+dbtui/backend/project.py,sha256=Acc1E90SenOepNSSBblAEA4EydMzV9lQzaXiIgqDpaI,9881
+dbtui/backend/property_claim.py,sha256=V2FF4lYqNaywfG5G4F6uXNI0XQj6s7PDmC0RjoCS7yk,6883
+dbtui/backend/property_discovery.py,sha256=8NF1DpempvMokVBG0H9bvBwPnPpiOKcB99RzLoMFF5M,15028
+dbtui/common/__init__.py,sha256=z-QvzVhkV_9rDXFUswwrC_3dSVa40jSfid4myPdza_Q,155
+dbtui/common/cache.py,sha256=aBUMofPYqGfm4KRd5xlJVIQXEhtnN-8rc6Bw2jPH8mI,2334
+dbtui/common/exceptions.py,sha256=Xic3bVGjYrK4J9nChAwcHEbkhS4qovlvUoFH7W6zRaU,274
+dbtui/common/model.py,sha256=qKQJYNIU8xydCIFMqd8f97tyJLiHsLTMe7efKLRU_FE,474
+dbtui/common/project.py,sha256=6Vfj2EsSG4Tmszod-WYXX0ZYSvp_TzwZhQobRbadRlE,840
+dbtui/frontend/__init__.py,sha256=hXVp-ZV0GJTIunfx2xqvSs4IUMcebSvUxTrLizeqhP8,44
+dbtui/frontend/common/__init__.py,sha256=0B3YYs1RvFfQQEc4rSHZFyvjjFhAp8ML8ujoafdGRC0,157
+dbtui/frontend/common/dbtui_screen.py,sha256=gajcZcSXNkOpdmtstb28szP57J4mykXlIcpT_7sr7EU,1650
+dbtui/frontend/common/isolated.py,sha256=vRF1oSNQnt1M0c0yAgw92ibWPSgPMBi2UxYx34Ogolg,428
+dbtui/frontend/common/model_list.py,sha256=Zf3ZJ9H0h7GKHX9QRrBAskiV2Eo0GGIHf_MH9hOBlUA,1165
+dbtui/frontend/common/model_list_item.py,sha256=Alnqz2ypwdLqEKJhtqE2h-VdUOQ-supoGHbu5HL1HGo,480
+dbtui/frontend/lorem.txt,sha256=HfuvMdyoE8hBebajImphe0gTGVHLMO6qbv9YunoCdLQ,3295
+dbtui/frontend/main.py,sha256=TMz_VecJJp522-RiPwjd-MycAmOel6uRwpLwEvD64sE,4452
+dbtui/frontend/model_search/__init__.py,sha256=OFwnctfsS-4l5q58Lf441gcMugoil0UykMWKuoyzreE,38
+dbtui/frontend/model_search/model_search.py,sha256=13iayOB_V-Ub-3HHrsvZwJDhKRTmn_A6l0DWQEwEsrY,1430
+dbtui/frontend/model_search/model_search_input.py,sha256=uD6yJ7QMiHhZ16fibXeqULelGWXSECS-PeIrTygcXDk,616
+dbtui/frontend/model_search/model_search_list.py,sha256=cAV-9HnEbSBCTE1zNlJtzj9h_lrLuiJrCotOQc69Xtg,515
+dbtui/frontend/model_tree/__init__.py,sha256=cjsjmAal7mH26AoOpoEd8uT1MrzZB97HF_5AgTa0URM,34
+dbtui/frontend/model_tree/children_list.py,sha256=2bplKOXjg9u0cY9tZsRntT7Iep32AyHfI3bFiz62Icc,897
+dbtui/frontend/model_tree/constants.py,sha256=1fO0isX7ObEJXSmKdQkRdKOn0bzbCchFe6tZwlwPMAM,117
+dbtui/frontend/model_tree/model_relatives_list.py,sha256=tbvaILP-VWec8vITuL0MuGA3NNavITTLTmM4lzmvM5c,476
+dbtui/frontend/model_tree/model_tree.py,sha256=820iKDA5jjZ20PqkGVj8XYoUuOija4EbIRfdH6csb7c,3268
+dbtui/frontend/model_tree/parents_list.py,sha256=FhUK9zZw3j9SqmX7NqSS2sLLP8EXZ2HZxEmV9FLepIw,901
+dbtui/frontend/model_view/__init__.py,sha256=iPWtYSByCYX_nE374ddtcSJhUBb2V5zTgQ355bTJdcE,80
+dbtui/frontend/model_view/model_tree.py,sha256=jH6BDammNRrQ4v-SbEozzxurRlp_vUiGom2-YCTwZB4,5295
+dbtui/frontend/model_view/properties_panel.py,sha256=4gAO4CKX0NtGwcWkctM0ufyW7C5I_xEJtUAYISbwOC0,5098
+dbtui/frontend/new_model/__init__.py,sha256=EEQNjE0mlWlKC8BzB0F2RLEmOZgrhOPx3jDdV8o3Yu0,31
+dbtui/frontend/new_model/new_model.py,sha256=eHi70emtt0v1QmzzNqG006npkJpWL4j96h5MMWVQ7wU,1564
+dbtui/frontend/new_model/select_filepath.py,sha256=3Ai96GBjHNuCPmQvX87kdYpwgZeis390PBIRay_x4Uk,1001
+dbtui/frontend/options/__init__.py,sha256=O0HOFS-oaXdpgFSjmUxFROj4LCizHENjggblfCluR78,29
+dbtui/frontend/options/options.py,sha256=QJo8iuQKr3h1JcF8lPk71cT04UYxu_3jS8pviS7mmqM,837
+dbtui/frontend/project_search/__init__.py,sha256=yxCMGHgd5O4rClMnLyD-X2CoX05M9kUWUe-T_5jnJ1U,42
+dbtui/frontend/project_search/project_search.py,sha256=BvrprGVnpuh5myN27C2Z6wzySdXELIicbrlOackUTdI,3633
+dbtui/frontend/pseudo/__init__.py,sha256=jTNtjd6Gcj7BpnUXCWAnLQL7AitByq05VPt5SoAyVrc,68
+dbtui/frontend/pseudo/dbt_model.py,sha256=r8roTZnBpoAHkCLTBUOmLAryK-heHwACSwVkL1B9Rrk,1198
+dbtui/frontend/pseudo/dbt_project.py,sha256=qRTqQjv2cV9nMSS92pob5mP22YiATIhSuoJWLX4YGZE,1127
+dbtui/frontend/pseudo/utils.py,sha256=lDUc6q1vE7aegtb-rkjer4UOY_FSWADKJAnRG4ZObMA,132
+dbt_tui-0.1.0.dist-info/METADATA,sha256=dcjV18nPbfxVh2Hl7fdFrREWe84U2V_8t6E3rGzd9XU,8504
+dbt_tui-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+dbt_tui-0.1.0.dist-info/entry_points.txt,sha256=zEaIQ64eIxqYbrMCquQRHaeHpbVup2QXIfFQ1O08cCQ,73
+dbt_tui-0.1.0.dist-info/RECORD,,

dbt_tui-0.1.0.dist-info/WHEEL

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

dbt_tui-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+dbt-tui=dbtui.__main__:main
+dbtui=dbtui.__main__:main
+

dbtui/__main__.py

@@ -0,0 +1,59 @@
+"""
+dbtui - Terminal UI for dbt projects
+
+Usage:
+    python -m dbtui [project_dir]
+
+If project_dir is not specified, launches with the last opened project.
+"""
+import argparse
+import sys
+from pathlib import Path
+
+from .frontend import frontend as dbtuiFrontend
+from .common import load_cache, save_cache
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='dbtui',
+        description='Terminal UI for exploring and managing dbt projects'
+    )
+    parser.add_argument(
+        'project_dir',
+        nargs='?',
+        default=None,
+        help='Path to dbt project directory (optional, uses last project if not specified)'
+    )
+
+    args = parser.parse_args()
+
+    # If project_dir is provided, validate it and save to cache
+    if args.project_dir:
+        project_path = Path(args.project_dir).resolve()
+
+        if not project_path.exists():
+            print(f"Error: Directory not found: {project_path}", file=sys.stderr)
+            sys.exit(1)
+
+        if not (project_path / 'dbt_project.yml').exists():
+            print(f"Error: Not a dbt project (no dbt_project.yml found): {project_path}", file=sys.stderr)
+            sys.exit(1)
+
+        # Load existing cache to preserve external_editor_command
+        existing_cache = load_cache()
+
+        # Save the project path to cache so the app loads it
+        save_cache(
+            project_path=project_path,
+            model_name=None,
+            external_editor_command=existing_cache.external_editor_command
+        )
+
+    # Launch the app
+    app = dbtuiFrontend()
+    app.run()
+
+
+if __name__ == '__main__':
+    main()

dbtui/backend/__init__.py

@@ -0,0 +1,2 @@
+from .project import DbtProject, DbtModelNotFoundException
+from .model import DbtModel

dbtui/backend/fetch.py

@@ -0,0 +1,206 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal
+
+
+def get_model_path_parts(
+    model_path: Path,
+    project_path: Path,
+) -> list[str]:
+    """
+    models/foo/bar/my_model.sql -> ["foo", "bar", "my_model"]
+    """
+    models_dir = project_path / "models"
+    rel = model_path.resolve().relative_to(models_dir.resolve())
+    return list(rel.with_suffix("").parts)
+
+
+def find_schema_files(
+    model_path: Path,
+    project_path: Path,
+) -> list[Path]:
+    schema_files: list[Path] = []
+
+    model_dir_path_abs = model_path.parent.resolve()
+    project_dir_path_abs = project_path.resolve()
+    
+    yml_targets = [i for i in model_dir_path_abs.relative_to(project_dir_path_abs).parents if not i == Path('.')]
+
+    for target in yml_targets:
+        for ext in ("*.yml", "*.yaml"):
+            schema_files.extend(target.glob(ext))
+
+
+    return schema_files
+
+
+
+@dataclass
+class PropertyClaim:
+    source_type: Literal["dbt_project.yml", "schema.yml", "model.sql"]
+    source_path: Path
+    name: str
+    value: Any
+    kind: Literal["config", "property"]
+
+import yaml
+import re
+
+def collect_project_configs(
+    model_path: Path,
+    project_path: Path,
+) -> list[PropertyClaim]:
+    claims: list[PropertyClaim] = []
+
+    project_file = project_path / "dbt_project.yml"
+    if not project_file.exists():
+        return claims
+
+    data = yaml.safe_load(project_file.read_text()) or {}
+    models = data.get("models", {})
+
+    model_parts = get_model_path_parts(model_path, project_path)
+
+    def walk(node, path_index: int):
+        """
+        node: current yaml dict
+        path_index: where we are in model_parts
+        """
+        if not isinstance(node, dict):
+            return
+
+        # collect configs at this level
+        for k, v in node.items():
+            if isinstance(k, str) and k.startswith("+"):
+                claims.append(
+                    PropertyClaim(
+                        source_type="dbt_project.yml",
+                        source_path=project_file,
+                        name=k[1:],
+                        value=v,
+                        kind="config",
+                    )
+                )
+
+        # descend if possible
+        if path_index >= len(model_parts):
+            return
+
+        next_key = model_parts[path_index]
+        if next_key in node:
+            walk(node[next_key], path_index + 1)
+
+    # dbt_project.yml always has: models: <package_name>: ...
+    for package_node in models.values():
+        walk(package_node, 0)
+
+    return claims
+
+
+
+
+def collect_schema_properties(
+    schema_file: Path,
+    model_name: str,
+) -> list[PropertyClaim]:
+    claims: list[PropertyClaim] = []
+
+    try:
+        data = yaml.safe_load(schema_file.read_text()) or {}
+    except Exception:
+        return claims  # invalid yaml, dbt would scream; you quietly ignore
+
+    models = data.get("models", [])
+
+    for model in models:
+        if model.get("name") != model_name:
+            continue
+
+        for key, value in model.items():
+            if key == "config":
+                for ck, cv in (value or {}).items():
+                    claims.append(
+                        PropertyClaim(
+                            source_type="schema.yml",
+                            source_path=schema_file,
+                            name=ck,
+                            value=cv,
+                            kind="config",
+                        )
+                    )
+            elif key != "name":
+                claims.append(
+                    PropertyClaim(
+                        source_type="schema.yml",
+                        source_path=schema_file,
+                        name=key,
+                        value=value,
+                        kind="property",
+                    )
+                )
+
+    return claims
+
+
+CONFIG_CALL_RE = re.compile(
+    r"config\s*\((.*?)\)",
+    re.DOTALL,
+)
+
+
+def collect_sql_configs(model_path: Path) -> list[PropertyClaim]:
+    claims: list[PropertyClaim] = []
+
+    text = model_path.read_text()
+    matches = CONFIG_CALL_RE.findall(text)
+
+    for match in matches:
+        # extremely naive kwarg parsing
+        parts = re.split(r",(?![^\[\]\(\)]*[\]\)])", match)
+
+        for part in parts:
+            if "=" not in part:
+                continue
+            key, value = part.split("=", 1)
+            claims.append(
+                PropertyClaim(
+                    source_type="model.sql",
+                    source_path=model_path,
+                    name=key.strip(),
+                    value=value.strip(),
+                    kind="config",
+                )
+            )
+
+    return claims
+
+def collect_model_claims(
+    model_path: Path,
+    project_path: Path,
+) -> list[PropertyClaim]:
+    claims: list[PropertyClaim] = []
+    model_name = model_path.stem
+
+    # dbt_project.yml
+    claims.extend(collect_project_configs(model_path, project_path))
+
+    # schema.yml files discovered automatically
+    schema_files = find_schema_files(model_path, project_path)
+    for schema_file in schema_files:
+        claims.extend(
+            collect_schema_properties(schema_file, model_name)
+        )
+
+    # model.sql
+    claims.extend(collect_sql_configs(model_path))
+
+    return claims
+
+
+print(
+    collect_model_claims(
+        Path('models/mart/users_daily_stat.sql'),
+        Path('.'),
+    )
+)
+

dbtui/backend/model.py

@@ -0,0 +1,86 @@
+from pathlib import Path
+from jinja2 import Environment, Template
+from jinja2.nodes import Call, Const
+import logging
+
+from ..common import DbtModelAbstract, NotWithinSubdirectoryException
+
+from typing import TYPE_CHECKING, Iterable, Self
+if TYPE_CHECKING:
+    from .project import DbtProject
+    from .property_claim import PropertyClaimAggregate
+
+
+class DbtModel(DbtModelAbstract):
+    file_name: str
+    file_path_full: Path
+    file_path_relative: Path
+    template: str
+    parsed_template: Template
+    project: 'DbtProject'
+    property_claims: 'PropertyClaimAggregate | None'
+
+    @property 
+    def file_path_relative(self):
+        return self.file_path_full.relative_to(self.project.root_folder)
+    
+    @property
+    def file_name(self):
+        return self.file_path_full.name
+
+    def __init__(self, file_path_full: Path, project: 'DbtProject'):
+        self.file_path_full = file_path_full
+        self.project = project
+        self.property_claims = None  # Populated by DbtProject.collect_property_claims()
+        with open(file_path_full, 'r', encoding='utf-8') as f:
+            self.template = f.read()
+        self.parsed_template = Environment().parse(self.template)
+
+    def _find_calls(self, macro_name: str):
+        return [i for i in self.parsed_template.find_all(Call) if i.node.name == macro_name]
+
+    
+    @property 
+    def name(self) -> str:
+        # by default dbt sets model name as its filename without extension
+        default_name = self.file_name.rpartition('.')[0]
+        # we need to figure out if the model has been renamed with config() macro, so let's find this macro in the model file
+        calls = self._find_calls('config')
+
+        # double config would be invalid
+        if len(calls) > 1:
+            logging.warn("Duplicated invocation of config() in %s" % self.file_path_relative)
+            return default_name
+
+        if not calls:
+            return default_name
+        else:
+            config: Call = calls[0]
+            kwargs = {item.key: item.value for item in config.kwargs}
+            return kwargs.get('name', Const(default_name)).value
+    
+    @property 
+    def children(self) -> list[Self]:
+        return sorted(list(self.project.graph.successors(self)), key=lambda n: n.name)
+    
+    @property 
+    def parents(self) -> Iterable[Self]:
+        return sorted(list(self.project.graph.predecessors(self)), key=lambda n: n.name)
+    
+    @property
+    def text(self) -> str:
+        with open(self.file_path_full, 'r', encoding='utf-8') as f:
+            self.template = f.read()
+        return self.template
+    
+    
+    @property
+    def refs(self) -> list[str]:
+        result = []
+        for call in self._find_calls('ref'):
+            if len(call.args) != 1:
+                logging.warn(f"Invalid number of args to ref() in model {self.name}: should be one, but it's {len(call.args)}: {[arg.value for arg in call.args]}")
+                continue
+            result.append(call.args[0].value)
+        return result
+