codex-agent-framework 0.1.1__py3-none-any.whl

codex_agent/get_text/simpler_get_text.py

@@ -0,0 +1,184 @@
+"""Lightweight text extraction using only standard library.
+
+This is a fallback for when the full get_text.py dependencies are not available.
+Supports basic file reading and URL fetching without external dependencies
+(except urllib which is stdlib).
+"""
+
+import os
+import re
+from typing import Optional
+from urllib.request import urlopen
+from urllib.error import URLError, HTTPError
+from html.parser import HTMLParser
+
+
+def get_text(source: str) -> str:
+    """Extract text from a file or URL using only stdlib.
+
+    This is a simplified version that handles:
+    - Plain text files
+    - URLs (basic HTTP/HTTPS fetching)
+    - Directory listings
+
+    Args:
+        source: File path or URL to extract text from
+
+    Returns:
+        Extracted text content, or error message
+    """
+    # Check if it's a URL
+    if source.startswith(('http://', 'https://')):
+        return _handle_url(source)
+
+    # Check if it's a directory
+    if os.path.isdir(source):
+        return _handle_directory(source)
+
+    # Handle as file
+    return _handle_file(source)
+
+
+def _handle_file(path: str) -> str:
+    """Read a text file from disk.
+
+    Args:
+        path: Path to file
+
+    Returns:
+        File contents or error message
+    """
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except FileNotFoundError:
+        return f"File not found: {path}"
+    except PermissionError:
+        return f"Permission denied: {path}"
+    except UnicodeDecodeError:
+        # Try binary mode for non-text files
+        return f"Binary file (cannot read as text): {path}"
+    except Exception as e:
+        return f"Error reading file: {e}"
+
+
+def _handle_directory(path: str) -> str:
+    """List directory contents.
+
+    Args:
+        path: Path to directory
+
+    Returns:
+        Directory listing as text
+    """
+    try:
+        entries = os.listdir(path)
+        if not entries:
+            return f"{path}/\n(empty directory)"
+
+        lines = [f"{path}/"]
+        for entry in sorted(entries):
+            full_path = os.path.join(path, entry)
+            if os.path.isdir(full_path):
+                lines.append(f"  {entry}/")
+            else:
+                lines.append(f"  {entry}")
+
+        return '\n'.join(lines)
+    except PermissionError:
+        return f"Permission denied: {path}"
+    except Exception as e:
+        return f"Error listing directory: {e}"
+
+
+class _HTMLTextExtractor(HTMLParser):
+    """Simple HTML parser to extract text content using stdlib only."""
+
+    def __init__(self):
+        super().__init__()
+        self.text_parts = []
+        self.skip_tags = {'script', 'style', 'head', 'meta', 'link'}
+        self.current_tag = None
+
+    def handle_starttag(self, tag, attrs):
+        self.current_tag = tag
+
+    def handle_endtag(self, tag):
+        self.current_tag = None
+
+    def handle_data(self, data):
+        if self.current_tag not in self.skip_tags:
+            text = data.strip()
+            if text:
+                self.text_parts.append(text)
+
+    def get_text(self):
+        return '\n'.join(self.text_parts)
+
+
+def _strip_html(html_content: str) -> str:
+    """Strip HTML tags and extract text content.
+
+    Args:
+        html_content: HTML content as string
+
+    Returns:
+        Plain text content
+    """
+    try:
+        parser = _HTMLTextExtractor()
+        parser.feed(html_content)
+        text = parser.get_text()
+
+        # Clean up excessive whitespace
+        text = re.sub(r'\n{3,}', '\n\n', text)
+
+        return text if text else html_content  # Fallback to raw if parsing fails
+    except Exception:
+        # If parsing fails, return raw content
+        return html_content
+
+
+def _handle_url(url: str) -> str:
+    """Fetch content from a URL and extract text.
+
+    Args:
+        url: URL to fetch
+
+    Returns:
+        URL content as text or error message
+    """
+    try:
+        with urlopen(url, timeout=30) as response:
+            # Read content
+            content = response.read()
+
+            # Try to decode as text
+            try:
+                html = content.decode('utf-8')
+            except UnicodeDecodeError:
+                # Try other common encodings
+                for encoding in ['latin-1', 'iso-8859-1', 'windows-1252']:
+                    try:
+                        html = content.decode(encoding)
+                        break
+                    except UnicodeDecodeError:
+                        continue
+                else:
+                    return f"Binary content (cannot decode as text): {url}"
+
+            # Strip HTML tags if it looks like HTML
+            if '<html' in html.lower() or '<body' in html.lower():
+                return _strip_html(html)
+            else:
+                # Plain text content
+                return html
+
+    except HTTPError as e:
+        return f"HTTP Error {e.code}: {url}"
+    except URLError as e:
+        return f"URL Error: {e.reason}"
+    except TimeoutError:
+        return f"Request timed out: {url}"
+    except Exception as e:
+        return f"Error fetching URL: {e}"

codex_agent/get_webdriver.py

@@ -0,0 +1,44 @@
+from selenium import webdriver
+from selenium.webdriver.firefox.service import Service as FirefoxService
+from selenium.webdriver.firefox.options import Options as FirefoxOptions
+from get_gecko_driver import GetGeckoDriver
+from shutil import which
+import os
+
+def get_webdriver():
+    """Get a headless Firefox WebDriver instance.
+
+    Automatically installs geckodriver if not found in PATH.
+    Configures Firefox in headless mode with standard options.
+
+    Returns:
+        selenium.webdriver.Firefox: Configured headless Firefox WebDriver.
+
+    Note:
+        Requires Firefox browser to be installed on the system.
+    """
+    from .utils import root_join
+    tmp_path=root_join("tmp")
+    if not os.path.isdir(tmp_path):
+        os.makedirs(tmp_path)
+    os.environ['TMPDIR']=tmp_path
+    path=which('geckodriver')
+    if not path:
+        # Install the latest version of GeckoDriver
+        get_driver = GetGeckoDriver()
+        path=get_driver.install()
+        print(f"geckodriver successfully installed to {path}")
+    else:
+        path=os.path.dirname(path)
+    # Set the driver
+    service=FirefoxService(log_path=os.path.devnull,executable_path=os.path.join(path,'geckodriver'))
+    options = FirefoxOptions()
+    # Enable headless mode
+    options.add_argument('--headless')
+    # Disable GPU (not necessary for headless)
+    options.add_argument('--disable-gpu')
+    # Set the window size (some websites require a minimum window size)
+    options.add_argument('--window-size=1920,1080')
+    # Instantiate a headless Firefox WebDriver
+    driver = webdriver.Firefox(options=options, service=service)
+    return driver

codex_agent/image.py

@@ -0,0 +1,304 @@
+from .message import Message, register_message_type
+from .utils import guess_extension_from_bytes, runtime_join, short_id, timestamp
+import base64
+import binascii
+from collections.abc import Mapping
+from io import BytesIO
+import os
+import re
+
+from PIL import Image as PILImage
+import requests
+from urllib.parse import urlparse
+
+
+IMAGE_CACHE_ATTR = 'b64_string'
+IMAGE_DIR = 'images'
+
+
+def ext_to_mime(ext):
+    ext = ext.lower().lstrip('.')
+    if ext in ('jpg', 'jpeg'):
+        return 'image/jpeg'
+    if ext == 'png':
+        return 'image/png'
+    if ext == 'webp':
+        return 'image/webp'
+    if ext == 'gif':
+        return 'image/gif'
+    return None
+
+
+def _data_url(data, mime_type):
+    b64 = base64.b64encode(data).decode('utf-8')
+    return f"data:{mime_type};base64,{b64}"
+
+
+def data_url_from_file(path):
+    ext = os.path.splitext(path)[1]
+    mime_type = ext_to_mime(ext) or 'image/jpeg'
+    with open(path, 'rb') as f:
+        return _data_url(f.read(), mime_type)
+
+
+def image_request_headers(url):
+    """Return browser-like headers for remote image fetches.
+
+    Some image hosts/CDNs reject the default python-requests user agent even
+    for public images. A small, stable header set makes observe() much more
+    reliable without changing semantics.
+    """
+    parsed = urlparse(url)
+    referer = f"{parsed.scheme}://{parsed.netloc}/" if parsed.scheme and parsed.netloc else None
+    headers = {
+        "User-Agent": (
+            "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+            "(KHTML, like Gecko) Chrome/124.0 Safari/537.36 codex-agent/observe"
+        ),
+        "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
+    }
+    if referer:
+        headers["Referer"] = referer
+    return headers
+
+
+def image_mime_from_source(source, content_type=None):
+    content_type = (content_type or '').split(';')[0].strip()
+    if content_type.startswith('image/'):
+        return content_type
+    if isinstance(source, str):
+        ext = os.path.splitext(source.split('?', 1)[0])[1]
+        return ext_to_mime(ext) or 'image/jpeg'
+    return 'image/png'
+
+
+def fetch_image_bytes(url, timeout=15):
+    response = requests.get(url, timeout=timeout, headers=image_request_headers(url))
+    response.raise_for_status()
+
+    data = response.content
+    if not data:
+        raise ValueError(f"URL resolved to an empty image response: {url!r}")
+
+    content_type = response.headers.get('content-type')
+    content_mime = (content_type or '').split(';')[0].strip()
+    guessed_mime = ext_to_mime(guess_extension_from_bytes(data) or '')
+
+    if content_mime and not content_mime.startswith('image/'):
+        if not guessed_mime:
+            raise ValueError(f"URL did not resolve to an image: {url!r} ({content_mime})")
+        return data, guessed_mime
+
+    return data, guessed_mime or image_mime_from_source(url, content_type)
+
+
+def data_url_from_url(url):
+    data, mime_type = fetch_image_bytes(url)
+    return _data_url(data, mime_type)
+
+
+def persist_image_url(url):
+    data, mime_type = fetch_image_bytes(url)
+    ext = os.path.splitext(url.split('?', 1)[0])[1] or None
+    mime_ext = {
+        'image/jpeg': '.jpg',
+        'image/png': '.png',
+        'image/webp': '.webp',
+        'image/gif': '.gif',
+    }.get(mime_type)
+    if mime_ext and ext_to_mime(ext or '') != mime_type:
+        ext = mime_ext
+    return persist_image_bytes(data, name=f"remote{ext or ''}")
+
+
+def get_data_url(source):
+    if isinstance(source, str) and os.path.isfile(source):
+        return data_url_from_file(source)
+    if isinstance(source, str) and source.startswith(('http://', 'https://')):
+        return data_url_from_url(source)
+    raise ValueError(f"Unsupported image source: {source!r}")
+
+
+def persist_image_bytes(data, name=None):
+    _, ext = os.path.splitext(name) if isinstance(name, str) else ('', '')
+    ext = ext or guess_extension_from_bytes(data) or '.png'
+
+    folder = runtime_join(IMAGE_DIR)
+    os.makedirs(folder, exist_ok=True)
+
+    path = runtime_join(IMAGE_DIR, f"{timestamp()}_{short_id()}{ext}")
+    with open(path, 'wb') as f:
+        f.write(data)
+    return path
+
+
+def persist_bytesio(source):
+    return persist_image_bytes(source.getvalue(), name=getattr(source, 'name', None))
+
+
+def image_name_from_source(source):
+    if isinstance(source, BytesIO) and getattr(source, 'name', None):
+        return os.path.basename(source.name)
+    if isinstance(source, str) and os.path.isfile(source):
+        return os.path.basename(source)
+    if source:
+        return str(source)
+    return 'Unnamed image'
+
+
+def normalize_image_content(content):
+    if isinstance(content, BytesIO):
+        return persist_bytesio(content)
+    if isinstance(content, bytes):
+        return persist_image_bytes(content)
+    if content is not None and not isinstance(content, str):
+        raise TypeError(f"Image content must be a path, URL, BytesIO, or bytes. Got {type(content).__name__}.")
+    return content
+
+
+@register_message_type
+class ImageMessage(Message):
+    """Image message with a lightweight serialized payload.
+
+    The session stores only reloadable ``content``. The base64 data URL is
+    cached as runtime metadata and generated only when formatting API input.
+    """
+
+    detail = "auto"
+    description = None
+    image_name = None
+    embedding = None
+    name = 'image'
+    role = "user"
+
+    def __init__(self, *args, **kwargs):
+        args, kwargs, data_url, content_name = self._prepare_init_payload(args, kwargs)
+        super().__init__(*args, **kwargs)
+
+        if not self.get('image_name'):
+            self.image_name = content_name or image_name_from_source(self.get('content'))
+
+        if data_url:
+            self.set_attr(IMAGE_CACHE_ATTR, data_url)
+
+    @classmethod
+    def _prepare_init_payload(cls, args, kwargs):
+        kwargs = dict(kwargs)
+        data_url = kwargs.pop(IMAGE_CACHE_ATTR, None)
+        content = kwargs.get('content')
+
+        if args and isinstance(args[0], Mapping):
+            data = dict(args[0])
+            data_url = data.pop(IMAGE_CACHE_ATTR, data_url)
+            if 'content' in data:
+                if 'content' not in kwargs:
+                    content = data['content']
+                data['content'] = normalize_image_content(data['content'])
+            args = (data, *args[1:])
+
+        if 'content' in kwargs:
+            content = kwargs['content']
+            kwargs['content'] = normalize_image_content(content)
+
+        content_name = image_name_from_source(content) if content is not None else None
+        return args, kwargs, data_url, content_name
+
+    def get_base64(self):
+        data_url = self.get_attr(IMAGE_CACHE_ATTR, None)
+        if data_url:
+            return data_url
+
+        try:
+            data_url = get_data_url(self.get('content'))
+        except Exception:
+            return None
+
+        self.set_attr(IMAGE_CACHE_ATTR, data_url)
+        return data_url
+
+    def is_valid(self):
+        data_url = self.get_base64()
+        if not isinstance(data_url, str) or not data_url.startswith('data:image/'):
+            return False
+        match = re.match(r"^data:image/[^;]+;base64,(.*)$", data_url)
+        if not match:
+            return False
+        try:
+            image_bytes = base64.b64decode(match.group(1), validate=True)
+        except (binascii.Error, ValueError):
+            return False
+        try:
+            with PILImage.open(BytesIO(image_bytes)) as img:
+                img.verify()
+        except Exception:
+            return False
+        return True
+
+    def content_to_response_parts(self, output=False):
+        data_url = self.get_base64()
+        if not data_url:
+            return [{
+                'type': 'input_text',
+                'text': f"Unable to access the image ({self.image_name!r})",
+            }]
+
+        text = (
+            "The following image has been made available in context for visual analysis:\n"
+            + repr(self.image_name)
+        )
+        if self.get('description'):
+            text += f"\nAlong with the following description:\n{self.description}\n"
+
+        return [
+            {
+                'type': 'input_image',
+                'image_url': data_url,
+                'detail': self.detail,
+            },
+            {
+                'type': 'input_text',
+                'text': text,
+            },
+        ]
+
+    def to_response_format(self):
+        return {
+            "type": "message",
+            "role": self.role,
+            "content": self.content_to_response_parts(),
+        }
+
+    def as_string_attrs(self):
+        attrs = self.extract('name', 'type', 'timestamp')
+        attrs["image_name"] = self.get("image_name")
+        attrs["detail"] = self.get("detail")
+        return self.format_as_string_attrs(attrs)
+
+    def as_string_body(self):
+        parts = []
+        if self.get("content"):
+            parts.append(f"<source>{self.content}</source>")
+        if self.get("description"):
+            parts.append(f"<description>{self.description}</description>")
+        return "\n".join(parts)
+
+    def as_bytesio(self):
+        data_url = self.get_base64()
+        if not data_url:
+            return None
+
+        match = re.match(r"^data:image/[^;]+;base64,(.*)$", data_url)
+        if not match:
+            return None
+        return BytesIO(base64.b64decode(match.group(1)))
+
+    def show(self):
+        img_bytes = self.as_bytesio()
+        if not img_bytes:
+            print("[ImageMessage.show] Image non disponible en mémoire.")
+            return
+
+        try:
+            PILImage.open(img_bytes).show()
+        except Exception as e:
+            print(f"[ImageMessage.show] Erreur lors de l'affichage : {e}")

codex_agent/latex.py

@@ -0,0 +1,165 @@
+import re
+from .stream_utils import Streamer, TokenStreamer, fenced
+
+def escape_formula_specials(formula: str) -> str:
+    r"""
+    Dans une formule KaTeX, on veut transformer uniquement les séquences
+    d'escape type JSON/Python :
+
+        \n, \t, \r, \b, \f, \", \'
+
+    en :
+
+        \\n, \\t, \\r, \\b, \\f, \\", \'
+
+    SANS toucher :
+      - aux séquences déjà échappées (\\n, \\t, ...)
+      - aux commandes LaTeX (\frac, \alpha, \begin, ...)
+      - aux brackets ()[]{} et autres structures KaTeX.
+    """
+
+    # 1) Contrôles \n \t \r \b \f
+    # On ne touche que les séquences \x non suivies d'une autre lettre
+    # pour éviter \frac, \begin, etc.
+    control_chars = "ntrbf"
+    pattern_controls = re.compile(
+        rf'(?<!\\)\\([{control_chars}])(?=$|[^A-Za-z])'
+    )
+    formula = pattern_controls.sub(r'\\\1', formula)
+
+    # 2) Quotes : \" et \'
+    pattern_quotes = re.compile(r'(?<!\\)\\(["\'])')
+    formula = pattern_quotes.sub(r'\\\1', formula)
+
+    return formula
+
+def _normalize_latex_delimiters(text: str) -> str:
+    r"""
+    Convertit :
+      \( ... \)  ->  $...$
+      \[ ... \]  ->  $$...$$
+
+    - Sur une seule ligne (pas de \n à l'intérieur)
+    - On supporte les backslashes normaux type LLM / JSON.
+    """
+
+    # Display math : \[ ... \]  ->  $$ ... $$
+    text = re.sub(
+        r'(?<!\\)\\\[(?P<disp>[^\]\n]+?)\\\]',   # \[ ... \]
+        lambda m: f"$${m.group('disp')}$$",
+        text,
+    )
+
+    # Inline math : \( ... \)  ->  $ ... $
+    text = re.sub(
+        r'(?<!\\)\\\((?P<inl>[^\)\n]+?)\\\)',    # \( ... \)
+        lambda m: f"${m.group('inl')}$",
+        text,
+    )
+
+    return text
+
+def _escape_katex_formulas(text: str) -> str:
+    r"""
+    Traite uniquement les formules KaTeX dans `text` (hors blocs de code).
+
+    Gère :
+      - block triple ligne :  $$ \n ... \n $$
+      - display inline :     $$ ... $$
+      - inline :             $ ... $
+    """
+
+    # D'abord normaliser \(..\) et \[..\] en $..$ / $$..$$
+    text = _normalize_latex_delimiters(text)
+
+    pattern = re.compile(
+        r"""
+        # 1) Bloc KaTeX sur plusieurs lignes :
+        (?P<block>^\s*\$\$\s*\n(?P<block_content>.*?)(?:\n)?\s*\$\$\s*$)
+        |
+        # 2) Inline display : $$...$$ sur une seule ligne
+        (?P<inline_display>(?<!\$)\$\$(?!\$)(?P<inline_display_content>[^\n$]+?)\$\$(?!\$))
+        |
+        # 3) Inline normal : $...$ sur une seule ligne
+        (?P<inline>(?<!\$)\$(?!\$)(?P<inline_content>[^$\n]+?)\$(?!\$))
+        """,
+        re.VERBOSE | re.DOTALL | re.MULTILINE,
+    )
+
+    def repl(match: re.Match) -> str:
+        # Bloc multi-ligne
+        if match.group("block_content") is not None:
+            content = match.group("block_content")
+            return "$$\n" + escape_formula_specials(content) + "\n$$"
+
+        # Inline display $$...$$
+        if match.group("inline_display_content") is not None:
+            content = match.group("inline_display_content")
+            return f"$${escape_formula_specials(content)}$$"
+
+        # Inline $...$
+        content = match.group("inline_content")
+        return f"${escape_formula_specials(content)}$"
+
+    return pattern.sub(repl, text)
+
+def format_latex(md: str) -> str:
+    r"""
+    Traite les formules KaTeX dans un markdown *raw-like* :
+
+      - ignore complètement les blocs de code :
+            ```...``` ou ~~~...~~~
+      - convertit \(..\) en $..$, \[..] en $$..$$
+      - gère :
+            $$ \n ... \n $$     (block)
+            $$ ... $$           (inline display)
+            $ ... $             (inline)
+      - échappe les séquences d'escape foireuses dans les formules.
+    """
+
+    code_pattern = re.compile(
+        r"""
+        (
+          ```.*?```         # bloc ```...```
+        | ~~~.*?~~~         # bloc ~~~...~~~
+        )
+        """,
+        re.VERBOSE | re.DOTALL,
+    )
+
+    parts = code_pattern.split(md)
+    out_parts = []
+
+    for part in parts:
+        if not part:
+            continue
+        if part.startswith("```") or part.startswith("~~~"):
+            # bloc de code → on ne touche à rien
+            out_parts.append(part)
+        else:
+            # texte normal → traitement KaTeX
+            out_parts.append(_escape_katex_formulas(part))
+
+    return "".join(out_parts)
+
+class LaTeXProcessor(Streamer):
+    """Stream processor for formatting LaTeX/KaTeX formulas in markdown text.
+
+    Escapes special characters in LaTeX formulas while preserving code blocks.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.token_streamer = TokenStreamer([
+            # ignore processing in markdown code blocs
+            (fenced('```','```',flags=re.DOTALL|re.MULTILINE), lambda m: f'{m.group()}'),
+            # Mute LaTeX formulas
+            (fenced(r'\$\$',r'\$\$',flags=re.DOTALL|re.MULTILINE), lambda m: f'{format_latex(m.group())}'),
+            (fenced(r'\\\[',r'\\\]',flags=re.DOTALL|re.MULTILINE), lambda m: f'{format_latex(m.group())}'),
+            (fenced(r'\\\(',r'\\\)',flags=re.DOTALL|re.MULTILINE), lambda m: f'{format_latex(m.group())}'),
+            (r'\$[^$\n]+?\$', lambda m: f'{format_latex(m.group())}'),
+        ], threaded=False)
+
+    def stream_processor(self, stream):
+        """Process stream and format LaTeX formulas."""
+        return self.token_streamer.process(stream)