Implementation Guide: Capture deposition proceedings and generate structured summaries with key admissions

# adjust for client's switch vendor

configure terminal
vlan 50
name DEPOSITION_CAPTURE
exit
interface range GigabitEthernet0/1-4
switchport mode access
switchport access vlan 50
no shutdown
exit

# Enable BitLocker via PowerShell (run as Administrator)
Enable-BitLocker -MountPoint "C:" -EncryptionMethod XtsAes256 -UsedSpaceOnly -RecoveryPasswordProtector

# Store BitLocker recovery key to Azure AD
BackupToAAD-BitLockerKeyProtector -MountPoint "C:" -KeyProtectorId (Get-BitLockerVolume -MountPoint "C:").KeyProtector[0].KeyProtectorId

# Disable unnecessary services
Set-Service -Name "WSearch" -StartupType Disabled  # Windows Search indexer not needed
Set-Service -Name "MapsBroker" -StartupType Disabled

# Configure Windows Firewall - allow only required outbound
New-NetFirewallRule -DisplayName "Allow Deepgram API" -Direction Outbound -RemoteAddress Any -RemotePort 443 -Protocol TCP -Action Allow
New-NetFirewallRule -DisplayName "Allow SMB to NAS" -Direction Outbound -RemoteAddress 10.10.50.0/24 -RemotePort 445 -Protocol TCP -Action Allow

# Set power plan to High Performance (prevent sleep during recording)
powercfg /setactive 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c

# Create local recording directory structure
New-Item -Path "C:\DepositionRecordings" -ItemType Directory
New-Item -Path "C:\DepositionRecordings\Pending" -ItemType Directory
New-Item -Path "C:\DepositionRecordings\Processed" -ItemType Directory
New-Item -Path "C:\DepositionRecordings\Archive" -ItemType Directory

Get-PnpDevice -Class AudioEndpoint | Where-Object {$_.FriendlyName -like '*Shure*'}

winget install OBSProject.OBSStudio

net use Z: \\<NAS-IP>\DepositionRecordings /user:depo-workstation-01 /persistent:yes

[System.Environment]::SetEnvironmentVariable('DEEPGRAM_API_KEY', 'your-api-key-here', 'Machine')

curl -X POST "https://api.deepgram.com/v1/listen?model=nova-3&smart_format=true&diarize=true&punctuate=true&paragraphs=true&utterances=true&language=en-US" -H "Authorization: Token $env:DEEPGRAM_API_KEY" -H "Content-Type: audio/wav" --data-binary @C:\DepositionRecordings\test_sample.wav -o C:\DepositionRecordings\test_transcript.json

winget install Python.Python.3.11

mkdir C:\DepositionPipeline
cd C:\DepositionPipeline
python -m venv venv
.\venv\Scripts\Activate.ps1

pip install deepgram-sdk anthropic requests watchdog python-docx schedule
pip install azure-storage-blob python-dotenv

DEEPGRAM_API_KEY=your_key
CASEMARK_API_KEY=your_key
ANTHROPIC_API_KEY=your_key
CLIO_API_TOKEN=your_token
AZURE_STORAGE_CONNECTION_STRING=your_connection
NAS_SHARE_PATH=\\nas-ip\DepositionRecordings

pip install pywin32
python deposition_service.py install
python deposition_service.py start

Get-Service DepositionPipeline

# open in browser to begin authorization flow

https://app.clio.com/oauth/authorize?response_type=code&client_id=YOUR_CLIENT_ID&redirect_uri=http://localhost:8080/callback&scope=documents:write%20matters:read%20contacts:read

curl -X POST https://app.clio.com/oauth/token -d "grant_type=authorization_code&code=AUTH_CODE&client_id=YOUR_CLIENT_ID&client_secret=YOUR_SECRET&redirect_uri=http://localhost:8080/callback"

# .env entries
CLIO_CLIENT_ID=your_id
CLIO_CLIENT_SECRET=your_secret
CLIO_REFRESH_TOKEN=your_refresh_token

curl -H "Authorization: Bearer ACCESS_TOKEN" https://app.clio.com/api/v4/matters.json?limit=5

$obs = Get-Process obs64 -ErrorAction SilentlyContinue
if (-not $obs) { Write-Output 'ALERT: OBS Studio not running on deposition workstation'; exit 1 }

$response = Invoke-WebRequest -Uri 'https://api.deepgram.com/v1/listen' -Method OPTIONS -TimeoutSec 10 -ErrorAction SilentlyContinue
if ($response.StatusCode -ne 200 -and $response.StatusCode -ne 405) { Write-Output 'ALERT: Deepgram API unreachable'; exit 1 }

$usage = (Get-PSDrive Z).Used / (Get-PSDrive Z).Free * 100
if ($usage -gt 80) { Write-Output "ALERT: NAS storage at $usage% capacity"; exit 1 }

$svc = Get-Service DepositionPipeline -ErrorAction SilentlyContinue
if ($svc.Status -ne 'Running') { Write-Output 'ALERT: Deposition Pipeline service stopped'; exit 1 }

$stale = Get-ChildItem C:\DepositionRecordings\Pending -File | Where-Object { $_.LastWriteTime -lt (Get-Date).AddHours(-4) }
if ($stale) { Write-Output "ALERT: $($stale.Count) files stuck in Pending queue"; exit 1 }

type C:\DepositionPipeline\logs\pipeline.log

# Core pipeline orchestrator for deposition processing

# deposition_pipeline.py
# Core pipeline orchestrator for deposition processing

import os
import sys
import json
import time
import logging
import shutil
from pathlib import Path
from datetime import datetime
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from dotenv import load_dotenv

load_dotenv('C:\\DepositionPipeline\\.env')

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler('C:\\DepositionPipeline\\logs\\pipeline.log'),
        logging.StreamHandler(sys.stdout)
    ]
)
logger = logging.getLogger('DepositionPipeline')

# Import sub-modules
from transcriber import DeepgramTranscriber
from summarizer import DepositionSummarizer
from pms_integration import ClioIntegration
from consent_manager import ConsentManager

# Configuration
WATCH_DIR = Path('C:/DepositionRecordings/Pending')
PROCESSED_DIR = Path('C:/DepositionRecordings/Processed')
ARCHIVE_DIR = Path('C:/DepositionRecordings/Archive')
NAS_PATH = Path(os.getenv('NAS_SHARE_PATH', 'Z:\\'))
STABILITY_WAIT = 30  # seconds to wait after file stops growing

class RecordingHandler(FileSystemEventHandler):
    """Watches for new recording files and triggers processing."""
    
    def __init__(self):
        self.transcriber = DeepgramTranscriber(api_key=os.getenv('DEEPGRAM_API_KEY'))
        self.summarizer = DepositionSummarizer(
            casemark_key=os.getenv('CASEMARK_API_KEY'),
            anthropic_key=os.getenv('ANTHROPIC_API_KEY')
        )
        self.clio = ClioIntegration(
            client_id=os.getenv('CLIO_CLIENT_ID'),
            client_secret=os.getenv('CLIO_CLIENT_SECRET'),
            refresh_token=os.getenv('CLIO_REFRESH_TOKEN')
        )
        self.processing = set()
    
    def on_created(self, event):
        if event.is_directory:
            return
        filepath = Path(event.src_path)
        if filepath.suffix.lower() in ['.mp4', '.mkv', '.wav', '.mp3', '.flac']:
            logger.info(f'New recording detected: {filepath.name}')
            self._wait_for_stable(filepath)
            if filepath.name not in self.processing:
                self.processing.add(filepath.name)
                try:
                    self._process_recording(filepath)
                except Exception as e:
                    logger.error(f'Pipeline error for {filepath.name}: {e}', exc_info=True)
                finally:
                    self.processing.discard(filepath.name)
    
    def _wait_for_stable(self, filepath, timeout=600):
        """Wait until file size stops changing (recording finished)."""
        logger.info(f'Waiting for {filepath.name} to stabilize...')
        prev_size = -1
        stable_count = 0
        elapsed = 0
        while elapsed < timeout:
            try:
                current_size = filepath.stat().st_size
            except FileNotFoundError:
                return
            if current_size == prev_size:
                stable_count += 1
                if stable_count >= 3:  # stable for 3 checks (30 sec)
                    logger.info(f'{filepath.name} is stable at {current_size / 1e6:.1f} MB')
                    return
            else:
                stable_count = 0
            prev_size = current_size
            time.sleep(10)
            elapsed += 10
        logger.warning(f'{filepath.name} did not stabilize within {timeout}s, processing anyway')
    
    def _process_recording(self, filepath):
        """Full pipeline: transcribe → summarize → file."""
        session_id = datetime.now().strftime('%Y%m%d_%H%M%S')
        logger.info(f'=== Processing {filepath.name} | Session: {session_id} ===')
        
        # Step 1: Transcribe with Deepgram
        logger.info('Step 1: Sending to Deepgram for transcription...')
        transcript_result = self.transcriber.transcribe(
            audio_path=str(filepath),
            options={
                'model': 'nova-3',
                'smart_format': True,
                'diarize': True,
                'punctuate': True,
                'paragraphs': True,
                'utterances': True,
                'language': 'en-US',
                'keywords': ['objection:2', 'stipulate:2', 'exhibit:2',
                             'deposition:2', 'counsel:2', 'testimony:2']
            }
        )
        
        # Step 2: Format transcript with speaker labels
        logger.info('Step 2: Formatting transcript with speaker labels...')
        formatted_transcript = self.transcriber.format_transcript(transcript_result)
        
        # Save raw transcript
        transcript_path = PROCESSED_DIR / f'{session_id}_transcript.json'
        with open(transcript_path, 'w') as f:
            json.dump(transcript_result, f, indent=2)
        
        formatted_path = PROCESSED_DIR / f'{session_id}_transcript.txt'
        with open(formatted_path, 'w') as f:
            f.write(formatted_transcript)
        
        logger.info(f'Transcript saved: {formatted_path}')
        
        # Step 3: Generate AI Summary
        logger.info('Step 3: Generating AI deposition summary...')
        summary = self.summarizer.generate_summary(
            transcript_text=formatted_transcript,
            session_id=session_id
        )
        
        summary_path = PROCESSED_DIR / f'{session_id}_summary.docx'
        self.summarizer.save_as_docx(summary, summary_path)
        logger.info(f'Summary saved: {summary_path}')
        
        # Step 4: Archive to NAS
        logger.info('Step 4: Archiving to NAS...')
        nas_session_dir = NAS_PATH / 'DepositionRecordings' / session_id
        nas_session_dir.mkdir(parents=True, exist_ok=True)
        shutil.copy2(filepath, nas_session_dir / filepath.name)
        shutil.copy2(formatted_path, NAS_PATH / 'Transcripts' / formatted_path.name)
        shutil.copy2(summary_path, NAS_PATH / 'AISummaries' / summary_path.name)
        logger.info('Files archived to NAS')
        
        # Step 5: Upload to Practice Management System
        logger.info('Step 5: Filing to Clio...')
        # Matter ID should be set in the session metadata file
        metadata_path = WATCH_DIR / f'{filepath.stem}_metadata.json'
        matter_id = None
        if metadata_path.exists():
            with open(metadata_path) as f:
                metadata = json.load(f)
                matter_id = metadata.get('clio_matter_id')
        
        if matter_id:
            self.clio.upload_document(
                matter_id=matter_id,
                file_path=str(summary_path),
                name=f'AI Deposition Summary - {session_id}',
                category='AI Deposition Summary'
            )
            self.clio.upload_document(
                matter_id=matter_id,
                file_path=str(formatted_path),
                name=f'AI Deposition Transcript - {session_id}',
                category='AI Deposition Transcript'
            )
            logger.info(f'Documents filed to Clio matter {matter_id}')
        else:
            logger.warning('No matter_id found in metadata — skipping Clio upload')
        
        # Step 6: Move original to archive
        archive_path = ARCHIVE_DIR / filepath.name
        shutil.move(str(filepath), str(archive_path))
        if metadata_path.exists():
            shutil.move(str(metadata_path), str(ARCHIVE_DIR / metadata_path.name))
        
        logger.info(f'=== Pipeline complete for {filepath.name} | Session: {session_id} ===')

def main():
    # Ensure directories exist
    for d in [WATCH_DIR, PROCESSED_DIR, ARCHIVE_DIR]:
        d.mkdir(parents=True, exist_ok=True)
    Path('C:/DepositionPipeline/logs').mkdir(parents=True, exist_ok=True)
    
    logger.info('Deposition Processing Pipeline starting...')
    logger.info(f'Watching directory: {WATCH_DIR}')
    
    handler = RecordingHandler()
    observer = Observer()
    observer.schedule(handler, str(WATCH_DIR), recursive=False)
    observer.start()
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()
    logger.info('Pipeline stopped.')

if __name__ == '__main__':
    main()

# Deepgram Nova-3 integration for deposition transcription

# transcriber.py
# Deepgram Nova-3 integration for deposition transcription

import json
import logging
import time
import math
from pathlib import Path
from deepgram import DeepgramClient, PrerecordedOptions, FileSource

logger = logging.getLogger('DepositionPipeline.Transcriber')

LINES_PER_PAGE = 25  # Standard legal transcript page format
CHARS_PER_LINE = 70  # Approximate characters per line

class DeepgramTranscriber:
    def __init__(self, api_key: str):
        self.client = DeepgramClient(api_key)
    
    def transcribe(self, audio_path: str, options: dict, max_retries: int = 3) -> dict:
        """Transcribe audio file using Deepgram Nova-3 with retry logic."""
        logger.info(f'Transcribing: {audio_path}')
        file_size = Path(audio_path).stat().st_size / 1e6
        logger.info(f'File size: {file_size:.1f} MB')
        
        with open(audio_path, 'rb') as audio_file:
            buffer_data = audio_file.read()
        
        payload: FileSource = {'buffer': buffer_data}
        
        dg_options = PrerecordedOptions(
            model=options.get('model', 'nova-3'),
            smart_format=options.get('smart_format', True),
            diarize=options.get('diarize', True),
            punctuate=options.get('punctuate', True),
            paragraphs=options.get('paragraphs', True),
            utterances=options.get('utterances', True),
            language=options.get('language', 'en-US'),
            keywords=options.get('keywords', [])
        )
        
        for attempt in range(max_retries):
            try:
                response = self.client.listen.rest.v('1').transcribe_file(
                    payload, dg_options
                )
                result = response.to_dict() if hasattr(response, 'to_dict') else json.loads(str(response))
                logger.info(f'Transcription complete. Words: {self._count_words(result)}')
                return result
            except Exception as e:
                logger.warning(f'Transcription attempt {attempt+1} failed: {e}')
                if attempt < max_retries - 1:
                    wait_time = 2 ** attempt * 5
                    logger.info(f'Retrying in {wait_time}s...')
                    time.sleep(wait_time)
                else:
                    logger.error('All transcription attempts failed')
                    raise
    
    def _count_words(self, result: dict) -> int:
        try:
            return len(result['results']['channels'][0]['alternatives'][0]['words'])
        except (KeyError, IndexError):
            return 0
    
    def format_transcript(self, result: dict) -> str:
        """Format Deepgram output into legal transcript format with page:line numbering."""
        utterances = result.get('results', {}).get('utterances', [])
        if not utterances:
            # Fallback to paragraphs if utterances not available
            return self._format_from_paragraphs(result)
        
        # Build speaker map
        speaker_map = {}
        speaker_counter = 1
        for utt in utterances:
            speaker_id = utt.get('speaker', 0)
            if speaker_id not in speaker_map:
                speaker_map[speaker_id] = f'SPEAKER {speaker_counter}'
                speaker_counter += 1
        
        # Format with page:line numbers
        lines = []
        current_line = 1
        current_page = 1
        
        # Header
        lines.append(f'PAGE {current_page}')
        lines.append('=' * 70)
        lines.append('')
        current_line = 1
        
        for utt in utterances:
            speaker = speaker_map.get(utt.get('speaker', 0), 'UNKNOWN')
            text = utt.get('transcript', '').strip()
            timestamp = utt.get('start', 0)
            
            # Format timestamp
            mins = int(timestamp // 60)
            secs = int(timestamp % 60)
            ts_str = f'[{mins:02d}:{secs:02d}]'
            
            # Speaker line
            speaker_line = f'{current_page}:{current_line:02d}  {ts_str}  {speaker}:'
            lines.append(speaker_line)
            current_line += 1
            
            # Wrap text to ~70 chars per line
            words = text.split()
            current_text_line = ''
            for word in words:
                if len(current_text_line) + len(word) + 1 > CHARS_PER_LINE:
                    lines.append(f'{current_page}:{current_line:02d}          {current_text_line}')
                    current_line += 1
                    current_text_line = word
                else:
                    current_text_line = f'{current_text_line} {word}'.strip()
                
                # Page break
                if current_line > LINES_PER_PAGE:
                    current_page += 1
                    current_line = 1
                    lines.append('')
                    lines.append(f'PAGE {current_page}')
                    lines.append('=' * 70)
                    lines.append('')
            
            if current_text_line:
                lines.append(f'{current_page}:{current_line:02d}          {current_text_line}')
                current_line += 1
            
            lines.append('')  # Blank line between utterances
            current_line += 1
            
            if current_line > LINES_PER_PAGE:
                current_page += 1
                current_line = 1
                lines.append(f'PAGE {current_page}')
                lines.append('=' * 70)
                lines.append('')
        
        # Footer
        lines.append('')
        lines.append(f'--- END OF TRANSCRIPT ---')
        lines.append(f'Total Pages: {current_page}')
        lines.append(f'Speaker Map: {json.dumps(speaker_map)}')
        lines.append(f'Note: Speaker identities should be verified by reviewing attorney.')
        lines.append(f'      This is an AI-generated transcript, not a certified court reporter transcript.')
        
        return '\n'.join(lines)
    
    def _format_from_paragraphs(self, result: dict) -> str:
        """Fallback formatting from paragraph-level results."""
        try:
            paragraphs = result['results']['channels'][0]['alternatives'][0]['paragraphs']['paragraphs']
            lines = []
            page = 1
            line = 1
            for para in paragraphs:
                speaker = para.get('speaker', 0)
                for sent in para.get('sentences', []):
                    text = sent.get('text', '')
                    lines.append(f'{page}:{line:02d}  SPEAKER {speaker + 1}: {text}')
                    line += 1
                    if line > LINES_PER_PAGE:
                        page += 1
                        line = 1
                lines.append('')
                line += 1
            return '\n'.join(lines)
        except (KeyError, IndexError) as e:
            logger.error(f'Failed to format transcript: {e}')
            # Last resort: return raw text
            return result.get('results', {}).get('channels', [{}])[0].get('alternatives', [{}])[0].get('transcript', 'TRANSCRIPTION ERROR')

# Deposition summary generation using CaseMark and Claude

# summarizer.py
# Deposition summary generation using CaseMark and Claude

import json
import logging
import requests
from pathlib import Path
from datetime import datetime
from docx import Document
from docx.shared import Pt, Inches
from docx.enum.text import WD_ALIGN_PARAGRAPH

logger = logging.getLogger('DepositionPipeline.Summarizer')

# Claude prompt template for deposition summarization
DEPOSITION_SUMMARY_PROMPT = """You are a senior litigation paralegal with 20 years of experience summarizing depositions. You are analyzing a deposition transcript that was generated by AI speech-to-text (with possible minor transcription errors). Your task is to produce a comprehensive, structured deposition summary.

IMPORTANT RULES:
1. Every factual assertion must include a page:line citation in the format (Page:Line)
2. Use exact quotes for key admissions — surround with quotation marks
3. Flag any statements that contradict other testimony, prior pleadings, or documentary evidence
4. Note any objections made and whether they were sustained
5. Identify all exhibits referenced and what they were used for
6. Flag credibility issues: evasive answers, memory failures, contradictions
7. Do NOT fabricate citations — if you cannot identify the exact page:line, use [approximate location]

Produce the summary in the following sections:

## 1. DEPOSITION OVERVIEW
- Deponent name (as identified in transcript)
- Date of deposition
- Duration (approximate from timestamps)
- Attorneys present (as identified)
- Key topics covered

## 2. KEY ADMISSIONS
List each significant admission by the deponent, with:
- The exact quote
- Page:line citation
- Why this admission is significant for the case
- Suggested follow-up or impeachment use

## 3. CONTRADICTIONS & IMPEACHMENT MATERIAL
List any statements that:
- Contradict other statements within this deposition
- Appear to contradict common knowledge or documentary evidence
- Show evasiveness or memory issues
Include page:line citations for each.

## 4. CHRONOLOGICAL TIMELINE
Extract all dates, times, and events mentioned, in chronological order:
| Date/Time | Event | Speaker | Citation |

## 5. EXHIBIT REFERENCES
List all exhibits mentioned:
| Exhibit # | Description | How Used | Citation |

## 6. OBJECTIONS LOG
List all objections:
| Objection | Basis | Ruling | Citation |

## 7. CREDIBILITY ASSESSMENT NOTES
- Overall cooperation level
- Areas of evasiveness
- Memory/recall issues
- Demeanor notes (if discernible from transcript)

## 8. RECOMMENDED FOLLOW-UP
- Areas requiring further discovery
- Suggested interrogatories or document requests
- Potential motion topics (e.g., motion to compel if witness refused to answer)

---

Here is the deposition transcript:

{transcript}

---

Produce the structured summary now. Be thorough and cite every assertion."""


class DepositionSummarizer:
    def __init__(self, casemark_key: str = None, anthropic_key: str = None):
        self.casemark_key = casemark_key
        self.anthropic_key = anthropic_key
    
    def generate_summary(self, transcript_text: str, session_id: str) -> str:
        """Generate summary using CaseMark (primary) or Claude (fallback)."""
        # Try CaseMark first
        if self.casemark_key:
            try:
                logger.info('Attempting summary via CaseMark API...')
                return self._summarize_casemark(transcript_text, session_id)
            except Exception as e:
                logger.warning(f'CaseMark failed, falling back to Claude: {e}')
        
        # Fallback to Claude
        if self.anthropic_key:
            logger.info('Generating summary via Claude API...')
            return self._summarize_claude(transcript_text)
        
        raise RuntimeError('No summarization API available (both CaseMark and Claude failed/unconfigured)')
    
    def _summarize_casemark(self, transcript_text: str, session_id: str) -> str:
        """Submit transcript to CaseMark API for summarization."""
        # CaseMark API endpoint (verify current endpoint with CaseMark docs)
        url = 'https://api.casemark.ai/v1/summaries'
        headers = {
            'Authorization': f'Bearer {self.casemark_key}',
            'Content-Type': 'application/json'
        }
        payload = {
            'document_type': 'deposition_transcript',
            'content': transcript_text,
            'template': 'deposition_summary',
            'options': {
                'include_key_admissions': True,
                'include_contradictions': True,
                'include_chronology': True,
                'include_exhibit_references': True,
                'include_credibility_notes': True,
                'citation_format': 'page_line'
            },
            'reference_id': session_id
        }
        
        response = requests.post(url, json=payload, headers=headers, timeout=300)
        response.raise_for_status()
        
        result = response.json()
        summary_text = result.get('summary', '')
        
        if not summary_text:
            # CaseMark may use async processing — poll for result
            job_id = result.get('job_id')
            if job_id:
                summary_text = self._poll_casemark(job_id)
        
        logger.info(f'CaseMark summary generated: {len(summary_text)} chars')
        return summary_text
    
    def _poll_casemark(self, job_id: str, timeout: int = 600, interval: int = 10) -> str:
        """Poll CaseMark for async job completion."""
        import time
        url = f'https://api.casemark.ai/v1/summaries/{job_id}'
        headers = {'Authorization': f'Bearer {self.casemark_key}'}
        
        elapsed = 0
        while elapsed < timeout:
            response = requests.get(url, headers=headers, timeout=30)
            response.raise_for_status()
            result = response.json()
            
            if result.get('status') == 'completed':
                return result.get('summary', '')
            elif result.get('status') == 'failed':
                raise RuntimeError(f'CaseMark job failed: {result.get("error")}')
            
            time.sleep(interval)
            elapsed += interval
        
        raise TimeoutError(f'CaseMark job {job_id} timed out after {timeout}s')
    
    def _summarize_claude(self, transcript_text: str) -> str:
        """Generate summary using Anthropic Claude API."""
        import anthropic
        
        client = anthropic.Anthropic(api_key=self.anthropic_key)
        
        # Truncate very long transcripts to fit context window
        # Claude claude-sonnet-4-20250514 supports 200K tokens (~150K words)
        max_chars = 500000  # ~125K words, safe for Sonnet
        if len(transcript_text) > max_chars:
            logger.warning(f'Transcript truncated from {len(transcript_text)} to {max_chars} chars')
            transcript_text = transcript_text[:max_chars] + '\n\n[TRANSCRIPT TRUNCATED DUE TO LENGTH]'
        
        prompt = DEPOSITION_SUMMARY_PROMPT.format(transcript=transcript_text)
        
        message = client.messages.create(
            model='claude-sonnet-4-20250514',
            max_tokens=8192,
            messages=[
                {'role': 'user', 'content': prompt}
            ]
        )
        
        summary = message.content[0].text
        logger.info(f'Claude summary generated: {len(summary)} chars, {message.usage.input_tokens} input tokens, {message.usage.output_tokens} output tokens')
        return summary
    
    def save_as_docx(self, summary_text: str, output_path: Path):
        """Save summary as a formatted Word document."""
        doc = Document()
        
        # Title
        title = doc.add_heading('AI DEPOSITION SUMMARY', level=0)
        title.alignment = WD_ALIGN_PARAGRAPH.CENTER
        
        # Metadata
        doc.add_paragraph(f'Generated: {datetime.now().strftime("%B %d, %Y at %I:%M %p")}')
        doc.add_paragraph('CONFIDENTIAL — ATTORNEY WORK PRODUCT')
        doc.add_paragraph('')
        
        # Disclaimer
        disclaimer = doc.add_paragraph()
        disclaimer.style = doc.styles['Intense Quote']
        disclaimer.add_run(
            'NOTICE: This summary was generated by artificial intelligence and has not been '
            'verified by a human reviewer. Speaker identifications are based on AI voice '
            'diarization and may contain errors. Page:line citations reference the AI-generated '
            'transcript, not the certified court reporter transcript. This document is attorney '
            'work product and should be reviewed for accuracy before reliance.'
        )
        
        # Parse and format summary sections
        lines = summary_text.split('\n')
        for line in lines:
            line = line.rstrip()
            if line.startswith('## '):
                doc.add_heading(line[3:], level=2)
            elif line.startswith('### '):
                doc.add_heading(line[4:], level=3)
            elif line.startswith('| ') and '|' in line[1:]:
                # Simple table row — add as formatted paragraph
                p = doc.add_paragraph(line, style='List Bullet')
                p.paragraph_format.space_after = Pt(2)
            elif line.startswith('- '):
                doc.add_paragraph(line[2:], style='List Bullet')
            elif line.startswith('  - '):
                doc.add_paragraph(line[4:], style='List Bullet 2')
            elif line.strip():
                doc.add_paragraph(line)
        
        # Footer
        doc.add_paragraph('')
        footer = doc.add_paragraph('--- END OF AI SUMMARY ---')
        footer.alignment = WD_ALIGN_PARAGRAPH.CENTER
        
        doc.save(str(output_path))
        logger.info(f'DOCX saved: {output_path}')

# Clio Manage API integration for document filing

# pms_integration.py
# Clio Manage API integration for document filing

import json
import logging
import requests
from pathlib import Path
from datetime import datetime, timedelta

logger = logging.getLogger('DepositionPipeline.ClioIntegration')

CLIO_BASE_URL = 'https://app.clio.com/api/v4'
CLIO_TOKEN_URL = 'https://app.clio.com/oauth/token'


class ClioIntegration:
    def __init__(self, client_id: str, client_secret: str, refresh_token: str):
        self.client_id = client_id
        self.client_secret = client_secret
        self.refresh_token = refresh_token
        self.access_token = None
        self.token_expiry = datetime.min
    
    def _ensure_token(self):
        """Refresh access token if expired or missing."""
        if self.access_token and datetime.now() < self.token_expiry:
            return
        
        logger.info('Refreshing Clio access token...')
        response = requests.post(CLIO_TOKEN_URL, data={
            'grant_type': 'refresh_token',
            'refresh_token': self.refresh_token,
            'client_id': self.client_id,
            'client_secret': self.client_secret
        })
        response.raise_for_status()
        
        token_data = response.json()
        self.access_token = token_data['access_token']
        self.refresh_token = token_data.get('refresh_token', self.refresh_token)
        # Clio tokens expire in ~24 hours; refresh 1 hour early
        self.token_expiry = datetime.now() + timedelta(hours=23)
        logger.info('Clio token refreshed successfully')
        
        # Persist updated refresh token
        self._save_refresh_token()
    
    def _save_refresh_token(self):
        """Persist refresh token to .env file for service restarts."""
        env_path = Path('C:/DepositionPipeline/.env')
        if env_path.exists():
            lines = env_path.read_text().splitlines()
            new_lines = []
            found = False
            for line in lines:
                if line.startswith('CLIO_REFRESH_TOKEN='):
                    new_lines.append(f'CLIO_REFRESH_TOKEN={self.refresh_token}')
                    found = True
                else:
                    new_lines.append(line)
            if not found:
                new_lines.append(f'CLIO_REFRESH_TOKEN={self.refresh_token}')
            env_path.write_text('\n'.join(new_lines))
    
    def _headers(self):
        self._ensure_token()
        return {
            'Authorization': f'Bearer {self.access_token}',
            'Content-Type': 'application/json'
        }
    
    def get_matter(self, matter_id: int) -> dict:
        """Retrieve matter details from Clio."""
        response = requests.get(
            f'{CLIO_BASE_URL}/matters/{matter_id}.json',
            headers=self._headers(),
            params={'fields': 'id,display_number,description,client'}
        )
        response.raise_for_status()
        return response.json()['data']
    
    def search_matters(self, query: str) -> list:
        """Search for matters by name or number."""
        response = requests.get(
            f'{CLIO_BASE_URL}/matters.json',
            headers=self._headers(),
            params={'query': query, 'fields': 'id,display_number,description', 'limit': 10}
        )
        response.raise_for_status()
        return response.json()['data']
    
    def upload_document(self, matter_id: int, file_path: str, name: str, category: str = None):
        """Upload a document to a Clio matter."""
        self._ensure_token()
        file_path = Path(file_path)
        
        if not file_path.exists():
            raise FileNotFoundError(f'Document not found: {file_path}')
        
        # Step 1: Create the document record
        doc_data = {
            'data': {
                'name': name,
                'parent': {'id': matter_id, 'type': 'Matter'},
            }
        }
        
        response = requests.post(
            f'{CLIO_BASE_URL}/documents.json',
            headers=self._headers(),
            json=doc_data
        )
        response.raise_for_status()
        doc_id = response.json()['data']['id']
        logger.info(f'Created Clio document record: {doc_id}')
        
        # Step 2: Upload the file content
        # Get the upload URL
        upload_headers = {
            'Authorization': f'Bearer {self.access_token}'
        }
        
        # Determine content type
        content_types = {
            '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
            '.txt': 'text/plain',
            '.pdf': 'application/pdf',
            '.json': 'application/json',
            '.mp4': 'video/mp4',
            '.wav': 'audio/wav'
        }
        content_type = content_types.get(file_path.suffix.lower(), 'application/octet-stream')
        
        with open(file_path, 'rb') as f:
            files = {'file': (file_path.name, f, content_type)}
            put_data = {'data': json.dumps({'uuid': None})}
            response = requests.put(
                f'{CLIO_BASE_URL}/documents/{doc_id}.json',
                headers=upload_headers,
                files=files,
                data=put_data
            )
        response.raise_for_status()
        
        logger.info(f'Uploaded {file_path.name} to Clio document {doc_id} in matter {matter_id}')
        return doc_id

# Tkinter-based GUI for deposition session management. Runs on the recording
# workstation; controls OBS via WebSocket.

# session_manager.py
# Tkinter-based GUI for deposition session management
# Runs on the recording workstation; controls OBS via WebSocket

import tkinter as tk
from tkinter import ttk, messagebox
import json
import os
import logging
import threading
from pathlib import Path
from datetime import datetime
import websocket
import hashlib
import base64

logger = logging.getLogger('DepositionSessionManager')

OBS_WS_HOST = 'localhost'
OBS_WS_PORT = 4455
OBS_WS_PASSWORD = os.getenv('OBS_WS_PASSWORD', 'change-me-in-production')
METADATA_DIR = Path('C:/DepositionRecordings/Pending')


class OBSController:
    """Controls OBS Studio via obs-websocket protocol."""
    
    def __init__(self, host, port, password):
        self.url = f'ws://{host}:{port}'
        self.password = password
        self.ws = None
        self.msg_id = 0
    
    def connect(self):
        self.ws = websocket.create_connection(self.url)
        # Handle authentication (obs-websocket v5 protocol)
        hello = json.loads(self.ws.recv())
        if hello.get('d', {}).get('authentication'):
            auth = hello['d']['authentication']
            challenge = auth['challenge']
            salt = auth['salt']
            # Generate auth string
            secret = base64.b64encode(
                hashlib.sha256((self.password + salt).encode()).digest()
            ).decode()
            auth_str = base64.b64encode(
                hashlib.sha256((secret + challenge).encode()).digest()
            ).decode()
            
            identify = {
                'op': 1,
                'd': {
                    'rpcVersion': 1,
                    'authentication': auth_str
                }
            }
            self.ws.send(json.dumps(identify))
            resp = json.loads(self.ws.recv())
    
    def send_request(self, request_type, request_data=None):
        self.msg_id += 1
        msg = {
            'op': 6,
            'd': {
                'requestType': request_type,
                'requestId': str(self.msg_id),
                'requestData': request_data or {}
            }
        }
        self.ws.send(json.dumps(msg))
        return json.loads(self.ws.recv())
    
    def start_recording(self):
        return self.send_request('StartRecord')
    
    def stop_recording(self):
        return self.send_request('StopRecord')
    
    def get_record_status(self):
        return self.send_request('GetRecordStatus')


class DepositionSessionGUI:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title('Deposition Capture Manager')
        self.root.geometry('600x800')
        self.root.configure(bg='#1a1a2e')
        
        self.obs = OBSController(OBS_WS_HOST, OBS_WS_PORT, OBS_WS_PASSWORD)
        self.is_recording = False
        self.session_start = None
        
        self._build_ui()
        self._connect_obs()
    
    def _build_ui(self):
        style = ttk.Style()
        style.configure('Title.TLabel', font=('Segoe UI', 16, 'bold'))
        style.configure('Status.TLabel', font=('Segoe UI', 12))
        
        # Header
        header = ttk.Frame(self.root, padding=10)
        header.pack(fill='x')
        ttk.Label(header, text='DEPOSITION CAPTURE SYSTEM', style='Title.TLabel').pack()
        
        # Case Info Frame
        info_frame = ttk.LabelFrame(self.root, text='Case Information', padding=10)
        info_frame.pack(fill='x', padx=10, pady=5)
        
        ttk.Label(info_frame, text='Clio Matter ID:').grid(row=0, column=0, sticky='e', padx=5)
        self.matter_id_var = tk.StringVar()
        ttk.Entry(info_frame, textvariable=self.matter_id_var, width=30).grid(row=0, column=1)
        
        ttk.Label(info_frame, text='Case Caption:').grid(row=1, column=0, sticky='e', padx=5)
        self.case_caption_var = tk.StringVar()
        ttk.Entry(info_frame, textvariable=self.case_caption_var, width=30).grid(row=1, column=1)
        
        ttk.Label(info_frame, text='Deponent Name:').grid(row=2, column=0, sticky='e', padx=5)
        self.deponent_var = tk.StringVar()
        ttk.Entry(info_frame, textvariable=self.deponent_var, width=30).grid(row=2, column=1)
        
        ttk.Label(info_frame, text='Noticing Attorney:').grid(row=3, column=0, sticky='e', padx=5)
        self.attorney_var = tk.StringVar()
        ttk.Entry(info_frame, textvariable=self.attorney_var, width=30).grid(row=3, column=1)
        
        # Consent Checklist
        consent_frame = ttk.LabelFrame(self.root, text='Pre-Recording Consent Checklist', padding=10)
        consent_frame.pack(fill='x', padx=10, pady=5)
        
        self.consent_vars = []
        checklist_items = [
            'Deposition notice specifies recording method per FRCP 30(b)(3)',
            'All parties informed of AI recording and transcription on the record',
            'Written consent form signed (or objections noted on record)',
            'Court reporter present (if required by jurisdiction)',
            'Audio levels verified — all microphones showing signal',
            'Backup microphone (EPOS Capture 5) verified',
            'UPS battery status confirmed (>50%)',
            'Sufficient storage space available on workstation and NAS'
        ]
        
        for i, item in enumerate(checklist_items):
            var = tk.BooleanVar()
            self.consent_vars.append(var)
            cb = ttk.Checkbutton(consent_frame, text=item, variable=var,
                                command=self._check_ready)
            cb.grid(row=i, column=0, sticky='w', pady=2)
        
        # Recording Controls
        control_frame = ttk.Frame(self.root, padding=10)
        control_frame.pack(fill='x', padx=10)
        
        self.start_btn = ttk.Button(control_frame, text='▶ START RECORDING',
                                     command=self._start_recording, state='disabled')
        self.start_btn.pack(side='left', padx=5)
        
        self.stop_btn = ttk.Button(control_frame, text='⏹ STOP RECORDING',
                                    command=self._stop_recording, state='disabled')
        self.stop_btn.pack(side='left', padx=5)
        
        # Status Display
        status_frame = ttk.LabelFrame(self.root, text='Recording Status', padding=10)
        status_frame.pack(fill='x', padx=10, pady=5)
        
        self.status_label = ttk.Label(status_frame, text='NOT RECORDING',
                                       style='Status.TLabel', foreground='gray')
        self.status_label.pack()
        
        self.timer_label = ttk.Label(status_frame, text='00:00:00',
                                      font=('Consolas', 24))
        self.timer_label.pack()
        
        self.obs_status = ttk.Label(status_frame, text='OBS: Connecting...',
                                     foreground='orange')
        self.obs_status.pack()
    
    def _connect_obs(self):
        try:
            self.obs.connect()
            self.obs_status.configure(text='OBS: Connected ✓', foreground='green')
        except Exception as e:
            self.obs_status.configure(text=f'OBS: Connection Failed ✗', foreground='red')
            logger.error(f'OBS connection failed: {e}')
    
    def _check_ready(self):
        all_checked = all(var.get() for var in self.consent_vars)
        has_info = bool(self.matter_id_var.get() and self.deponent_var.get())
        if all_checked and has_info and not self.is_recording:
            self.start_btn.configure(state='normal')
        else:
            self.start_btn.configure(state='disabled')
    
    def _start_recording(self):
        try:
            # Save session metadata
            session_id = datetime.now().strftime('%Y-%m-%d_Deposition_%H-%M-%S')
            metadata = {
                'session_id': session_id,
                'clio_matter_id': self.matter_id_var.get(),
                'case_caption': self.case_caption_var.get(),
                'deponent': self.deponent_var.get(),
                'noticing_attorney': self.attorney_var.get(),
                'start_time': datetime.now().isoformat(),
                'consent_checklist_completed': True
            }
            
            metadata_path = METADATA_DIR / f'{session_id}_metadata.json'
            with open(metadata_path, 'w') as f:
                json.dump(metadata, f, indent=2)
            
            self.obs.start_recording()
            self.is_recording = True
            self.session_start = datetime.now()
            self.status_label.configure(text='● RECORDING', foreground='red')
            self.start_btn.configure(state='disabled')
            self.stop_btn.configure(state='normal')
            self._update_timer()
            logger.info(f'Recording started: {session_id}')
        except Exception as e:
            messagebox.showerror('Recording Error', f'Failed to start recording: {e}')
    
    def _stop_recording(self):
        if messagebox.askyesno('Stop Recording', 'Are you sure you want to stop recording?'):
            try:
                self.obs.stop_recording()
                self.is_recording = False
                self.status_label.configure(text='RECORDING STOPPED — Processing...', foreground='blue')
                self.stop_btn.configure(state='disabled')
                logger.info('Recording stopped')
            except Exception as e:
                messagebox.showerror('Error', f'Failed to stop recording: {e}')
    
    def _update_timer(self):
        if self.is_recording and self.session_start:
            elapsed = datetime.now() - self.session_start
            hours, remainder = divmod(int(elapsed.total_seconds()), 3600)
            minutes, seconds = divmod(remainder, 60)
            self.timer_label.configure(text=f'{hours:02d}:{minutes:02d}:{seconds:02d}')
            self.root.after(1000, self._update_timer)
    
    def run(self):
        self.root.mainloop()


if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    app = DepositionSessionGUI()
    app.run()

{
  "speaker_map": {
    "0": {"name": "identified name or role", "role": "questioning_attorney|defending_attorney|deponent|court_reporter|unknown", "confidence": 0.0-1.0},
    "1": {"name": "...", "role": "...", "confidence": 0.0-1.0}
  },
  "reasoning": "Brief explanation of how you determined each mapping"
}

# maps Deepgram speaker IDs to named participants

# speaker_identifier.py
import json
import anthropic

def identify_speakers(transcript_result: dict, metadata: dict, api_key: str) -> dict:
    """Map generic speaker IDs to actual names/roles."""
    
    utterances = transcript_result.get('results', {}).get('utterances', [])
    first_50 = utterances[:50]
    
    utterance_text = '\n'.join([
        f"Speaker {u['speaker']}: {u['transcript']}"
        for u in first_50
    ])
    
    prompt = f"""You are analyzing a deposition transcript with AI-generated speaker labels.

Deposition Metadata:
- Case Caption: {metadata.get('case_caption', 'Unknown')}
- Deponent: {metadata.get('deponent', 'Unknown')}
- Noticing Attorney: {metadata.get('noticing_attorney', 'Unknown')}

Deposition conventions: The questioning attorney typically speaks first after the court reporter,
asking the deponent to state their name. The deponent gives short answers early. The defending
attorney interjects with objections.

First 50 utterances:
{utterance_text}

Map each speaker number to a name and role. Respond in JSON:
{{
  "speaker_map": {{
    "0": {{"name": "...", "role": "questioning_attorney|defending_attorney|deponent|court_reporter|unknown", "confidence": 0.0-1.0}}
  }},
  "reasoning": "..."
}}"""
    
    client = anthropic.Anthropic(api_key=api_key)
    response = client.messages.create(
        model='claude-sonnet-4-20250514',
        max_tokens=1024,
        messages=[{'role': 'user', 'content': prompt}]
    )
    
    result = json.loads(response.content[0].text)
    return result


def apply_speaker_names(transcript_text: str, speaker_map: dict) -> str:
    """Replace generic SPEAKER N labels with identified names."""
    for speaker_id, info in speaker_map.get('speaker_map', {}).items():
        old_label = f'SPEAKER {int(speaker_id) + 1}'
        name = info.get('name', old_label)
        role = info.get('role', 'unknown')
        confidence = info.get('confidence', 0)
        
        if confidence >= 0.7:
            new_label = f'{name} ({role.replace("_", " ").title()})'
        else:
            new_label = f'{old_label} [possibly {name}]'
        
        transcript_text = transcript_text.replace(old_label, new_label)
    
    return transcript_text