For this code: `import sqlite3
import datetime

class Database:
    def __init__(self, db_path='object_tracking.db'):
        self.conn = sqlite3.connect(db_path)
        self.cursor = self.conn.cursor()
        self.create_table()

    def create_table(self):
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS tracked_objects (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                class_name TEXT,
                x1 INTEGER,
                y1 INTEGER,
                width INTEGER,
                height INTEGER,
                last_seen DATETIME,
                comment TEXT
            )
        ''')
        self.conn.commit()

    def fetch_objects(self, class_name=None):
        if class_name:
            self.cursor.execute('SELECT * FROM tracked_objects WHERE class_name=?', (class_name,))
        else:
            self.cursor.execute('SELECT * FROM tracked_objects')
        return self.cursor.fetchall()

    def fetch_all_objects(self):
        self.cursor.execute('SELECT * FROM tracked_objects')
        return self.cursor.fetchall()

    def update_object(self, obj_id, x1, y1, width, height):
        last_seen = datetime.datetime.now().isoformat()
        self.cursor.execute('''
            UPDATE tracked_objects 
            SET x1=?, y1=?, width=?, height=?, last_seen=? 
            WHERE id=?
        ''', (x1, y1, width, height, last_seen, obj_id))
        self.conn.commit()

    def insert_object(self, class_name, x1, y1, width, height):
        last_seen = datetime.datetime.now().isoformat()
        self.cursor.execute('''
            INSERT INTO tracked_objects (class_name, x1, y1, width, height, last_seen) 
            VALUES (?, ?, ?, ?, ?, ?)
        ''', (class_name, x1, y1, width, height, last_seen))
        self.conn.commit()

    def update_comment(self, obj_id, comment):
        self.cursor.execute('''
            UPDATE tracked_objects 
            SET comment=? 
            WHERE id=?
        ''', (comment, obj_id))
        self.conn.commit()`,`# Import necessary libraries
from Database import Database
from ObjectDetection import ObjectDetection
from ObjectTracker import ObjectTracker
import cv2

def main():
    db = Database()
    detection_model = ObjectDetection()
    tracker = ObjectTracker(db, detection_model)

    cap = cv2.VideoCapture(0)
    cap.set(3, 640)
    cap.set(4, 480)

    while True:
        success, img = cap.read()
        if not success:
            break

        img = tracker.track_objects(img)
        cv2.imshow('Webcam', img)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == "__main__":
    main()`,`from ultralytics import YOLO

class ObjectDetection:
    def __init__(self, model_path="yolo-Weights/yolov8n.pt"):
        self.model = YOLO(model_path)
        self.classNames = ["person", "bicycle", "car", "motorbike", "aeroplane", "bus", "train", "truck", "boat",
                           "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat",
                           "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella",
                           "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat",
                           "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup",
                           "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli",
                           "carrot", "hot dog", "pizza", "donut", "cake", "chair", "sofa", "pottedplant", "bed",
                           "diningtable", "toilet", "tvmonitor", "laptop", "mouse", "remote", "keyboard", "cell phone",
                           "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors",
                           "teddy bear", "hair drier", "toothbrush"]
        self.allowed_classes = {0, 24, 25, 26, 31, 36, 37, 39, 40, 41, 53, 63, 65, 67}

    def detect_objects(self, img):
        results = self.model(img, stream=True)
        detections = []
        for r in results:
            for box in r.boxes:
                confidence = box.conf[0].item()
                if confidence < 0.55:
                    continue

                cls = int(box.cls[0])
                if cls not in self.allowed_classes:
                    continue

                x1, y1, x2, y2 = map(int, box.xyxy[0])
                width, height = x2 - x1, y2 - y1
                class_name = self.classNames[cls]
                detections.append((class_name, x1, y1, width, height, confidence))
        return detections`,`import cv2
from deep_sort_realtime.deepsort_tracker import DeepSort
from datetime import datetime, timedelta

class ObjectTracker:
    def __init__(self, db, detection_model):
        self.db = db
        self.detection_model = detection_model
        self.tracker = DeepSort(max_age=10, n_init=3, nms_max_overlap=1.0, max_cosine_distance=0.4, nn_budget=None)

    def is_near(self, existing_obj, new_obj, threshold=30):
        ex, ey, ew, eh = existing_obj
        nx, ny, nw, nh = new_obj
        return not (nx > ex + ew + threshold or
                    nx + nw < ex - threshold or
                    ny > ey + eh + threshold or
                    ny + nh < ey - threshold)

    def is_near_edge(self, x1, y1, width, height, frame_width, frame_height, threshold=50):
        # Check if any side is within threshold of edge
        near_left = x1 <= threshold
        near_right = x1 + width >= frame_width - threshold
        near_top = y1 <= threshold
        near_bottom = y1 + height >= frame_height - threshold
        return near_left or near_right or near_top or near_bottom

    def check_for_lost_objects(self, frame_width, frame_height):
        all_objects = self.db.fetch_all_objects()
        now = datetime.now()
        fifteen_minutes_ago = now - timedelta(minutes=15)
        edge_threshold = 50  # pixels
        for obj in all_objects:
            obj_id = obj[0]
            class_name = obj[1]
            x1 = obj[2]
            y1 = obj[3]
            width = obj[4]
            height = obj[5]
            last_seen_str = obj[6]
            comment = obj[7]

            last_seen = datetime.fromisoformat(last_seen_str)

            if last_seen < fifteen_minutes_ago and (comment is None or comment == ''):
                # Check if object was near edge
                if self.is_near_edge(x1, y1, width, height, frame_width, frame_height, edge_threshold):
                    self.db.update_comment(obj_id, 'Item was last seen leaving the room')

    def track_objects(self, img):
        frame_height, frame_width = img.shape[:2]
        detections = self.detection_model.detect_objects(img)
        formatted_detections = []

        for class_name, x1, y1, width, height, confidence in detections:
            existing_objs = self.db.fetch_objects(class_name)
            new_obj = (x1, y1, width, height)
            preexisting_obj = False
            for existing_obj in existing_objs:
                db_x1, db_y1, db_width, db_height = existing_obj[2], existing_obj[3], existing_obj[4], existing_obj[5]
                if self.is_near((db_x1, db_y1, db_width, db_height), new_obj):
                    preexisting_obj = True
                    self.db.update_object(existing_obj[0], x1, y1, width, height)
                    break  # Update only one matching object

            if not preexisting_obj:
                self.db.insert_object(class_name, x1, y1, width, height)

            formatted_detections.append(([x1, y1, width, height], confidence, class_name))
            cv2.rectangle(img, (x1, y1), (x1 + width, y1 + height), (255, 0, 255), 3)
            cv2.putText(img, f'{class_name} {confidence:.2f}', (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 0), 2)

        tracks = self.tracker.update_tracks(formatted_detections, frame=img)
        self.check_for_lost_objects(frame_width, frame_height)
        return img`, remove the comment part of the database record and replace it with a status. This could be an enum and be like item left frame, item in frame based on if its in frame or not. Also, fully document the code, this includes doc strings and such for functions and classes. For really long functions maybe a few inline comments.