chATLAS_Frontend 1.0.0__py3-none-any.whl

chATLAS_Frontend/frontend/auth.py

@@ -0,0 +1,38 @@
+import os
+
+from authlib.integrations.flask_client import OAuth
+from flask import redirect, session, url_for
+
+oauth = OAuth()
+
+
+def set_oauth(app):
+    CLIENT_ID = os.getenv("CLIENT_ID") or os.getenv("sso_clientID")  # noqa: SIM112
+    CLIENT_SECRET = os.getenv("CLIENT_SECRET") or os.getenv("sso_clientSecret")  # noqa: SIM112
+    CERN_SSO = "https://auth.cern.ch/auth/realms/cern/.well-known/openid-configuration"
+
+    oauth.init_app(app)
+
+    oauth.register(
+        name="cern",
+        server_metadata_url=CERN_SSO,
+        client_id=CLIENT_ID,
+        client_secret=CLIENT_SECRET,
+        client_kwargs={"scope": "openid email profile"},
+    )
+
+
+def login():
+    redirect_uri = url_for("auth_route", _external=True, _scheme="https")
+    return oauth.cern.authorize_redirect(redirect_uri)
+
+
+def auth():
+    token = oauth.cern.authorize_access_token()
+    session["user"] = token["userinfo"]
+    return redirect("/")
+
+
+def logout():
+    session.pop("user", None)
+    return redirect("/")

chATLAS_Frontend/frontend/chat_processing.py

@@ -0,0 +1,63 @@
+from collections.abc import Mapping
+
+from flask import jsonify
+
+from chATLAS_Frontend.frontend.chat_request import build_chat_request_mattermost
+from chATLAS_Frontend.frontend.html_generation import parse_answer
+from chATLAS_Frontend.frontend.processing import call_chain
+from chATLAS_Frontend.frontend.settings import get_env_settings
+
+
+def process_mattermost(input_request_str: str, user_id: str | None = None):
+    """
+    Process the Mattermost slash-command request through the ChatRequest pipeline.
+
+    Args:
+        input_request_str: Raw text passed to the slash command.
+        user_id: Optional user ID from Mattermost request payload.
+    """
+    env = get_env_settings()
+    session_like: Mapping[str, str] = {"user_id": user_id} if user_id else {}
+
+    try:
+        chat_request = build_chat_request_mattermost(input_request_str, session=session_like, env=env)
+        answer, sources = call_chain(chat_request, log_results=True)
+    except Exception as e:
+        return jsonify({"response_type": "in_channel", "text": f"caught_error_render_error_box\n\nError: {e!s}"})
+
+    if answer is None:
+        return jsonify({"response_type": "in_channel", "text": "No answer returned."})
+
+    try:
+        bot_answer, bot_citations = parse_answer(answer)
+    except Exception as e:
+        return jsonify(
+            {"response_type": "in_channel", "text": f"caught_error_render_error_box\n\nError in parse_answer: {e!s}"}
+        )
+
+    try:
+        md_used_links = get_links_to_used_sources(bot_citations, sources) or ["No sources used."]
+    except Exception:
+        md_used_links = ["Error extracting links."]
+
+    final_response = f"** /chatlas {input_request_str}**\n\n {bot_answer}\n\n Used Sources: \n " + "\n".join(
+        md_used_links
+    )
+    return jsonify({"response_type": "in_channel", "text": final_response})
+
+
+def get_links_to_used_sources(bot_citations, all_sources):
+    """
+    A helper function for mattermost endpoint which extracts the URL for each used source and puts link in md format
+
+    Returns: List[str] - List of md links to used sources
+    """
+    # Create a mapping of name to url from all_sources
+    source_map = {source.metadata.get("name"): source.metadata.get("url") for source in all_sources}
+
+    # Generate markdown links for citations that exist in the source map
+    return [
+        f"[{citation['name']}]({source_map[citation['name']]})"
+        for citation in bot_citations
+        if citation["name"] in source_map
+    ]

chATLAS_Frontend/frontend/chat_request.py

@@ -0,0 +1,278 @@
+"""
+Module to parse requests from both the web app and Mattermost into a common format: ChatRequest.
+
+Once a ChatRequest is built, it can be used to call the LangChain or LangGraph chains directly using their call signatures.
+
+This can be extended to other call signatures as needed.
+"""
+
+from __future__ import annotations
+
+import re
+import uuid
+from collections.abc import MutableMapping
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from chATLAS_Frontend.frontend.settings import EnvSettings, UserSettings
+
+
+@dataclass(frozen=True)
+class ChatRequest:
+    """
+    Holds all options available to the user when making a chat request.
+
+    Attributes:
+        - user_input: The user's input message.
+        - filters: A dictionary of filters to apply:
+            - type: A dictionary of source types : bool pairs
+            - category: Categories to filter on **NOTE** NOT USED
+            - date_filter: A date string in DD-MM-YYYY format
+            - k: Number of vectorstore results to retrieve
+            - k_text: Number of text search results to retrieve
+
+                   used to select which DBs to search, and keyword filters to apply.
+        - assistant_mode: Whether the request is for assistant mode (True) or search mode (False).
+        - user_settings: The per-session user settings.
+        - user_id: The hashed user ID, or special strings for local/mattermost users
+    """
+
+    user_input: str
+    filters: dict[str, Any] | None
+    assistant_mode: bool
+    user_settings: UserSettings
+    user_id: str  # hashed user id (or "Local User", "mattermost-xxx")
+    thread_id: str | None = None  # for conversational graph; set when assistant_mode
+
+    def search_kwargs(self) -> dict[str, Any]:
+        """
+        Build a dictionary the search_kwargs 'metadata' argument expected by LangChain retrieval chains.
+        """
+        filters = self.filters or {}
+
+        # Extract filters
+        # categories = filters.get("category")
+
+        date_filter = filters.get("date_filter")
+
+        metadata = {
+            "date_filter": date_filter,
+            "k": self.user_settings.k_vector,
+            "k_text": self.user_settings.k_text,
+        }
+
+        # if categories:
+        #     args_dict["metadata"]["category"] = categories
+
+        return metadata
+
+    def build_langchain_call_signature(self) -> dict[str, Any]:
+        """
+        Build the dictionary matching the LangChain call signature.
+
+        Can use this to directly call chain.invoke(**kwargs)
+        """
+
+        return {"input": self.user_input, "config": {"metadata": self.search_kwargs()}}
+
+    def build_langgraph_call_signature(self) -> dict[str, Any]:
+        """
+        Build the dictionary matching the LangGraph call signature.
+
+        Can use this to directly call chain.invoke(**kwargs)
+        """
+
+        return {"input": {"question": self.user_input, "search_kwargs": self.search_kwargs()}}
+
+
+def build_chat_request_web(
+    request_json, session: MutableMapping[str, Any], env: EnvSettings, assistant_mode: bool
+) -> ChatRequest:
+    """
+    Build a ChatRequest from the web app payload and session.
+
+    Args:
+        request_json: The JSON payload from the web request.
+        session: The Flask session mapping.
+        env: The EnvSettings.
+        assistant_mode: assistant mode (True) or search mode (False)
+    """
+
+    # need this so UserSettings can pick it up from session
+    # if it's not in the payload, UserSettings will use the default
+    if "date" in request_json:
+        session["date_filter"] = request_json["date"]
+
+    defaults = UserSettings.defaults(env)
+    settings = UserSettings.from_session(session, defaults)
+    try:
+        user_input = request_json["user_input"]
+        filters = request_json["filters"]
+    except KeyError as e:
+        raise ValueError(f"Missing required field in payload: {e!s}")
+
+    if env.local_mode:
+        user_id = "local_user"
+    else:
+        user_obj = session.get("user") or {}
+        user_id = user_obj.get("at_hash", "unknown-user")
+
+    filters["date_filter"] = _normalize_date_filter(request_json.get("date", settings.date_filter))
+
+    thread_id = None
+    if assistant_mode:
+        thread_id = session.get("thread_id")
+        if not thread_id:
+            session["thread_id"] = str(uuid.uuid4())
+            thread_id = session["thread_id"]
+
+    return ChatRequest(
+        user_input=user_input,
+        filters=filters,
+        assistant_mode=assistant_mode,
+        user_settings=settings,
+        user_id=user_id,
+        thread_id=thread_id,
+    )
+
+
+def _normalize_date_filter(raw_date: Any) -> str:
+    """
+    Normalize date filter string to DD-MM-YYYY for downstream SQL.
+
+    Inputs:
+        raw_date: Raw date value from payload/session in DD-MM-YYYY or YYYY-MM-DD.
+    Outputs:
+        str: Date string in DD-MM-YYYY format.
+    """
+    if raw_date is None:
+        return "01-01-2020"
+
+    date_str = str(raw_date).strip()
+    if not date_str:
+        return "01-01-2020"
+
+    # already in DD-MM-YYYY
+    if re.fullmatch(r"\d{2}-\d{2}-\d{4}", date_str):
+        return date_str
+
+    # browser date input commonly uses YYYY-MM-DD
+    if re.fullmatch(r"\d{4}-\d{2}-\d{2}", date_str):
+        return datetime.strptime(date_str, "%Y-%m-%d").strftime("%d-%m-%Y")
+
+    # fallback to safe default for malformed input
+    return "01-01-2020"
+
+
+def _parse_mattermost_input(input_str: str) -> dict[str, Any]:
+    """
+    Parse input string from mattermost
+
+    Returns: Parsed input with keys:
+                - type (List[str]) Vectorstores to search
+                - date-filter (str) Date filter in DD-MM-YYYY format
+                - k (int) Number of vectorstore results
+                - k_text (int) Number of text search results
+                - message (str) The main user input message
+    """
+    # Canonical source names (map legacy aliases to currently supported source values)
+    valid_sources = {
+        "twiki": "twiki",
+        "cds": "CDS",
+        "indico": "Indico",
+        "atlastalk": "AtlasTalk",
+        "atlas_talk": "AtlasTalk",
+        "gitlabmarkdown": "GitLabMarkdown",
+        "gitlab_markdown": "GitLabMarkdown",
+        "mkdocs": "GitLabMarkdown",
+    }
+
+    # Defaults
+    filters = {
+        "type": [],  # default: ["twiki", "MkDocs"] set below
+        "k": 4,
+        "k_text": 3,
+        "user_input": "",
+        "date-filter": "01-01-2020",
+    }
+
+    default_types = ["twiki", "GitLabMarkdown"]
+
+    # Remove the leading command
+    input_str = re.sub(r"^/\w+\s*", "", input_str)
+
+    # Match [content] blocks
+    bracket_pattern = re.compile(r"\[([^\[\]]+)\]")
+    matches = bracket_pattern.findall(input_str)
+    remaining = input_str
+
+    # Date pattern: DD-MM-YYYY
+    date_pattern = re.compile(r"^\d{2}-\d{2}-\d{4}$")
+
+    for match in matches:
+        remaining = remaining.replace(f"[{match}]", "", 1).strip()
+        lowered = match.lower()
+
+        # Match exact date format
+        if date_pattern.match(match.strip()):
+            filters["date-filter"] = match.strip()
+            continue
+
+        # Parse k_text and k
+        if lowered.startswith("k_text="):
+            try:
+                filters["k_text"] = int(lowered.split("=")[1])
+                continue
+            except ValueError:
+                pass
+        elif lowered.startswith("k="):
+            try:
+                filters["k"] = int(lowered.split("=")[1])
+                continue
+            except ValueError:
+                pass
+
+        # Source types
+        candidates = [s.strip() for s in match.split(",")]
+        for c in candidates:
+            key = c.lower()
+            if key in valid_sources:
+                filters["type"].append(valid_sources[key])
+
+    if not filters["type"]:
+        filters["type"] = default_types
+
+    filters["user_input"] = remaining.strip()
+    return filters
+
+
+def build_chat_request_mattermost(
+    request_text: str, session: MutableMapping[str, Any], env: EnvSettings
+) -> ChatRequest:
+    """
+    Build a ChatRequest from the Mattermost request form and session.
+
+    Args:
+        request_text: The text of the Mattermost request (usually get this using request.form["text"])
+        session: The Flask session mapping.
+        env: The environment settings.
+    """
+    parsed_dict = _parse_mattermost_input(request_text)
+    defaults = UserSettings.defaults(env)
+    settings = UserSettings.from_session(session, defaults).apply_overrides(
+        {"k_vector": parsed_dict["k"], "k_text": parsed_dict["k_text"]}
+    )
+
+    user_id = "mattermost-" + session.get("user_id", "unknown")
+
+    return ChatRequest(
+        user_input=parsed_dict["user_input"],
+        filters={
+            "sources": {source: True for source in parsed_dict["type"]},
+            "date_filter": parsed_dict["date-filter"],
+        },
+        assistant_mode=True,  # TODO: add search only mode for mattermost
+        user_settings=settings,
+        user_id=user_id,
+    )