1#!/usr/bin/env python3
2"""
3Environment Setup for NotebookLM Skill
4Manages virtual environment and dependencies automatically
5"""
6 
7import os
8import sys
9import subprocess
10import venv
11from pathlib import Path
12 
13 
14class SkillEnvironment:
15    """Manages skill-specific virtual environment"""
16 
17    def __init__(self):
18        # Skill directory paths
19        self.skill_dir = Path(__file__).parent.parent
20        self.venv_dir = self.skill_dir / ".venv"
21        self.requirements_file = self.skill_dir / "requirements.txt"
22 
23        # Python executable in venv
24        if os.name == 'nt':  # Windows
25            self.venv_python = self.venv_dir / "Scripts" / "python.exe"
26            self.venv_pip = self.venv_dir / "Scripts" / "pip.exe"
27        else:  # Unix/Linux/Mac
28            self.venv_python = self.venv_dir / "bin" / "python"
29            self.venv_pip = self.venv_dir / "bin" / "pip"
30 
31    def ensure_venv(self) -> bool:
32        """Ensure virtual environment exists and is set up"""
33 
34        # Check if we're already in the correct venv
35        if self.is_in_skill_venv():
36            print("✅ Already running in skill virtual environment")
37            return True
38 
39        # Create venv if it doesn't exist
40        if not self.venv_dir.exists():
41            print(f"🔧 Creating virtual environment in {self.venv_dir.name}/")
42            try:
43                venv.create(self.venv_dir, with_pip=True)
44                print("✅ Virtual environment created")
45            except Exception as e:
46                print(f"❌ Failed to create venv: {e}")
47                return False
48 
49        # Install/update dependencies
50        if self.requirements_file.exists():
51            print("📦 Installing dependencies...")
52            try:
53                # Upgrade pip first
54                subprocess.run(
55                    [str(self.venv_pip), "install", "--upgrade", "pip"],
56                    check=True,
57                    capture_output=True,
58                    text=True
59                )
60 
61                # Install requirements
62                result = subprocess.run(
63                    [str(self.venv_pip), "install", "-r", str(self.requirements_file)],
64                    check=True,
65                    capture_output=True,
66                    text=True
67                )
68                print("✅ Dependencies installed")
69 
70                # Install Chrome for Patchright (not Chromium!)
71                # Using real Chrome ensures cross-platform reliability and consistent browser fingerprinting
72                # See: https://github.com/Kaliiiiiiiiii-Vinyzu/patchright-python#anti-detection
73                print("🌐 Installing Google Chrome for Patchright...")
74                try:
75                    subprocess.run(
76                        [str(self.venv_python), "-m", "patchright", "install", "chrome"],
77                        check=True,
78                        capture_output=True,
79                        text=True
80                    )
81                    print("✅ Chrome installed")
82                except subprocess.CalledProcessError as e:
83                    print(f"⚠️ Warning: Failed to install Chrome: {e}")
84                    print("   You may need to run manually: python -m patchright install chrome")
85                    print("   Chrome is required (not Chromium) for reliability!")
86 
87                return True
88            except subprocess.CalledProcessError as e:
89                print(f"❌ Failed to install dependencies: {e}")
90                print(f"   Output: {e.output if hasattr(e, 'output') else 'No output'}")
91                return False
92        else:
93            print("⚠️ No requirements.txt found, skipping dependency installation")
94            return True
95 
96    def is_in_skill_venv(self) -> bool:
97        """Check if we're already running in the skill's venv"""
98        if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
99            # We're in a venv, check if it's ours
100            venv_path = Path(sys.prefix)
101            return venv_path == self.venv_dir
102        return False
103 
104    def get_python_executable(self) -> str:
105        """Get the correct Python executable to use"""
106        if self.venv_python.exists():
107            return str(self.venv_python)
108        return sys.executable
109 
110    def run_script(self, script_name: str, args: list = None) -> int:
111        """Run a script with the virtual environment"""
112        script_path = self.skill_dir / "scripts" / script_name
113 
114        if not script_path.exists():
115            print(f"❌ Script not found: {script_path}")
116            return 1
117 
118        # Ensure venv is set up
119        if not self.ensure_venv():
120            print("❌ Failed to set up environment")
121            return 1
122 
123        # Build command
124        cmd = [str(self.venv_python), str(script_path)]
125        if args:
126            cmd.extend(args)
127 
128        print(f"🚀 Running: {script_name} with venv Python")
129 
130        try:
131            # Run the script with venv Python
132            result = subprocess.run(cmd)
133            return result.returncode
134        except Exception as e:
135            print(f"❌ Failed to run script: {e}")
136            return 1
137 
138    def activate_instructions(self) -> str:
139        """Get instructions for manual activation"""
140        if os.name == 'nt':
141            activate = self.venv_dir / "Scripts" / "activate.bat"
142            return f"Run: {activate}"
143        else:
144            activate = self.venv_dir / "bin" / "activate"
145            return f"Run: source {activate}"
146 
147 
148def main():
149    """Main entry point for environment setup"""
150    import argparse
151 
152    parser = argparse.ArgumentParser(
153        description='Setup NotebookLM skill environment'
154    )
155 
156    parser.add_argument(
157        '--check',
158        action='store_true',
159        help='Check if environment is set up'
160    )
161 
162    parser.add_argument(
163        '--run',
164        help='Run a script with the venv (e.g., --run ask_question.py)'
165    )
166 
167    parser.add_argument(
168        'args',
169        nargs='*',
170        help='Arguments to pass to the script'
171    )
172 
173    args = parser.parse_args()
174 
175    env = SkillEnvironment()
176 
177    if args.check:
178        if env.venv_dir.exists():
179            print(f"✅ Virtual environment exists: {env.venv_dir}")
180            print(f"   Python: {env.get_python_executable()}")
181            print(f"   To activate manually: {env.activate_instructions()}")
182        else:
183            print(f"❌ No virtual environment found")
184            print(f"   Run setup_environment.py to create it")
185        return
186 
187    if args.run:
188        # Run a script with venv
189        return env.run_script(args.run, args.args)
190 
191    # Default: ensure environment is set up
192    if env.ensure_venv():
193        print("\n✅ Environment ready!")
194        print(f"   Virtual env: {env.venv_dir}")
195        print(f"   Python: {env.get_python_executable()}")
196        print(f"\nTo activate manually: {env.activate_instructions()}")
197        print(f"Or run scripts directly: python setup_environment.py --run script_name.py")
198    else:
199        print("\n❌ Environment setup failed")
200        return 1
201 
202 
203if __name__ == "__main__":
204    sys.exit(main() or 0)