Spaces:
Running on Zero
Running on Zero
| """ | |
| SAULSGPT — LAYER 5: EXTERNAL TOOLS | |
| ===================================== | |
| Two tools: | |
| Tool 1 — IndiaKanoon Case Law Fetcher | |
| Scrapes indiankanoon.org for relevant judgments | |
| Called AFTER Layer 3 for Case Analysis mode only | |
| Appended to final response as supplementary section | |
| Gracefully skipped if offline or blocked | |
| Tool 2 — APScheduler Background Auto-Updater | |
| Re-runs scraper + chunk_and_embed every 30 days | |
| Keeps ChromaDB current with latest amendments | |
| Runs as background daemon | |
| Called once when FastAPI server starts | |
| Run standalone to test IndiaKanoon: | |
| python layer5_external.py | |
| Import in orchestrator: | |
| from layer5_external import fetch_case_law, start_auto_updater | |
| """ | |
| import os | |
| import sys | |
| import time | |
| import threading | |
| import hashlib | |
| import subprocess | |
| import requests | |
| from bs4 import BeautifulSoup | |
| from datetime import datetime | |
| from typing import List, Dict | |
| # DuckDuckGo search — free, no API key needed | |
| # Install: pip install duckduckgo-search | |
| try: | |
| try: | |
| from duckduckgo_search import DDGS | |
| except ImportError: | |
| from ddgs import DDGS | |
| DDGS_AVAILABLE = True | |
| except ImportError: | |
| DDGS_AVAILABLE = False | |
| print("[Layer 5] WARNING: duckduckgo-search not installed.") | |
| print(" Run: pip install duckduckgo-search") | |
| # ───────────────────────────────────────────────────────────── | |
| # CONFIG | |
| # ───────────────────────────────────────────────────────────── | |
| # Absolute paths for subprocess updater | |
| BASE_DIR = os.path.dirname(os.path.abspath(__file__)) | |
| REPO_DIR = os.path.dirname(BASE_DIR) | |
| SCRAPER = os.path.join(BASE_DIR, "01_scraper.py") | |
| CHUNKER = os.path.join(BASE_DIR, "02_chunk_and_embed.py") | |
| # IndiaKanoon config | |
| IK_BASE_URL = "https://indiankanoon.org" | |
| IK_TIMEOUT = 8 # seconds — don't block main pipeline long | |
| IK_MAX_RESULTS = 2 # only top 2 judgments | |
| # Browser User-Agent — required to avoid being blocked | |
| HEADERS = { | |
| "User-Agent": ( | |
| "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " | |
| "AppleWebKit/537.36 (KHTML, like Gecko) " | |
| "Chrome/120.0.0.0 Safari/537.36" | |
| ), | |
| "Accept": "text/html,application/xhtml+xml", | |
| "Accept-Language": "en-IN,en;q=0.9", | |
| } | |
| # ───────────────────────────────────────────────────────────── | |
| # TOOL 1 — INDIAKANOON CASE LAW FETCHER | |
| # ───────────────────────────────────────────────────────────── | |
| def fetch_case_law( | |
| query: str, | |
| act_name: str = "", | |
| section_num: str = "" | |
| ) -> str: | |
| """ | |
| Fetches relevant Supreme Court / High Court judgments | |
| from IndiaKanoon for the given legal query. | |
| Called AFTER Layer 3 generates response. | |
| Result is APPENDED to final response — not used for reasoning. | |
| This avoids polluting the LLM context with unverified web data. | |
| Args: | |
| query : user's legal query (reformulated from Layer 1) | |
| act_name : act name from retrieved sections (improves search) | |
| section_num: section number from retrieved sections | |
| Returns: | |
| formatted string of top cases to append to response | |
| OR empty string if offline/blocked/no results | |
| Example: | |
| result = fetch_case_law( | |
| "employer unpaid wages", | |
| act_name="Payment of Wages Act", | |
| section_num="15" | |
| ) | |
| """ | |
| print("[Layer 5] 🌐 Fetching relevant case law from IndiaKanoon...") | |
| # 1. Clean database act name | |
| # ChromaDB stores names like "NIA_from_db" — IndiaKanoon won't understand | |
| # Strip "_from_db" suffix and underscores before searching | |
| clean_act = act_name.replace("_from_db", "").replace("_", " ").strip() | |
| # 2. Map common acronyms to full act names IndiaKanoon recognises | |
| ACT_MAP = { | |
| "NIA": "Negotiable Instruments Act", | |
| "IPC": "Indian Penal Code", | |
| "CRPC": "Criminal Procedure Code", | |
| "CrPC": "Criminal Procedure Code", | |
| "BNS": "Bharatiya Nyaya Sanhita", | |
| "BNSS": "Bharatiya Nagarik Suraksha Sanhita", | |
| "BSA": "Bharatiya Sakshya Adhiniyam", | |
| "CPC": "Civil Procedure Code", | |
| "IEA": "Indian Evidence Act", | |
| "HMA": "Hindu Marriage Act", | |
| "MVA": "Motor Vehicles Act", | |
| "IDA": "Industrial Disputes Act", | |
| } | |
| search_act = ACT_MAP.get(clean_act.upper(), clean_act) | |
| # 3. Build STRICT search query — no user story, just law | |
| # Long user queries choke IndiaKanoon keyword search | |
| # Only use act name + section number for precise results | |
| if search_act and section_num: | |
| search_query = f'"{search_act}" AND "Section {section_num}"' | |
| elif search_act: | |
| search_query = f'"{search_act}"' | |
| else: | |
| # Fallback: first 4 words of query only | |
| search_query = " ".join(query.split()[:4]) | |
| print(f"[Layer 5] Search query: {search_query}") | |
| search_url = ( | |
| f"{IK_BASE_URL}/search/" | |
| f"?formInput={requests.utils.quote(search_query)}" | |
| f"&type=judgments" | |
| ) | |
| try: | |
| response = requests.get( | |
| search_url, | |
| headers=HEADERS, | |
| timeout=IK_TIMEOUT | |
| ) | |
| response.raise_for_status() | |
| soup = response.text | |
| bsoup = BeautifulSoup(soup, 'html.parser') | |
| # IndiaKanoon search result structure | |
| # Try multiple selectors — site structure can vary | |
| results = ( | |
| bsoup.find_all('div', class_='result', limit=IK_MAX_RESULTS) or | |
| bsoup.find_all('div', class_='result_title', limit=IK_MAX_RESULTS) or | |
| bsoup.find_all('li', class_='result', limit=IK_MAX_RESULTS) | |
| ) | |
| if not results: | |
| print("[Layer 5] ℹ️ No case law results found.") | |
| return "" | |
| cases = [] | |
| for idx, res in enumerate(results, 1): | |
| try: | |
| # Try to extract title | |
| title_container = ( | |
| res.find('div', class_='result_title') or | |
| res.find('a') or | |
| res | |
| ) | |
| title_tag = ( | |
| title_container.find('a') | |
| if title_container.name != 'a' | |
| else title_container | |
| ) | |
| if not title_tag: | |
| continue | |
| title = title_tag.get_text(strip=True) | |
| href = title_tag.get('href', '') | |
| link = f"{IK_BASE_URL}{href}" if href.startswith('/') else href | |
| # Try to extract snippet | |
| snippet_tag = ( | |
| res.find('div', class_='headline') or | |
| res.find('div', class_='snippet') or | |
| res.find('p') | |
| ) | |
| snippet = ( | |
| snippet_tag.get_text(strip=True)[:200] | |
| if snippet_tag | |
| else "See full judgment at link." | |
| ) | |
| cases.append( | |
| f"Case {idx}: {title}\n" | |
| f" Summary: {snippet}\n" | |
| f" Link: {link}" | |
| ) | |
| # ── SELF-HEALING PRECEDENT INGESTION: Auto-ingest into Precedents DB ── | |
| try: | |
| from precedent_engine import PrecedentIntelligenceEngine | |
| PrecedentIntelligenceEngine.auto_ingest_case_precedent({ | |
| "case_name": title, | |
| "citation": "IndiaKanoon / Web Precedent", | |
| "court": "Supreme Court / High Court", | |
| "statute": f"{search_act} {section_num}".strip(), | |
| "summary": snippet | |
| }) | |
| except Exception as e: | |
| pass | |
| except Exception: | |
| # Skip malformed result — don't crash | |
| continue | |
| if not cases: | |
| return "" | |
| result_block = ( | |
| "\n\n📚 RELEVANT CASE LAW (IndiaKanoon)\n" | |
| + "─" * 40 + "\n" | |
| + "\n\n".join(cases) | |
| + "\n" + "─" * 40 | |
| + "\nNote: Case law provided for reference only. " | |
| "Verify judgments before citing." | |
| ) | |
| print(f"[Layer 5] ✅ Found {len(cases)} relevant case(s).") | |
| return result_block | |
| except requests.exceptions.Timeout: | |
| print("[Layer 5] ⚠️ IndiaKanoon request timed out.") | |
| return "" | |
| except requests.exceptions.ConnectionError: | |
| print("[Layer 5] ⚠️ No internet connection. Skipping case law.") | |
| return "" | |
| except requests.exceptions.HTTPError as e: | |
| print(f"[Layer 5] ⚠️ IndiaKanoon HTTP error: {e}") | |
| return "" | |
| except Exception as e: | |
| print(f"[Layer 5] ⚠️ Case law fetch error: {e}") | |
| return "" | |
| # ───────────────────────────────────────────────────────────── | |
| # TOOL 2 — BACKGROUND AUTO-UPDATER | |
| # ───────────────────────────────────────────────────────────── | |
| # ───────────────────────────────────────────────────────────── | |
| # TOOL 2 — AGENTIC FALLBACK WEB SEARCH | |
| # Triggered ONLY when Layer 2 ChromaDB returns zero results | |
| # AND Knowledge Graph also found nothing | |
| # Searches the web for Indian law info on the query | |
| # Formats results to look like ChromaDB chunks | |
| # So Layer 3 reads them without knowing the difference | |
| # ───────────────────────────────────────────────────────────── | |
| def fallback_web_search(query: str) -> list: | |
| """ | |
| Safety net when local database has no relevant data. | |
| Searches the live web for Indian law information. | |
| Formats results to mimic ChromaDB chunks so Layer 3 | |
| can process them exactly like local database results. | |
| Triggered by orchestrator ONLY when: | |
| 1. Layer 2 returns zero results AND | |
| 2. Knowledge Graph found no relationships | |
| This guarantees SaulGPT always finds an answer | |
| even if local database is incomplete. | |
| Args: | |
| query: user query (reformulated from Layer 1) | |
| Returns: | |
| list of mock chunk dicts matching ChromaDB format | |
| OR empty list if web search also fails | |
| Example: | |
| results = fallback_web_search( | |
| "Industrial Disputes Act retrenchment definition" | |
| ) | |
| # Returns list of dicts with act_name, section_number, | |
| # is_repealed, content — same format as ChromaDB chunks | |
| """ | |
| print("[Layer 5] [Web] Local DB empty. Initiating Web Fallback Search...") | |
| if not DDGS_AVAILABLE: | |
| print("[Layer 5] WARNING: duckduckgo-search not installed. Skipping.") | |
| print(" Run: pip install duckduckgo-search") | |
| return [] | |
| try: | |
| # ── PII Scrubber ── | |
| # Replace personal identifiers with category labels | |
| # to preserve search query structure without leaking data | |
| import re | |
| scrubbed_query = query | |
| # Replace email addresses with EMAIL label | |
| scrubbed_query = re.sub(r'[\w.+-]+@[\w-]+\.[a-z]+', '[EMAIL]', scrubbed_query) | |
| # Replace phone numbers with PHONE label | |
| scrubbed_query = re.sub(r'\b\d{10}\b|\b\+91\d{10}\b', '[PHONE]', scrubbed_query) | |
| # Replace Aadhaar-like numbers (12 digits) with ID label | |
| scrubbed_query = re.sub(r'\b\d{12}\b', '[ID_NUMBER]', scrubbed_query) | |
| # Replace individual person names (capitalized words not in legal vocab) | |
| LEGAL_CAPS = { | |
| "Industrial", "Disputes", "Act", "Supreme", "Court", | |
| "High", "Section", "Article", "India", "Indian", | |
| "Payment", "Wages", "Motor", "Vehicles", "Criminal", | |
| "Procedure", "Evidence", "Penal", "Code", "Hindu", | |
| "Marriage", "Negotiable", "Instruments", "Civil", | |
| "Constitution", "Labour", "Consumer", "Protection" | |
| } | |
| scrubbed_query = re.sub( | |
| r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b', | |
| lambda m: m.group(0) if any( | |
| word in LEGAL_CAPS for word in m.group(0).split() | |
| ) else '[NAME]', | |
| scrubbed_query | |
| ).strip() | |
| # Clean up extra spaces from removed tokens | |
| scrubbed_query = re.sub(r'\s+', ' ', scrubbed_query).strip() | |
| if scrubbed_query != query: | |
| print(f"[Layer 5] [PII] PII scrubbed from query before web search") | |
| # Clean conversational filler to form a high-precision legal search query | |
| clean_keywords = re.sub( | |
| r'(?i)\b(i|my|me|we|us|what are|what is|tell me about|how to|a seller on|sent me a|and refused|what)\b', | |
| ' ', | |
| scrubbed_query | |
| ) | |
| clean_keywords = re.sub(r'\s+', ' ', clean_keywords).strip() | |
| search_query = f"{clean_keywords} Indian law" | |
| print(f"[Layer 5] Searching: {search_query[:100]}...") | |
| results = [] | |
| # Primary: Direct HTML DuckDuckGo Search (fast, reliable, no package breaking changes) | |
| try: | |
| ddg_headers = { | |
| "User-Agent": ( | |
| "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " | |
| "AppleWebKit/537.36 (KHTML, like Gecko) " | |
| "Chrome/120.0.0.0 Safari/537.36" | |
| ), | |
| "Accept": "text/html,application/xhtml+xml", | |
| "Accept-Language": "en-IN,en;q=0.9", | |
| } | |
| resp = requests.post( | |
| "https://html.duckduckgo.com/html/", | |
| data={"q": search_query}, | |
| headers=ddg_headers, | |
| timeout=8 | |
| ) | |
| if resp.status_code == 200: | |
| soup = BeautifulSoup(resp.text, "html.parser") | |
| for div in soup.find_all("div", class_="result"): | |
| a_title = div.find("a", class_="result__a") | |
| a_snippet = div.find("a", class_="result__snippet") or div.find("div", class_="result__snippet") | |
| a_url = div.find("a", class_="result__url") | |
| if a_title: | |
| t = a_title.get_text(strip=True) | |
| s = a_snippet.get_text(strip=True) if a_snippet else "" | |
| u = a_url.get_text(strip=True) if a_url else a_title.get("href", "") | |
| if t and (s or u): | |
| results.append({"title": t, "body": s, "href": u}) | |
| except Exception as html_err: | |
| print(f"[Layer 5] Direct HTML search error: {html_err}") | |
| # Secondary: DDGS package fallback if available | |
| if not results and DDGS_AVAILABLE: | |
| try: | |
| results = list(DDGS().text(search_query, max_results=6)) | |
| except Exception as ddg_err: | |
| print(f"[Layer 5] DDGS error: {ddg_err}") | |
| if not results: | |
| print("[Layer 5] No matching web results.") | |
| return [] | |
| # Prefer Indian legal sources if present, otherwise use top results | |
| INDIAN_DOMAINS = ("indiankanoon.org", "indiacode.nic.in", "scconline.com", | |
| "manupatra.com", "barandbench.com", "livelaw.in", | |
| "supremecourtcaselaw.com", "lawctopus.com", "vakilsearch.com", "legalserviceindia.com", "juristco.com", "lawcurb.com") | |
| legal_results = [r for r in results if any(d in r.get("href", "").lower() or d in r.get("body", "").lower() for d in INDIAN_DOMAINS)] | |
| final_results = legal_results[:4] if legal_results else results[:4] | |
| mock_chunks = [] | |
| for i, res in enumerate(final_results, 1): | |
| href = res.get('href', '') | |
| is_primary = any(d in href.lower() for d in ["indiankanoon.org", "indiacode.nic.in", "scconline.com"]) | |
| source_type = "primary" if is_primary else "commentary" | |
| SCORE_MAP = {"primary": 0.85, "commentary": 0.75} | |
| # Attempt to fetch rich body text from the article page | |
| body_content = res.get('body', '') | |
| if href.startswith('http') and i <= 2: | |
| try: | |
| page_resp = requests.get( | |
| href, | |
| headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}, | |
| timeout=3.5 | |
| ) | |
| if page_resp.status_code == 200: | |
| page_soup = BeautifulSoup(page_resp.text, "html.parser") | |
| for tag in page_soup(["script", "style", "nav", "header", "footer"]): | |
| tag.decompose() | |
| paras = [p.get_text(strip=True) for p in page_soup.find_all("p") if len(p.get_text(strip=True)) > 40] | |
| if paras: | |
| extracted_text = " \n".join(paras[:6]) | |
| if len(extracted_text) > 150: | |
| body_content = extracted_text[:1500] | |
| except Exception: | |
| pass | |
| mock_chunks.append({ | |
| "act_name": "Live Web Search (Indian Law)", | |
| "section_number": f"Web Source {i}", | |
| "is_repealed": False, | |
| "law_type": "Web Search Legal Intelligence", | |
| "source_type": source_type, | |
| "content": ( | |
| f"TOPIC / TITLE: {res.get('title', '')}\n" | |
| f"LEGAL SUMMARY & PROVISIONS: {body_content}\n" | |
| f"SOURCE REFERENCE: {href}" | |
| ), | |
| "relevance_score": SCORE_MAP.get(source_type, 0.75) | |
| }) | |
| print(f"[Layer 5] [Web] Web fallback found {len(mock_chunks)} results.") | |
| # ── CONTINUOUS LEARNING: Auto-ingest into ChromaDB & Expand GNN Triples ── | |
| _auto_ingest_web_chunks_into_chromadb(mock_chunks) | |
| try: | |
| from auto_triplifier import auto_expand_knowledge_graph_from_web | |
| auto_expand_knowledge_graph_from_web(mock_chunks) | |
| except Exception as e: | |
| print(f"[Layer 5] Auto-triplifier trigger error: {e}") | |
| return mock_chunks | |
| except Exception as e: | |
| print(f"[Layer 5] WARNING: Web fallback failed: {e}") | |
| return [] | |
| def _auto_ingest_web_chunks_into_chromadb(mock_chunks: list, async_mode: bool = True): | |
| """ | |
| Continuous Self-Learning Ingester: | |
| Automatically embeds and upserts newly retrieved high-quality web legal chunks | |
| directly into ChromaDB (`saulgpt_indian_laws`) so the database expands over time. | |
| """ | |
| if not mock_chunks: | |
| return | |
| def _ingest_worker(): | |
| try: | |
| import hashlib | |
| import chromadb | |
| from chromadb.config import Settings | |
| from sentence_transformers import SentenceTransformer | |
| # Setup ChromaDB persistent client pointing to official vector_db path | |
| chroma_dir = os.path.join(REPO_DIR, "data", "vector_db") | |
| if not os.path.exists(chroma_dir): | |
| chroma_dir = os.path.join(os.path.dirname(__file__), "data", "vector_db") | |
| client = chromadb.PersistentClient( | |
| path=chroma_dir, | |
| settings=Settings(anonymized_telemetry=False) | |
| ) | |
| collection = client.get_or_create_collection( | |
| name="saulgpt_indian_laws", | |
| metadata={"hnsw:space": "cosine"} | |
| ) | |
| model = SentenceTransformer("all-MiniLM-L6-v2") | |
| ids_to_add = [] | |
| docs_to_add = [] | |
| metas_to_add = [] | |
| embs_to_add = [] | |
| for chunk in mock_chunks: | |
| content = chunk.get("content", "") | |
| if len(content) < 100: | |
| continue | |
| # Deterministic MD5 ID based on content | |
| chunk_hash = hashlib.md5(content.encode("utf-8")).hexdigest()[:12] | |
| chunk_id = f"web_ingest_{chunk_hash}" | |
| # Check if already present | |
| existing = collection.get(ids=[chunk_id]) | |
| if existing and existing.get("ids"): | |
| continue | |
| emb = model.encode(content).tolist() | |
| ids_to_add.append(chunk_id) | |
| docs_to_add.append(content) | |
| embs_to_add.append(emb) | |
| metas_to_add.append({ | |
| "act_name": "Web Ingested Legal Rule", | |
| "section_number": str(chunk.get("section_number", "Web Source")), | |
| "law_type": "web_live_ingest", | |
| "source_type": chunk.get("source_type", "primary"), | |
| "status": "active", | |
| "ingestion_date": datetime.now().isoformat() | |
| }) | |
| if ids_to_add: | |
| collection.upsert( | |
| ids=ids_to_add, | |
| documents=docs_to_add, | |
| embeddings=embs_to_add, | |
| metadatas=metas_to_add | |
| ) | |
| print(f"[ChromaDB Ingest] [OK] Dynamically learned {len(ids_to_add)} new web statute chunk(s) into saulgpt_indian_laws! Total chunks now: {collection.count()}") | |
| except Exception as err: | |
| import traceback | |
| print(f"[ChromaDB Ingest] WARNING: Dynamic ingestion failed: {err}") | |
| traceback.print_exc() | |
| if async_mode: | |
| t = threading.Thread(target=_ingest_worker, daemon=True, name="ChromaDB_Dynamic_Ingester") | |
| t.start() | |
| return t | |
| else: | |
| _ingest_worker() | |
| # ───────────────────────────────────────────────────────────── | |
| # THREAD-SAFE DATABASE AUTO-UPDATER & SCHEDULER | |
| # ───────────────────────────────────────────────────────────── | |
| _UPDATE_LOCK = threading.Lock() | |
| _IS_UPDATING = False | |
| def run_database_update(): | |
| """ | |
| Executes scraper + chunker to refresh ChromaDB. | |
| Guarded with strict thread locking to prevent overlapping runs under high load. | |
| """ | |
| global _IS_UPDATING | |
| if not _UPDATE_LOCK.acquire(blocking=False): | |
| print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] ⏳ DB Update already running in background. Skipping duplicate trigger.") | |
| return | |
| _IS_UPDATING = True | |
| timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S') | |
| print(f"\n[{timestamp}] 🔄 SCHEDULED DB UPDATE STARTING...") | |
| try: | |
| if os.path.exists(SCRAPER): | |
| print(" → Running 01_scraper.py...") | |
| subprocess.run([sys.executable, SCRAPER], check=True, cwd=REPO_DIR, timeout=300) | |
| print(" → Scraper complete.") | |
| if os.path.exists(CHUNKER): | |
| print(" → Running 02_chunk_and_embed.py...") | |
| subprocess.run([sys.executable, CHUNKER], check=True, cwd=REPO_DIR, timeout=300) | |
| print(" → Chunker complete.") | |
| done_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S') | |
| print(f"[{done_time}] ✅ DATABASE UPDATE COMPLETE.\n") | |
| except subprocess.CalledProcessError as e: | |
| print(f"🚨 UPDATE FAILED: Script crashed. Error: {e}") | |
| except subprocess.TimeoutExpired: | |
| print("🚨 UPDATE FAILED: Process timed out after 300s.") | |
| except Exception as e: | |
| print(f"🚨 UPDATE FAILED: Unknown error: {e}") | |
| finally: | |
| _IS_UPDATING = False | |
| _UPDATE_LOCK.release() | |
| def run_database_update_async(): | |
| """Non-blocking asynchronous wrapper for scheduler and manual triggers.""" | |
| worker = threading.Thread(target=run_database_update, daemon=True, name="ChromaDB_Auto_Updater") | |
| worker.start() | |
| def start_auto_updater(): | |
| """ | |
| Starts the APScheduler background job. | |
| Uses asynchronous worker so it never blocks web requests or API threads. | |
| """ | |
| try: | |
| from apscheduler.schedulers.background import BackgroundScheduler | |
| scheduler = BackgroundScheduler() | |
| scheduler.add_job( | |
| run_database_update_async, | |
| trigger = 'interval', | |
| days = 30, | |
| id = 'monthly_law_update', | |
| replace_existing = True, | |
| max_instances = 1 | |
| ) | |
| scheduler.start() | |
| next_run = datetime.now().strftime('%Y-%m-%d') | |
| print(f"⏳ Auto-updater started. DB will refresh every 30 days.") | |
| print(f" Next update: 30 days from {next_run}") | |
| return scheduler | |
| except ImportError: | |
| print("⚠️ APScheduler not installed. Auto-updater disabled.") | |
| return None | |
| except Exception as e: | |
| print(f"⚠️ Auto-updater failed to start: {e}") | |
| return None | |
| # ───────────────────────────────────────────────────────────── | |
| # TEST RUNNER | |
| # ───────────────────────────────────────────────────────────── | |
| if __name__ == "__main__": | |
| print("-" * 55) | |
| print("SaulGPT — Layer 5 External Tools Test") | |
| print("-" * 55) | |
| # Test IndiaKanoon fetcher | |
| print("\nTest: Fetching case law for wage dispute...") | |
| result = fetch_case_law( | |
| query = "employer unpaid wages legal remedy", | |
| act_name = "Payment of Wages Act", | |
| section_num = "15" | |
| ) | |
| if result: | |
| print("\n" + result) | |
| else: | |
| print("No results (offline or blocked)") | |
| print("\n" + "=" * 55) | |
| print("Layer 5 External Tools test complete.") |