Configuration

def get_flags():
    """
    Get the current global flags.
    
    Returns:
        Namespace: Current global flags object
    """

def set_flags(flags):
    """
    Set the global flags.
    
    Args:
        flags: Namespace or Flags object containing configuration
    """

def set_from_args(args: Namespace, project_flags):
    """
    Set flags from command line arguments and project configuration.
    
    Args:
        args: Parsed command line arguments
        project_flags: Project-specific flag configuration
    """

def get_flag_dict():
    """
    Get flag attributes as a dictionary.
    
    Returns:
        dict: Dictionary of flag attributes and values
    """

from dbt.flags import GLOBAL_FLAGS

# Access current flag values
GLOBAL_FLAGS.USE_COLORS  # Boolean for colored output
GLOBAL_FLAGS.LOG_LEVEL   # Current log level
GLOBAL_FLAGS.THREADS     # Number of execution threads

DBT_PROJECT_FILE_NAME = "dbt_project.yml"
"""Standard name for dbt project configuration file."""

PACKAGES_FILE_NAME = "packages.yml"
"""File name for package dependencies."""

DEPENDENCIES_FILE_NAME = "dependencies.yml"
"""Alternative file name for package dependencies."""

PACKAGE_LOCK_FILE_NAME = "package-lock.yml"
"""Lock file for pinned package versions."""

MANIFEST_FILE_NAME = "manifest.json"
"""Compiled manifest artifact file name."""

SEMANTIC_MANIFEST_FILE_NAME = "semantic_manifest.json"
"""Semantic layer manifest file name."""

PARTIAL_PARSE_FILE_NAME = "partial_parse.msgpack"
"""Partial parsing cache file name."""

CATALOGS_FILE_NAME = "catalogs.yml"
"""Catalog configuration file name."""

RUN_RESULTS_FILE_NAME = "run_results.json"
"""Run results artifact file name."""

CATALOG_FILENAME = "catalog.json"
"""Generated catalog artifact file name."""

SOURCE_RESULT_FILE_NAME = "sources.json"
"""Source freshness results file name."""

MAXIMUM_SEED_SIZE = 1 * 1024 * 1024
"""Maximum size for seed files in bytes (1MB)."""

MAXIMUM_SEED_SIZE_NAME = "1MB"
"""Human-readable maximum seed size."""

DEFAULT_ENV_PLACEHOLDER = "DBT_DEFAULT_PLACEHOLDER"
"""Placeholder for default environment variable values."""

SECRET_PLACEHOLDER = "$$$DBT_SECRET_START$$${}$$$DBT_SECRET_END$$$"
"""Template for masking secrets in logs and output."""

PIN_PACKAGE_URL = "https://docs.getdbt.com/docs/package-management#section-specifying-package-versions"
"""Documentation URL for package version pinning."""

from dbt_semantic_interfaces.type_enums import TimeGranularity

LEGACY_TIME_SPINE_MODEL_NAME = "metricflow_time_spine"
"""Legacy time spine model name for semantic layer."""

LEGACY_TIME_SPINE_GRANULARITY = TimeGranularity.DAY
"""Default granularity for legacy time spine."""

MINIMUM_REQUIRED_TIME_SPINE_GRANULARITY = TimeGranularity.DAY
"""Minimum required time spine granularity."""

# Threading and performance
THREADS: int              # Number of execution threads
SINGLE_THREADED: bool     # Force single-threaded execution
PARTIAL_PARSE: bool       # Enable partial parsing for performance

# Execution behavior  
FULL_REFRESH: bool        # Force full refresh of incremental models
FAIL_FAST: bool          # Stop on first failure
STORE_FAILURES: bool     # Store test failures in database

# Output control
USE_COLORS: bool         # Enable colored terminal output  
USE_COLORS_FILE: bool    # Enable colors in log files
QUIET: bool              # Suppress non-error output
PRINT: bool              # Print output to console

# Logging configuration
LOG_LEVEL: str           # Log level (debug, info, warn, error)
LOG_LEVEL_FILE: str      # File log level
LOG_PATH: str            # Path for log files
LOG_FORMAT: str          # Log format for console
LOG_FORMAT_FILE: str     # Log format for files
LOG_FILE_MAX_BYTES: int  # Maximum log file size

# Debugging
DEBUG: bool              # Enable debug mode
MACRO_DEBUGGING: bool    # Enable macro debugging

# Development features
USE_EXPERIMENTAL_PARSER: bool  # Use experimental parser
STATIC_PARSER: bool           # Use static parser
SHOW_ALL_DEPRECATIONS: bool   # Show all deprecation warnings
WARN_ERROR: bool              # Treat warnings as errors

# Resource selection
SELECT: List[str]        # Resource selection criteria
EXCLUDE: List[str]       # Resource exclusion criteria
RESOURCE_TYPE: List[str] # Filter by resource type
SELECTOR: str            # Named selector to use

# State comparison
STATE: str               # Path to state directory
DEFER: bool              # Defer to state for unselected resources
FAVOR_STATE: bool        # Favor state over current project

from dbt.flags import set_flags
from argparse import Namespace

# Create custom flags
custom_flags = Namespace()
custom_flags.USE_COLORS = False
custom_flags.LOG_LEVEL = 'debug'
custom_flags.THREADS = 8

# Apply flags
set_flags(custom_flags)

from dbt.flags import get_flags

flags = get_flags()
print(f"Current log level: {flags.LOG_LEVEL}")
print(f"Thread count: {flags.THREADS}")
print(f"Colors enabled: {flags.USE_COLORS}")

from dbt.constants import (
    DBT_PROJECT_FILE_NAME,
    MANIFEST_FILE_NAME,
    MAXIMUM_SEED_SIZE
)
import os

# Check for project file
if os.path.exists(DBT_PROJECT_FILE_NAME):
    print("Found dbt project")

# Check manifest
manifest_path = os.path.join('target', MANIFEST_FILE_NAME)
if os.path.exists(manifest_path):
    print("Manifest available")

# Validate seed file size
def validate_seed_size(file_path):
    size = os.path.getsize(file_path)
    if size > MAXIMUM_SEED_SIZE:
        raise ValueError(f"Seed file too large: {size} bytes")

import os
from dbt.constants import DEFAULT_ENV_PLACEHOLDER

def get_env_or_default(key, default=None):
    """Get environment variable or return default."""
    value = os.getenv(key, DEFAULT_ENV_PLACEHOLDER)
    if value == DEFAULT_ENV_PLACEHOLDER:
        return default
    return value

# Usage
threads = int(get_env_or_default('DBT_THREADS', '4'))
target = get_env_or_default('DBT_TARGET', 'dev')