swarm-debug 0.1.0__py3-none-any.whl

backend/apps/debugger/debugger.py

@@ -0,0 +1,83 @@
+import logging
+import json
+import os
+from backend.config.Apps import SubApp
+from backend.core.models.project_scanner import update_debug_toggles, dir_to_output_format
+from backend.core.data_dir import NEEDS_RESYNC_FILE, TOGGLE_FILE as DEBUG_TOGGLE_FILE
+from backend.core.DEFAULTS import get_root_dir, set_root_dir
+from contextlib import asynccontextmanager
+from fastapi.responses import JSONResponse
+from typeguard import typechecked
+
+log = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def debugger_lifespan():
+    log.debug("debugger_lifespan START")
+    yield
+    log.debug("debugger_lifespan END")
+
+
+debugger = SubApp("debugger", debugger_lifespan)
+
+
+@debugger.router.get("/pull_structure")
+@typechecked
+async def pull_structure() -> JSONResponse:
+    log.info("GET /api/debugger/pull_structure")
+    scanned_dir = update_debug_toggles(save_to_file=True)
+    output = dir_to_output_format(scanned_dir)
+    return JSONResponse(content=output)
+
+
+@debugger.router.post("/push_structure")
+@typechecked
+async def push_structure(data: dict) -> JSONResponse:
+    log.info("POST /api/debugger/push_structure")
+    project_structure = data['projectStructure']
+    with open(DEBUG_TOGGLE_FILE, 'w', encoding='utf-8') as file:
+        json.dump(project_structure, file, indent=4)
+    with open(NEEDS_RESYNC_FILE, 'w') as f:
+        f.write('1')
+    return JSONResponse(content={"status": "success"})
+
+
+@debugger.router.post("/reset_color")
+@typechecked
+async def reset_color() -> JSONResponse:
+    log.info("POST /api/debugger/reset_color")
+    scanned_dir = update_debug_toggles(save_to_file=False)
+    scanned_dir.reset_colors()
+    output = dir_to_output_format(scanned_dir)
+    return JSONResponse(content=output)
+
+
+@debugger.router.post("/reset_emoji")
+@typechecked
+async def reset_emoji() -> JSONResponse:
+    log.info("POST /api/debugger/reset_emoji")
+    scanned_dir = update_debug_toggles(save_to_file=False)
+    scanned_dir.reset_emojis()
+    output = dir_to_output_format(scanned_dir)
+    return JSONResponse(content=output)
+
+
+@debugger.router.get("/root_dir")
+@typechecked
+async def get_root() -> JSONResponse:
+    log.info("GET /api/debugger/root_dir")
+    return JSONResponse(content={"root_dir": get_root_dir()})
+
+
+@debugger.router.post("/root_dir")
+@typechecked
+async def set_root(data: dict) -> JSONResponse:
+    log.info("POST /api/debugger/root_dir")
+    path = data.get("root_dir", "")
+    if not path or not os.path.isdir(path):
+        return JSONResponse(content={"error": "Invalid directory path"}, status_code=400)
+    set_root_dir(path)
+    with open(NEEDS_RESYNC_FILE, 'w') as f:
+        f.write('1')
+    return JSONResponse(content={"root_dir": get_root_dir()})

backend/apps/health/health.py

@@ -0,0 +1,33 @@
+import logging
+from backend.config.Apps import SubApp
+from contextlib import asynccontextmanager
+from fastapi.responses import PlainTextResponse
+from typeguard import typechecked
+from fastapi import status
+
+log = logging.getLogger(__name__)
+
+@asynccontextmanager
+async def health_lifespan():
+    log.debug("health_lifespan START")
+    yield
+    log.debug("health_lifespan END")
+
+health = SubApp("health", health_lifespan)
+
+######################################
+# Health Check Endpoints #
+######################################
+
+@health.router.get("/check")
+@typechecked
+async def check() -> PlainTextResponse:
+    log.info("Health check successful")
+    return PlainTextResponse(
+        content="OK", 
+        status_code=status.HTTP_200_OK,
+        headers={
+            "Content-Type": "text/plain",
+            "Content-Length": "2"
+        }
+    )

backend/config/Apps.py

@@ -0,0 +1,48 @@
+import logging
+import os
+from fastapi import FastAPI, APIRouter
+from uuid import uuid4
+from typing import List
+from contextlib import asynccontextmanager
+from contextlib import AsyncExitStack
+from typing import Callable
+
+log = logging.getLogger(__name__)
+
+
+class SubApp:
+    def __init__(self, name:str, lifespan:Callable):
+        log.debug("SubApp.__init__ START: %s", name)
+        self.id = uuid4()
+        self.name = name
+        self.prefix = f"/api/{name}"
+        self.lifespan = lifespan
+        self.router = APIRouter()
+        log.debug("SubApp.__init__ END")
+    
+    def __str__(self):
+        return f"SubApp(name={self.name}, prefix={self.prefix}, id={self.id})"
+
+class MainApp:
+    def __init__(self, sub_apps: List[SubApp]):
+        log.debug("MainApp.__init__ START")
+        
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            async with AsyncExitStack() as stack:
+                for sub_app in sub_apps:
+                    log.debug("Starting lifespan for sub_app: %s", sub_app.name)
+                    await stack.enter_async_context(sub_app.lifespan())
+                port = os.environ.get("BACKEND_PORT", "8324")
+                print(f"\nCheck out the API docs at: http://127.0.0.1:{port}/docs\n")
+                yield
+        
+        self.app = FastAPI(lifespan=lifespan)
+        
+        for sub_app in sub_apps:
+            self.app.include_router(
+                sub_app.router, 
+                prefix=sub_app.prefix,
+                tags=[sub_app.name]
+            )
+        log.debug("MainApp.__init__ END")

backend/core/DEFAULTS.py

@@ -0,0 +1,29 @@
+import os
+from backend.core.data_dir import TOGGLE_FILE, ROOT_DIR_FILE
+
+DEFAULT_COLOR = '#ffffff'
+DEFAULT_TOGGLED = False
+DEFAULT_SET_MANUALLY = False
+DEFAULT_SET_MANUALLY_EMOJI = False
+DEFAULT_EMOJI = '⚫'
+
+
+def get_root_dir() -> str:
+    """Priority: env var > persisted file > cwd."""
+    env = os.environ.get("SWARM_DEBUG_ROOT")
+    if env:
+        return os.path.abspath(env)
+
+    if os.path.exists(ROOT_DIR_FILE):
+        with open(ROOT_DIR_FILE, "r") as f:
+            saved = f.read().strip()
+        if saved:
+            return saved
+
+    return os.getcwd()
+
+
+def set_root_dir(path: str):
+    path = os.path.abspath(path)
+    with open(ROOT_DIR_FILE, "w") as f:
+        f.write(path)

backend/core/Debugleton.py

@@ -0,0 +1,87 @@
+# Haik: sorry bout the filename
+
+import threading
+from backend.core.models.project_scanner import update_debug_toggles
+from backend.core.models.Directory import Directory
+from backend.core.models.DebugFile import DebugFile
+from backend.core.DEFAULTS import DEFAULT_COLOR, DEFAULT_TOGGLED, DEFAULT_EMOJI
+from backend.core.data_dir import NEEDS_RESYNC_FILE
+import os
+import time
+
+class Debugleton:
+    _instance = None
+    _lock = threading.Lock()  # Lock for thread-safe singleton creation
+    sync_lock: threading.Lock
+
+    def __new__(cls, *args, **kwargs):
+        # Double-checked locking for thread-safe singleton creation
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(Debugleton, cls).__new__(cls)
+                    print("\033[38;5;120m\n---------------------------------\033[0m")
+                    print("\033[38;5;120m|\tDEBUGLETON INIT \t|\033[0m")
+                    cls._instance.dir = None
+                    print("\033[38;5;120m|\tScanning Project...\t|\033[0m")
+                    cls._instance.sync_lock = threading.Lock()
+                    cls._instance.sync_lock.acquire(blocking=False)
+                    cls._instance.sync_to_saved(is_first_sync=True)
+                    cls._instance.sync_lock.release()
+                    print("\033[38;5;120m|\t...Project Scanned\t|\033[0m")
+                    print("\033[38;5;120m|\tDEBUGLETON INIT DONE\t|\033[0m")
+                    print("\033[38;5;120m---------------------------------\n\033[0m")
+        #         else: print("DEBUGLETON Already initialized INNER")
+        # else: print("DEBUGLETON Already initialized OUTER")
+        return cls._instance
+    
+
+    def sync_to_saved(self, is_first_sync=False):
+        # print(f"[sync_to_saved]: START")
+        if not is_first_sync: self.sync_lock.acquire()
+        # print(f"[sync_to_saved]: Acquired sync lock")
+        self.dir = update_debug_toggles(save_to_file=False)
+        # print(f"Synced to saved dir: {self.dir}")
+        self.abspaths, self.instances = self.dir.get_ordered_abspaths_and_instances()
+        # print(f"Synced to abspaths: {self.abspaths}")
+        with open(NEEDS_RESYNC_FILE, 'w') as f:
+            f.write('0')
+        if not is_first_sync: self.sync_lock.release()
+        # print(f"[sync_to_saved]: Released sync lock")
+        # print(f"[sync_to_saved]: END")
+
+    def needs_resync(self):
+        # print(f"[needs_resync]: START")
+        num_tries = 0
+        while self.is_syncing():
+            print(f"Waiting for Debugleton to sync... ({num_tries})")
+            time.sleep(5)
+            num_tries += 1
+            if num_tries > 10:
+                print(f"""
+                      NOTE: Debugleton is taking a long time, there's one scenario where it breaks:
+                      \n\t- If running in docker, and you deleted one of the root dirs in the volumes of docker compose,
+                      \n\t  then the debugger will not be able to find the project and will get stuck in an infinite loop.
+                      \n\t- In this case, you can restart the docker container and delete the volume in the docker compose file and it will resync.
+                      """)
+        with open(NEEDS_RESYNC_FILE, 'r') as f:
+                does_need_resync = True if f.read().strip() == '1' else False
+        # if does_need_resync: print("Resyncing Debugleton...")
+        # print(f"[needs_resync]: END")
+        return does_need_resync
+    
+    def is_syncing(self):
+        return self.sync_lock.locked()
+
+    def find_file_info(self, filepath: str):
+        filepath = filepath.lower()
+        # print(f"Finding file info for {filepath}")
+        if self.needs_resync():
+            self.sync_to_saved()
+        try:
+            filepath_id = self.abspaths.index(filepath)
+            match = self.instances[filepath_id]
+            return match.color, match.is_toggled, match.emoji
+        except ValueError:
+            print(f"Filepath not found: {filepath}")
+            return DEFAULT_COLOR, DEFAULT_TOGGLED, DEFAULT_EMOJI

backend/core/data_dir.py

@@ -0,0 +1,30 @@
+import os
+from pathlib import Path
+
+DATA_DIR = os.path.join(str(Path.home()), ".swarm-debug")
+
+_DEFAULTS = {
+    "debug_toggles.json": "[]",
+    "log_mode.txt": "all",
+    "needs_resync.txt": "1",
+    "root_dir.txt": "",
+}
+
+
+def _ensure_data_dir():
+    os.makedirs(DATA_DIR, exist_ok=True)
+
+
+def get_data_file(name: str) -> str:
+    _ensure_data_dir()
+    path = os.path.join(DATA_DIR, name)
+    if not os.path.exists(path) and name in _DEFAULTS:
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(_DEFAULTS[name])
+    return path
+
+
+TOGGLE_FILE = get_data_file("debug_toggles.json")
+NEEDS_RESYNC_FILE = get_data_file("needs_resync.txt")
+LOG_MODE_FILE = get_data_file("log_mode.txt")
+ROOT_DIR_FILE = get_data_file("root_dir.txt")

backend/core/log/__init__.py

@@ -0,0 +1,2 @@
+from backend.core.log.log_config import LogConfig, log_config
+from backend.core.log.log_mode import get_log_mode, set_log_mode

backend/core/log/log_config.py

@@ -0,0 +1,46 @@
+import logging
+from backend.core.log.log_mode import get_log_mode, set_log_mode
+
+class LogConfig:
+    _instance = None
+    MODES = {
+        "all": 1,
+        "debug": 10,
+        "test": 20,
+    }
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(LogConfig, cls).__new__(cls)
+            cls._instance._initialize_logger()
+        return cls._instance
+
+    def _initialize_logger(self):
+        for name, level in self.MODES.items():
+            logging.addLevelName(level, name.upper())
+        self.logger = logging.getLogger('custom_logger')
+        self.logger.propagate = False  # Prevent log propagation
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter('%(message)s')
+        handler.setFormatter(formatter)
+
+        # Remove existing handlers to prevent duplicate logging
+        if self.logger.hasHandlers():
+            self.logger.handlers.clear()
+
+        self.logger.addHandler(handler)
+        self.set_debug_mode(get_log_mode())
+
+    def debug_custom(self, message, mode = None, *args, **kwargs):
+        if mode is None:
+            mode = get_log_mode()
+        if self.logger.isEnabledFor(self.MODES[mode]):
+            self.logger._log(self.MODES[mode], message, args, **kwargs)
+
+    def set_debug_mode(self, mode):
+        # print(f"Setting debug mode from {current_mode} -> to {mode}")
+        if mode not in self.MODES: raise ValueError(f"Invalid mode: {mode}")
+        set_log_mode(mode)
+        self.logger.setLevel(self.MODES[mode])
+
+log_config = LogConfig()

backend/core/log/log_mode.py

@@ -0,0 +1,13 @@
+import os
+from backend.core.data_dir import LOG_MODE_FILE
+
+
+def set_log_mode(mode):
+    with open(LOG_MODE_FILE, 'w') as f:
+        f.write(mode)
+
+def get_log_mode():
+    if os.path.exists(LOG_MODE_FILE):
+        with open(LOG_MODE_FILE, 'r') as f:
+            return f.read().strip()
+    return 'all'  # Default to 'all' if the file doesn't exist

backend/core/models/DebugFile.py

@@ -0,0 +1,28 @@
+import os
+from backend.core.models.File import File
+from backend.core.DEFAULTS import DEFAULT_COLOR, DEFAULT_TOGGLED, DEFAULT_SET_MANUALLY, DEFAULT_SET_MANUALLY_EMOJI, DEFAULT_EMOJI
+
+class DebugFile(File):
+    def __init__(self, filename, path, color=DEFAULT_COLOR, is_toggled=DEFAULT_TOGGLED, 
+                 set_manually=DEFAULT_SET_MANUALLY, set_manually_emoji=DEFAULT_SET_MANUALLY_EMOJI,
+                 emoji=DEFAULT_EMOJI, directory=None):
+        super().__init__(filename, path)
+        self.color = color
+        self.is_toggled = is_toggled
+        self.set_manually = set_manually
+        self.set_manually_emoji = set_manually_emoji
+        self.emoji = emoji
+        self.directory = directory  # Reference to parent directory
+
+    def to_dict(self):
+        """
+        Converts the DebugFile object to a dictionary format.
+        """
+        return {
+            "name": os.path.basename(self.filename),
+            "color": self.color,
+            "is_toggled": self.is_toggled,
+            "set_manually": self.set_manually,
+            "set_manually_emoji": self.set_manually_emoji,
+            "emoji": self.emoji
+        }

backend/core/models/Directory.py

@@ -0,0 +1,216 @@
+import os
+import colorsys
+from backend.core.models.DebugFile import DebugFile
+from backend.core.DEFAULTS import DEFAULT_COLOR, DEFAULT_TOGGLED, DEFAULT_SET_MANUALLY, DEFAULT_SET_MANUALLY_EMOJI, DEFAULT_EMOJI, get_root_dir
+from backend.core.utils.path_mngr import get_abspath, get_root_rel_path
+
+class Directory:
+    def __init__(self, path, color=DEFAULT_COLOR, is_toggled=DEFAULT_TOGGLED, 
+                 set_manually=DEFAULT_SET_MANUALLY, set_manually_emoji=DEFAULT_SET_MANUALLY_EMOJI,
+                 emoji=DEFAULT_EMOJI):
+        self.path = path
+        # print(f"Directory init: {self.path}")
+        self.children = []  # Can contain DebugFile or other Directory objects
+        self.color = color
+        self.is_toggled = is_toggled
+        self.set_manually = set_manually
+        self.set_manually_emoji = set_manually_emoji
+        self.emoji = emoji
+
+    def __str__(self):
+        return f"Directory: {self.path}\nNum Children: {len(self.children)}\nColor: {self.color}\nToggled: {self.is_toggled}\nSet Manually: {self.set_manually}"
+    
+    def get_abspath(self):
+        return get_abspath(self.path)
+
+    def add_child(self, child):
+        """
+        Adds a child to the directory (either a DebugFile or another Directory).
+        """
+        self.children.append(child)
+
+    def get_ordered_abspaths_and_instances(self):
+        # print("[get_ordered_abspaths]: START")
+        root_dir = get_root_dir()
+        # print(f"[get_ordered_abspaths]: Curr path: {curr_file_path}")
+        # print(f"[get_ordered_abspaths]:  Dir path: {root_dir}")
+        def construct_ordered_abspaths(dir: Directory, ordered_abspaths: list):
+            dir_path = dir.path
+            full_path = os.path.join(root_dir, dir_path)
+            ordered_abspaths.append({"abspath": full_path, "instance": dir})
+            # print(f"\t[construct_ordered_abspaths]: Full path: {full_path}")
+            for child in dir.children:
+                child_abspath = os.path.join(root_dir, child.path).lower()
+                if os.path.isdir(child_abspath):
+                    construct_ordered_abspaths(child, ordered_abspaths)
+                elif os.path.isfile(child_abspath):
+                    # print(f"\t[construct_ordered_abspaths]: Child is file: {child_abspath}")
+                    ordered_abspaths.append({"abspath": child_abspath, "instance": child})
+                else:
+                    print(f"\033[38;5;120mEntry is non existent: {child_abspath}\033[0m")
+                # print(f"\t[construct_ordered_abspaths]: Finished for dir: {full_path}")
+            # print(f"\t[construct_ordered_abspaths]: RETURNING FROM DIR: {full_path}")
+            return ordered_abspaths
+        ordered_abspaths_and_instances = construct_ordered_abspaths(self, [])
+        # print("[get_ordered_abspaths]: Finished getting ordered abspaths and instances")
+        # for abspath_and_instance in ordered_abspaths_and_instances:
+        #     abspath = abspath_and_instance["abspath"]
+            # print(f"\t[get_ordered_abspaths]: Abspath: {abspath}")
+        ordered_abspaths = [abspath_and_instance["abspath"] for abspath_and_instance in ordered_abspaths_and_instances]
+        ordered_instances = [abspath_and_instance["instance"] for abspath_and_instance in ordered_abspaths_and_instances]
+        return ordered_abspaths, ordered_instances
+            
+
+    def build_structure(self):
+        print("[build_structure]: START")
+        root_dir = self.get_abspath()
+        # print(f"[build_structure]: Root dir: {root_dir}")
+        excluded_dirs = [".venv", "debugger", "node_modules", ".git", "__pycache__"]
+        project_structure = []
+
+        def construct_project_structure(dir_path: str, parent_dir: Directory):
+            # print(f"[build_structure]: Scanning dir: {dir_path}")
+            with os.scandir(dir_path) as it:
+                for entry in it:
+                    # print(f"[build_structure]: Entry: {entry.path}")
+                    if any(excluded_dir in entry.path for excluded_dir in excluded_dirs):
+                        # print(f"[build_structure]: Excluding {entry.path}")
+                        continue
+                    root_rel_path = get_root_rel_path(entry.path)
+                    if entry.is_dir():
+                        subdir = Directory(root_rel_path)
+                        construct_project_structure(entry.path, subdir)
+                        parent_dir.add_child(subdir)
+                    elif entry.is_file():
+                        debug_file = DebugFile(filename=entry.name, path=root_rel_path)
+                        if debug_file.calls_debug_function():
+                            parent_dir.add_child(debug_file)
+                    else:
+                        raise Exception(f"[build_structure]: Entry is not dir or file: {entry.path}")
+        
+        construct_project_structure(root_dir, self)        
+        # [print(f"[build_structure]: {file}") for file in project_structure]
+        # print(f"[build_structure]: END")
+        return
+
+    def to_dict(self):
+        """
+        Converts the Directory object to a dictionary format, recursively.
+        """
+        return {
+            "name": os.path.basename(self.path),
+            "color": self.color,
+            "is_toggled": self.is_toggled,
+            "set_manually": self.set_manually,
+            "set_manually_emoji": self.set_manually_emoji,
+            "emoji": self.emoji,
+            "children": [child.to_dict() if isinstance(child, DebugFile) else child.to_dict() for child in self.children]
+        }
+
+    def prune_empty(self):
+        # Recursively prune empty directories
+            # Base case) if the current directory has no children, return
+            # Recursive case) for each of the directories in the current directory, call prune_empty
+            # then remove the directory from the children of the current directory if it has no children
+        for child in self.children[:]:
+            if isinstance(child, Directory):
+                # Recursively prune empty subdirectories
+                child.prune_empty()
+                # If the subdirectory is empty after pruning, remove it
+                if len(child.children) == 0:
+                    self.children.remove(child)
+        
+    def propagate_toggled_state(self):
+        """
+        Propagates the toggled state down the hierarchy.
+        """
+        for child in self.children:
+            if isinstance(child, DebugFile) and not child.set_manually:
+                child.is_toggled = self.is_toggled
+            elif isinstance(child, Directory) and not child.set_manually:
+                child.is_toggled = self.is_toggled
+                child.propagate_toggled_state()
+
+    def propagate_color(self, parent_color=DEFAULT_COLOR):
+        """
+        Propagates the color from parent to children.
+        """
+        if self.color == DEFAULT_COLOR:
+            self.color = lighten_color(parent_color)
+        for child in self.children:
+            if isinstance(child, DebugFile) and child.color == DEFAULT_COLOR:
+                child.color = lighten_color(self.color)
+            elif isinstance(child, Directory):
+                child.propagate_color(self.color)
+
+    def load_from_json(self, json_data):
+        """
+        Loads a directory structure from a JSON file into this Directory instance.
+        """
+        for item in json_data:
+            if 'children' in item:
+                subdir = Directory(
+                    path=os.path.join(self.path, item['name']), 
+                    color=item.get('color', DEFAULT_COLOR), 
+                    is_toggled=item.get('is_toggled', DEFAULT_TOGGLED), 
+                    set_manually=item.get('set_manually', DEFAULT_SET_MANUALLY),
+                    set_manually_emoji=item.get('set_manually_emoji', DEFAULT_SET_MANUALLY_EMOJI),
+                    emoji=item.get('emoji', DEFAULT_EMOJI)
+                    )
+                
+                subdir.load_from_json(item['children'])
+                self.add_child(subdir)
+            else:
+                debug_file = DebugFile(
+                    filename=item['name'],
+                    path=os.path.join(self.path, item['name']),
+                    color=item.get('color', DEFAULT_COLOR),
+                    is_toggled=item.get('is_toggled', DEFAULT_TOGGLED),
+                    set_manually=item.get('set_manually', DEFAULT_SET_MANUALLY),
+                    set_manually_emoji=item.get('set_manually_emoji', DEFAULT_SET_MANUALLY_EMOJI),
+                    emoji=item.get('emoji', DEFAULT_EMOJI),
+                    directory=self
+                )
+                self.add_child(debug_file)
+
+    def reset_colors(self):
+        """
+        Resets the color and set_manually flag of all nodes to defaults.
+        """
+        self.color = DEFAULT_COLOR
+        self.set_manually = DEFAULT_SET_MANUALLY
+        for child in self.children:
+            if isinstance(child, DebugFile):
+                child.color = DEFAULT_COLOR
+                child.set_manually = DEFAULT_SET_MANUALLY
+            elif isinstance(child, Directory):
+                child.reset_colors()
+
+    def reset_emojis(self):
+        """
+        Resets the emoji and set_manually_emoji flag of all nodes to defaults.
+        """
+        self.emoji = DEFAULT_EMOJI
+        self.set_manually_emoji = DEFAULT_SET_MANUALLY_EMOJI
+        for child in self.children:
+            if isinstance(child, DebugFile):
+                child.emoji = DEFAULT_EMOJI
+                child.set_manually_emoji = DEFAULT_SET_MANUALLY_EMOJI
+            elif isinstance(child, Directory):
+                child.reset_emojis()
+
+
+def lighten_color(color, amount=0.1):
+    """
+    Lightens the given color by the specified amount.
+    """
+    try:
+        color = color.lstrip('#')
+        r, g, b = int(color[:2], 16), int(color[2:4], 16), int(color[4:6], 16)
+        h, l, s = colorsys.rgb_to_hls(r / 255.0, g / 255.0, b / 255.0)
+        l = min(1, l + amount)
+        r, g, b = colorsys.hls_to_rgb(h, l, s)
+        return '#{:02x}{:02x}{:02x}'.format(int(r * 255), int(g * 255), int(b * 255))
+    except Exception as e:
+        print(f"Error lightening color {color}: {e}")
+        return color

backend/core/models/File.py

@@ -0,0 +1,29 @@
+import os
+from backend.core.utils.path_mngr import get_abspath
+
+class File:
+    def __init__(self, filename, path):
+        self.filename = filename
+        self.path = path
+    
+    def get_abspath(self):
+        return get_abspath(self.path)
+
+    def calls_debug_function(self):
+        """
+        Checks if the file calls the debug function.
+        """
+        full_path = self.get_abspath()
+
+        if not full_path.endswith('.py') or full_path.endswith('.pyc'):
+            result = False
+        else:
+            try:
+                with open(full_path, 'r', encoding='utf-8') as file:
+                    content = file.read()
+                result = 'debug(' in content
+            except (UnicodeDecodeError, FileNotFoundError) as e:
+                print(f"Error reading file {full_path}")
+                result = False
+        # print(f"??calls_debug_function?? {result}")
+        return result

backend/core/models/__init__.py

@@ -0,0 +1,4 @@
+from backend.core.models.File import File
+from backend.core.models.DebugFile import DebugFile
+from backend.core.models.Directory import Directory
+from backend.core.models.project_scanner import update_debug_toggles, dir_to_output_format