URL

app.py

@@ -10,43 +10,88 @@ import gradio as gr
 from rag import build_vectorstore, retrieve_context
 from script_gen import generate_script
 from tts import script_to_audio
+from url_loader import scrape_urls
 
 GROQ_API_KEY   = os.environ.get("GROQ_API_KEY", "")
 GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
 
+WORDS_PER_MINUTE = 130  # average spoken English pace
 
-def run_pipeline(file, mode, topic_hint):
+
+def recommend_duration(word_count: int) -> float:
+    """Recommend audio duration based on source word count."""
+    # ~20% of source words end up in the final script (summarisation factor)
+    estimated_script_words = word_count * 0.20
+    minutes = estimated_script_words / WORDS_PER_MINUTE
+    # Round to nearest 0.5, clamp between 1 and 10
+    minutes = max(1.0, min(10.0, round(minutes * 2) / 2))
+    return minutes
+
+
+def run_pipeline(files, urls_text, mode, tone, duration, topic_hint):
     groq_key   = GROQ_API_KEY
     gemini_key = GEMINI_API_KEY
 
     if not groq_key and not gemini_key:
-        yield ("❌ No API keys found. Add GROQ_API_KEY or GEMINI_API_KEY in Space Settings → Secrets.", None, "")
+        yield "❌ No API keys found. Add GROQ_API_KEY or GEMINI_API_KEY in Space Settings → Secrets.", None, "", gr.update()
         return
 
-    if not file or (isinstance(file, list) and len(file) == 0):
-        yield "❌ Please upload at least one document (PDF, TXT, or DOCX).", None, ""
+    # Parse URLs — one per line
+    url_list = [u.strip() for u in (urls_text or "").splitlines() if u.strip()]
+
+    has_files = files and len(files) > 0
+    has_urls  = len(url_list) > 0
+
+    if not has_files and not has_urls:
+        yield "❌ Please upload at least one document or add a URL.", None, "", gr.update()
         return
 
     try:
-        n_files = len(file) if isinstance(file, list) else 1
-        yield f"📚 Reading {n_files} document(s) and building knowledge base...", None, ""
-        vectorstore, _ = build_vectorstore(file)
-
+        # ── Step 1: Scrape URLs ───────────────────────────────────────────────
+        url_texts = []
+        if has_urls:
+            yield f"🌐 Fetching {len(url_list)} URL(s)...", None, "", gr.update()
+            url_texts, url_errors = scrape_urls(url_list)
+            if url_errors and not url_texts and not has_files:
+                raise ValueError("All URLs failed:\n" + "\n".join(url_errors))
+            if url_errors:
+                print(f"[VoiceVerse] URL warnings: {url_errors}")
+
+        # ── Step 2: Build vectorstore ─────────────────────────────────────────
+        n_files = len(files) if has_files else 0
+        n_urls  = len(url_texts)
+        yield f"📚 Processing {n_files} file(s) and {n_urls} URL(s)...", None, "", gr.update()
+        vectorstore, _, word_count = build_vectorstore(
+            file_paths=files if has_files else None,
+            url_texts=url_texts if url_texts else None,
+        )
+
+        # Recommend duration based on actual source length
+        recommended = recommend_duration(word_count)
+        duration_update = gr.update(value=recommended)
+
+        # ── Step 3: Retrieve context ──────────────────────────────────────────
         query = topic_hint.strip() if topic_hint.strip() else f"main concepts key ideas themes {mode}"
-        yield f"🔍 Retrieving content for {mode} format...", None, ""
+        yield f"🔍 Retrieving content for {mode} format...", None, "", duration_update
         context = retrieve_context(vectorstore, query, k=8, mode=mode)
 
+        # ── Step 4: Generate script ───────────────────────────────────────────
         provider = "Groq (Llama 4)" if groq_key else "Gemini Flash"
-        yield f"✍️ Generating {mode} script using {provider}...", None, ""
+        yield f"✍️ Generating {tone.lower()} {mode} script (~{duration} min) using {provider}...", None, "", gr.update()
 
-        script = generate_script(context=context, mode=mode, groq_key=groq_key, gemini_key=gemini_key)
+        script = generate_script(
+            context=context, mode=mode,
+            groq_key=groq_key, gemini_key=gemini_key,
+            tone=tone, duration=duration,
+        )
 
         if not script.strip():
-            yield "❌ Script generation returned empty output. Please try again.", None, ""
+            yield "❌ Script generation returned empty output. Please try again.", None, "", gr.update()
             return
 
-        yield "🎙️ Script ready! Synthesizing audio, please wait...", None, script
+        yield "🎙️ Script ready! Synthesizing audio, please wait...", None, script, gr.update()
 
+        # ── Step 5: Synthesize audio ──────────────────────────────────────────
         out_dir    = tempfile.mkdtemp()
         unique_id  = uuid.uuid4().hex[:8]
         audio_path = os.path.join(out_dir, f"voiceverse_{unique_id}.mp3")
@@ -67,17 +112,17 @@ def run_pipeline(file, mode, topic_hint):
         while not tts_result["done"]:
             time.sleep(3)
             dots = (dots % 3) + 1
-            yield f"🎙️ Synthesizing audio{'.' * dots}", None, script
+            yield f"🎙️ Synthesizing audio{'.' * dots}", None, script, gr.update()
 
         if tts_result["error"]:
             raise ValueError(f"Audio synthesis failed: {tts_result['error']}")
 
-        yield "⏳ Loading audio player...", audio_path, script
+        yield "⏳ Loading audio player...", audio_path, script, gr.update()
 
     except ValueError as e:
-        yield f"❌ {str(e)}", None, ""
+        yield f"❌ {str(e)}", None, "", gr.update()
     except Exception as e:
-        yield f"❌ Unexpected error: {str(e)}", None, ""
+        yield f"❌ Unexpected error: {str(e)}", None, "", gr.update()
 
 
 CSS = """
@@ -98,6 +143,8 @@ MODE_CHOICES = [
     ("🎓 Lecture  — Professor explains your document", "lecture"),
 ]
 
+TONE_CHOICES = ["Professional", "Casual", "Dramatic", "Humorous", "Educational"]
+
 with gr.Blocks(title="VoiceVerse – Document to Audio AI") as demo:
 
     gr.HTML("""
@@ -110,14 +157,21 @@ with gr.Blocks(title="VoiceVerse – Document to Audio AI") as demo:
 
     with gr.Row(equal_height=False):
 
+        # ── LEFT: Inputs ──────────────────────────────────────────────────────
         with gr.Column(scale=1, min_width=320):
-            gr.Markdown("<p class='section-label'>Step 1 — Upload Documents</p>")
+
+            gr.Markdown("<p class='section-label'>Step 1 — Add Content</p>")
             file_input = gr.File(
-                label="PDF, TXT, or DOCX (select multiple if needed)",
+                label="Upload Documents (PDF, TXT, DOCX — select multiple)",
                 file_types=[".pdf", ".txt", ".docx", ".doc"],
                 file_count="multiple",
                 type="filepath",
             )
+            urls_input = gr.Textbox(
+                label="And / Or paste URLs (one per line)",
+                placeholder="https://example.com/article\nhttps://another.com/page",
+                lines=3,
+            )
 
             gr.Markdown("<p class='section-label'>Step 2 — Choose Format</p>")
             mode_select = gr.Radio(
@@ -126,7 +180,21 @@ with gr.Blocks(title="VoiceVerse – Document to Audio AI") as demo:
                 value="podcast",
             )
 
-            gr.Markdown("<p class='section-label'>Step 3 — Focus Topic (optional)</p>")
+            gr.Markdown("<p class='section-label'>Step 3 — Tone & Duration</p>")
+            tone_select = gr.Dropdown(
+                label="Tone",
+                choices=TONE_CHOICES,
+                value="Professional",
+            )
+            duration_slider = gr.Slider(
+                label="Duration (minutes) — auto-recommended after upload",
+                minimum=1,
+                maximum=10,
+                step=0.5,
+                value=2.0,
+            )
+
+            gr.Markdown("<p class='section-label'>Step 4 — Focus Topic (optional)</p>")
             topic_hint = gr.Textbox(
                 label="What should the content focus on?",
                 placeholder="e.g. 'key findings', 'chapter 2 concepts', or leave blank for full summary",
@@ -140,6 +208,7 @@ with gr.Blocks(title="VoiceVerse – Document to Audio AI") as demo:
                 elem_id="generate-btn",
             )
 
+        # ── RIGHT: Outputs ────────────────────────────────────────────────────
         with gr.Column(scale=1, min_width=320):
             gr.Markdown("<p class='section-label'>Output</p>")
 
@@ -165,31 +234,28 @@ with gr.Blocks(title="VoiceVerse – Document to Audio AI") as demo:
     with gr.Accordion("ℹ️ How VoiceVerse Works", open=False):
         gr.Markdown("""
         **Pipeline:**
-        1. **Document Ingestion** — File split into ~600 char chunks with 100 char overlap (paragraph → line → sentence → word)
-        2. **RAG Retrieval** — Chunks embedded with `sentence-transformers/all-MiniLM-L6-v2`, stored in FAISS. Each mode runs 3 targeted sub-queries → different chunks → different scripts from the same document.
-        3. **Script Generation** — Groq (Llama 4 Maverick) primary; Gemini 2.0 Flash automatic fallback.
-        4. **Neural TTS** — Microsoft Edge Neural voices with distinct voice + rate + pitch per speaker, stitched with natural pauses.
+        1. **Content Ingestion** — Upload PDFs/TXT/DOCX and/or paste URLs. URLs are scraped for clean text. All sources are merged into one knowledge base.
+        2. **RAG Retrieval** — Chunks embedded with `sentence-transformers/all-MiniLM-L6-v2`, stored in FAISS. Each mode runs 3 targeted sub-queries for diverse, non-overlapping chunks.
+        3. **Script Generation** — Groq (Llama 4 Maverick) primary; Gemini 2.0 Flash fallback. Tone and duration are injected into the prompt (~130 words/min).
+        4. **Neural TTS** — Microsoft Edge Neural voices with distinct voice + rate + pitch per speaker.
 
         **Voices:**
         | Format | Speaker | Voice |
         |---|---|---|
-        | Podcast | ALEX | en-US-AndrewNeural (US Male, warm) |
-        | Podcast | JAMIE | en-US-EmmaMultilingualNeural (US Female, natural) |
-        | Debate | PRO | en-US-AriaNeural (US Female, expressive) |
-        | Debate | CON | en-GB-RyanNeural (British Male, authoritative) |
-        | Storytelling | NARRATOR | en-US-EmmaMultilingualNeural (slightly slower) |
-        | Lecture | PROFESSOR | en-GB-RyanNeural (measured, academic) |
-
-        *⚠️ All voices are synthetic AI-generated audio.*
+        | Podcast | ALEX | en-US-AndrewNeural |
+        | Podcast | JAMIE | en-US-EmmaMultilingualNeural |
+        | Debate | PRO | en-US-AriaNeural |
+        | Debate | CON | en-GB-RyanNeural |
+        | Storytelling | NARRATOR | en-US-EmmaMultilingualNeural |
+        | Lecture | PROFESSOR | en-GB-RyanNeural |
         """)
 
     generate_btn.click(
         fn=run_pipeline,
-        inputs=[file_input, mode_select, topic_hint],
-        outputs=[status_box, audio_output, script_output],
+        inputs=[file_input, urls_input, mode_select, tone_select, duration_slider, topic_hint],
+        outputs=[status_box, audio_output, script_output, duration_slider],
     )
 
-    # Fires when audio_output gets a new value — meaning browser has loaded it
     audio_output.change(
         fn=lambda a: "✅ Done! Press play to listen." if a else "",
         inputs=[audio_output],

rag.py

@@ -91,44 +91,60 @@ def load_document(file_path: str):
     return docs
 
 
-def build_vectorstore(file_paths):
+def build_vectorstore(file_paths=None, url_texts=None):
     """
     Full RAG pipeline: load → chunk → embed → index.
-    Accepts a single file path (str) or a list of file paths.
-    All files are merged into one vectorstore so retrieval
-    works across the entire uploaded corpus.
-    Returns (vectorstore, text_preview_string).
-    """
-    # Normalise to list
-    if isinstance(file_paths, str):
-        file_paths = [file_paths]
 
-    # Filter out None entries (Gradio sometimes passes None)
-    file_paths = [f for f in file_paths if f]
+    Accepts:
+        file_paths: str or list of file paths (PDF, TXT, DOCX)
+        url_texts:  list of (url, text) tuples from url_loader.scrape_urls()
 
-    if not file_paths:
-        raise ValueError("No files provided. Please upload at least one document.")
+    All sources are merged into one vectorstore so retrieval
+    works across all documents and URLs simultaneously.
+    Returns (vectorstore, text_preview_string, word_count).
+    """
+    from langchain.schema import Document
 
     all_docs = []
     failed   = []
 
-    for fp in file_paths:
-        try:
-            docs = load_document(fp)
-            all_docs.extend(docs)
-        except Exception as e:
-            failed.append(f"{Path(fp).name}: {str(e)}")
+    # ── Load files ────────────────────────────────────────────────────────────
+    if file_paths:
+        if isinstance(file_paths, str):
+            file_paths = [file_paths]
+        file_paths = [f for f in file_paths if f]
+
+        for fp in file_paths:
+            try:
+                docs = load_document(fp)
+                all_docs.extend(docs)
+            except Exception as e:
+                failed.append(f"{Path(fp).name}: {str(e)}")
+
+    # ── Load URL content ──────────────────────────────────────────────────────
+    if url_texts:
+        for url, text in url_texts:
+            if text and text.strip():
+                all_docs.append(Document(
+                    page_content=text,
+                    metadata={"source": url}
+                ))
 
     if failed and not all_docs:
-        raise ValueError("All uploaded files failed to load:\n" + "\n".join(failed))
+        raise ValueError("All sources failed to load:\n" + "\n".join(failed))
+
+    if not all_docs:
+        raise ValueError(
+            "No content found. Please upload at least one document or add a URL."
+        )
 
     if failed:
-        print(f"[VoiceVerse RAG] Warning — some files failed: {failed}")
+        print(f"[VoiceVerse RAG] Warning — some sources failed: {failed}")
 
     full_text = " ".join([d.page_content for d in all_docs])
     if len(full_text.strip()) < 100:
         raise ValueError(
-            "Documents have very little extractable text. "
+            "Sources have very little extractable text. "
             "Please check that files are not empty or image-only."
         )
 
@@ -140,12 +156,13 @@ def build_vectorstore(file_paths):
     chunks = splitter.split_documents(all_docs)
 
     if len(chunks) == 0:
-        raise ValueError("Documents produced no chunks after splitting. They may be empty.")
+        raise ValueError("Sources produced no chunks after splitting.")
 
     vectorstore = FAISS.from_documents(chunks, get_embeddings())
 
-    preview = full_text[:300].strip()
-    return vectorstore, preview
+    word_count = len(full_text.split())
+    preview    = full_text[:300].strip()
+    return vectorstore, preview, word_count
 
 
 def retrieve_context(vectorstore, query: str, k: int = 8, mode: str = None) -> str:

script_gen.py

@@ -96,13 +96,29 @@ Rules:
 - All content must come from the source material""",
 }
 
+TONE_INSTRUCTIONS = {
+    "Professional": "Use formal, authoritative language. Be precise and clear. Avoid slang or casual expressions.",
+    "Casual":       "Use relaxed, conversational language. Feel free to use everyday expressions and a friendly tone.",
+    "Dramatic":     "Use expressive, emotive language. Build tension and emphasise key moments dramatically.",
+    "Humorous":     "Use wit, light humour, and playful language. Keep it fun and engaging without being silly.",
+    "Educational":  "Use clear, instructive language. Explain concepts patiently as if teaching someone new to the topic.",
+}
+
 USER_PROMPT_TEMPLATE = """Create a complete, production-ready {mode} script based STRICTLY on the source material below.
 
+Tone: {tone}
+Tone instruction: {tone_instruction}
+
+Duration target: Approximately {duration} minute(s) of spoken audio.
+Word count target: Aim for approximately {target_words} words total.
+(Spoken audio averages ~130 words per minute)
+
 Critical rules:
 - Do NOT add any facts, claims, or details not explicitly present in the source
 - Keep all content grounded and accurate to the source
 - Write in natural spoken English — this will be converted to audio
-- The script must be at least 400 words long
+- Match the tone instruction strictly throughout the entire script
+- Hit the word count target as closely as possible
 - Follow the format exactly as instructed (every line must have the correct speaker label)
 
 SOURCE MATERIAL:
@@ -113,7 +129,8 @@ Write the complete script now."""
 
 # ── Provider functions ────────────────────────────────────────────────────────
 
-def generate_with_groq(context: str, mode: str, api_key: str) -> str:
+def generate_with_groq(context: str, mode: str, api_key: str,
+                       tone: str = "Professional", duration: float = 2.0) -> str:
     """
     Generate script using Groq (Llama 4 Maverick).
     Free tier: 1,000 requests/day — no credit card needed.
@@ -121,6 +138,12 @@ def generate_with_groq(context: str, mode: str, api_key: str) -> str:
     """
     client = Groq(api_key=api_key)
 
+    target_words   = int(duration * 130)
+    tone_instruction = TONE_INSTRUCTIONS.get(tone, TONE_INSTRUCTIONS["Professional"])
+
+    # Scale max_tokens based on duration (avg ~1.5 tokens per word)
+    max_tokens = min(4096, max(1024, int(target_words * 1.6)))
+
     response = client.chat.completions.create(
         model="meta-llama/llama-4-maverick-17b-128e-instruct",
         messages=[
@@ -130,10 +153,14 @@ def generate_with_groq(context: str, mode: str, api_key: str) -> str:
             },
             {
                 "role": "user",
-                "content": USER_PROMPT_TEMPLATE.format(mode=mode, context=context),
+                "content": USER_PROMPT_TEMPLATE.format(
+                    mode=mode, context=context,
+                    tone=tone, tone_instruction=tone_instruction,
+                    duration=duration, target_words=target_words,
+                ),
             },
         ],
-        max_tokens=2048,
+        max_tokens=max_tokens,
         temperature=0.7,
     )
 
@@ -143,7 +170,8 @@ def generate_with_groq(context: str, mode: str, api_key: str) -> str:
     return result
 
 
-def generate_with_gemini(context: str, mode: str, api_key: str) -> str:
+def generate_with_gemini(context: str, mode: str, api_key: str,
+                         tone: str = "Professional", duration: float = 2.0) -> str:
     """
     Generate script using Google Gemini 2.0 Flash.
     Free tier: ~20 requests/day — no credit card needed.
@@ -152,14 +180,18 @@ def generate_with_gemini(context: str, mode: str, api_key: str) -> str:
     """
     client = genai.Client(api_key=api_key)
 
-    system = SYSTEM_PROMPTS.get(mode, SYSTEM_PROMPTS["podcast"])
-    full_prompt = f"{system}\n\n{USER_PROMPT_TEMPLATE.format(mode=mode, context=context)}"
+    target_words     = int(duration * 130)
+    tone_instruction = TONE_INSTRUCTIONS.get(tone, TONE_INSTRUCTIONS["Professional"])
+    max_tokens       = min(4096, max(1024, int(target_words * 1.6)))
+
+    system      = SYSTEM_PROMPTS.get(mode, SYSTEM_PROMPTS["podcast"])
+    full_prompt = f"{system}\n\n{USER_PROMPT_TEMPLATE.format(mode=mode, context=context, tone=tone, tone_instruction=tone_instruction, duration=duration, target_words=target_words)}"
 
     response = client.models.generate_content(
         model="gemini-2.0-flash",
         contents=full_prompt,
         config=genai_types.GenerateContentConfig(
-            max_output_tokens=2048,
+            max_output_tokens=max_tokens,
             temperature=0.7,
         ),
     )
@@ -177,6 +209,8 @@ def generate_script(
     mode: str,
     groq_key: str = "",
     gemini_key: str = "",
+    tone: str = "Professional",
+    duration: float = 2.0,
 ) -> str:
     """
     Generate a spoken-word script from retrieved document context.
@@ -190,6 +224,8 @@ def generate_script(
         mode:       One of 'podcast', 'debate', 'storytelling', 'lecture'
         groq_key:   Groq API key (primary)
         gemini_key: Google Gemini API key (fallback)
+        tone:       One of 'Professional', 'Casual', 'Dramatic', 'Humorous', 'Educational'
+        duration:   Target audio duration in minutes (e.g. 2.0 = ~260 words)
 
     Returns:
         Generated script as a string with speaker labels on every line
@@ -199,7 +235,7 @@ def generate_script(
     # ── Try Groq first ────────────────────────────────────────────────────────
     if groq_key.strip():
         try:
-            return generate_with_groq(context, mode, groq_key.strip())
+            return generate_with_groq(context, mode, groq_key.strip(), tone, duration)
         except Exception as e:
             errors.append(f"Groq error: {str(e)}")
             print(f"[VoiceVerse] Groq failed, trying Gemini. Reason: {e}")
@@ -207,7 +243,7 @@ def generate_script(
     # ── Fall back to Gemini ───────────────────────────────────────────────────
     if gemini_key.strip():
         try:
-            return generate_with_gemini(context, mode, gemini_key.strip())
+            return generate_with_gemini(context, mode, gemini_key.strip(), tone, duration)
         except Exception as e:
             errors.append(f"Gemini error: {str(e)}")
             print(f"[VoiceVerse] Gemini also failed. Reason: {e}")

url_loader.py

@@ -0,0 +1,102 @@
+# url_loader.py — Scrape web pages and return clean plain text
+# Uses requests + BeautifulSoup — free, no API key needed.
+
+import requests
+from bs4 import BeautifulSoup
+
+
+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"
+    )
+}
+
+TIMEOUT = 15  # seconds
+
+
+def scrape_url(url: str) -> str:
+    """
+    Fetch a URL and return clean plain text.
+    Strips nav, header, footer, scripts, and ads.
+    Raises ValueError with a user-friendly message on failure.
+    """
+    url = url.strip()
+    if not url:
+        raise ValueError("Empty URL provided.")
+
+    if not url.startswith(("http://", "https://")):
+        url = "https://" + url
+
+    try:
+        response = requests.get(url, headers=HEADERS, timeout=TIMEOUT)
+        response.raise_for_status()
+    except requests.exceptions.Timeout:
+        raise ValueError(f"Timed out trying to reach: {url}")
+    except requests.exceptions.ConnectionError:
+        raise ValueError(f"Could not connect to: {url}. Check the URL and try again.")
+    except requests.exceptions.HTTPError as e:
+        raise ValueError(f"HTTP error {e.response.status_code} for: {url}")
+    except Exception as e:
+        raise ValueError(f"Failed to fetch {url}: {str(e)}")
+
+    soup = BeautifulSoup(response.content, "html.parser")
+
+    # Remove noisy elements
+    for tag in soup(["script", "style", "nav", "header", "footer",
+                     "aside", "form", "noscript", "iframe", "ads",
+                     "advertisement", "cookie", "popup"]):
+        tag.decompose()
+
+    # Also remove by common class/id patterns for ads and nav
+    for tag in soup.find_all(True, {"class": [
+        "nav", "navbar", "menu", "sidebar", "footer", "header",
+        "advertisement", "ad", "cookie", "popup", "banner"
+    ]}):
+        tag.decompose()
+
+    # Get text from the body
+    body = soup.find("body") or soup
+    text = body.get_text(separator="\n")
+
+    # Clean up whitespace
+    lines = [line.strip() for line in text.splitlines()]
+    lines = [line for line in lines if len(line) > 30]  # drop short/empty lines
+    clean_text = "\n".join(lines)
+
+    if len(clean_text.strip()) < 100:
+        raise ValueError(
+            f"Could not extract meaningful text from: {url}\n"
+            "The page may require JavaScript, be paywalled, or block scrapers."
+        )
+
+    return clean_text
+
+
+def scrape_urls(urls: list) -> list:
+    """
+    Scrape multiple URLs. Returns list of (url, text) tuples for successes.
+    Collects errors without crashing — returns them separately.
+
+    Returns:
+        (results, errors)
+        results: list of (url, text) for successful scrapes
+        errors:  list of error strings for failed scrapes
+    """
+    results = []
+    errors  = []
+
+    for url in urls:
+        url = url.strip()
+        if not url:
+            continue
+        try:
+            text = scrape_url(url)
+            results.append((url, text))
+            print(f"[VoiceVerse URL] ✓ Scraped {url} ({len(text)} chars)")
+        except ValueError as e:
+            errors.append(str(e))
+            print(f"[VoiceVerse URL] ✗ Failed {url}: {e}")
+
+    return results, errors