projectdavid 1.33.12__tar.gz → 1.33.14__tar.gz

{projectdavid-1.33.12 → projectdavid-1.33.14}/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.33.14](https://github.com/frankie336/projectdavid/compare/v1.33.13...v1.33.14) (2025-06-16)
+
+
+### Bug Fixes
+
+* Back out from vision support - resource issue. Revisit in grand plan ([3199ba7](https://github.com/frankie336/projectdavid/commit/3199ba7a18b3cfcc0f7306cd8748105f593a1836))
+
+## [1.33.13](https://github.com/frankie336/projectdavid/compare/v1.33.12...v1.33.13) (2025-06-13)
+
+
+### Bug Fixes
+
+* restore code_interpreter_stream passthrough.14 ([df2a75f](https://github.com/frankie336/projectdavid/commit/df2a75f47a55d07d42af3a9949ef9bed4496a602))
+
 ## [1.33.12](https://github.com/frankie336/projectdavid/compare/v1.33.11...v1.33.12) (2025-06-13)
 
 

{projectdavid-1.33.12/src/projectdavid.egg-info → projectdavid-1.33.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: projectdavid
-Version: 1.33.12
+Version: 1.33.14
 Summary: Python SDK for interacting with the Entities Assistant API.
 Author-email: Francis Neequaye Armah <francis.neequaye@projectdavid.co.uk>
 License: PolyForm Noncommercial License 1.0.0

{projectdavid-1.33.12 → projectdavid-1.33.14}/docs/vector_store.md

@@ -24,9 +24,8 @@ print(test_user)
 
 # create a vector store
 store = client.vectors.create_vector_store(
-    name='Test Vector Store1',
-    user_id=test_user.id,
-)
+    name='Test Vector Store1')
+
 print(store)
 ```
 
@@ -81,14 +80,16 @@ At this point, your file has been vectorized to your store.
 
 ---
 
+### Searches
 
-## Supporting image vectors
 
-Entities now ingests and vectorizes a wide range of image formats for semantic search. You can leverage these image embeddings to extend text-only models into powerful multi-modal workflows; enriching chatbots, document search, recommendation engines, and more.
 
 ---
 
-### Making Searches Against Files in a Store
+
+
+
+
 
 - The assistant will self-select appropriate vector store 
 searches using its latent logic when responding to a prompt.

{projectdavid-1.33.12 → projectdavid-1.33.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "projectdavid"
-version = "1.33.12"
+version = "1.33.14"
 description = "Python SDK for interacting with the Entities Assistant API."
 readme = "README.md"
 authors = [

projectdavid-1.33.14/src/projectdavid/clients/file_processor.py

@@ -0,0 +1,364 @@
+import asyncio
+import csv
+import json
+import re
+import textwrap
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Any, Dict, List, Tuple, Union
+
+try:  # Python 3.11+
+    from typing import LiteralString
+except ImportError:  # 3.9–3.10
+    from typing_extensions import LiteralString
+
+import numpy as np
+import pdfplumber
+from docx import Document
+from pptx import Presentation
+from projectdavid_common import UtilsInterface
+from sentence_transformers import SentenceTransformer
+
+log = UtilsInterface.LoggingUtility()
+
+
+class FileProcessor:
+    # ------------------------------------------------------------------ #
+    #  Construction
+    # ------------------------------------------------------------------ #
+    def __init__(self, max_workers: int = 4, chunk_size: int = 512):
+        self.embedding_model = SentenceTransformer("paraphrase-MiniLM-L6-v2")
+        self.embedding_model_name = "paraphrase-MiniLM-L6-v2"
+        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+
+        # token limits
+        self.max_seq_length = self.embedding_model.get_max_seq_length()
+        self.special_tokens_count = 2
+        self.effective_max_length = self.max_seq_length - self.special_tokens_count
+        self.chunk_size = min(chunk_size, self.effective_max_length * 4)
+
+        log.info("Initialized optimized FileProcessor")
+
+    # ------------------------------------------------------------------ #
+    #  Generic validators
+    # ------------------------------------------------------------------ #
+    def validate_file(self, file_path: Path):
+        """Ensure file exists and is under 100 MB."""
+        max_size = 100 * 1024 * 1024
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+        if file_path.stat().st_size > max_size:
+            mb = max_size // (1024 * 1024)
+            raise ValueError(f"{file_path.name} > {mb} MB limit")
+
+    # ------------------------------------------------------------------ #
+    #  File-type detection  (simple extension map – NO libmagic)
+    # ------------------------------------------------------------------ #
+    def _detect_file_type(self, file_path: Path) -> str:
+        """
+        Return one of:
+
+            • 'pdf'   • 'csv'   • 'json'
+            • 'office' (.doc/.docx/.pptx)
+            • 'text'  (code / markup / plain text)
+
+        Raises *ValueError* if the extension is not recognised.
+        """
+        suffix = file_path.suffix.lower()
+
+        if suffix == ".pdf":
+            return "pdf"
+        if suffix == ".csv":
+            return "csv"
+        if suffix == ".json":
+            return "json"
+        if suffix in {".doc", ".docx", ".pptx"}:
+            return "office"
+
+        text_exts = {
+            ".txt",
+            ".md",
+            ".rst",
+            ".c",
+            ".cpp",
+            ".cs",
+            ".go",
+            ".java",
+            ".js",
+            ".ts",
+            ".php",
+            ".py",
+            ".rb",
+            ".sh",
+            ".tex",
+            ".html",
+            ".css",
+        }
+        if suffix in text_exts:
+            return "text"
+
+        raise ValueError(f"Unsupported file type: {file_path.name} (ext={suffix})")
+
+    # ------------------------------------------------------------------ #
+    #  Public entry-point
+    # ------------------------------------------------------------------ #
+    async def process_file(self, file_path: Union[str, Path]) -> Dict[str, Any]:
+        """Validate → detect → dispatch to the appropriate processor."""
+        file_path = Path(file_path)
+        self.validate_file(file_path)
+        ftype = self._detect_file_type(file_path)
+
+        dispatch_map = {
+            "pdf": self._process_pdf,
+            "text": self._process_text,
+            "csv": self._process_csv,
+            "office": self._process_office,
+            "json": self._process_json,
+        }
+        if ftype not in dispatch_map:
+            raise ValueError(f"Unsupported file type: {file_path.suffix}")
+
+        return await dispatch_map[ftype](file_path)
+
+    # ------------------------------------------------------------------ #
+    #  PDF
+    # ------------------------------------------------------------------ #
+    async def _process_pdf(self, file_path: Path) -> Dict[str, Any]:
+        page_chunks, doc_meta = await self._extract_text(file_path)
+        all_chunks, line_data = [], []
+
+        for page_text, page_num, line_nums in page_chunks:
+            lines = page_text.split("\n")
+            buf, buf_lines, length = [], [], 0
+            for line, ln in zip(lines, line_nums):
+                l = len(line) + 1
+                if length + l <= self.chunk_size:
+                    buf.append(line)
+                    buf_lines.append(ln)
+                    length += l
+                else:
+                    if buf:
+                        all_chunks.append("\n".join(buf))
+                        line_data.append({"page": page_num, "lines": buf_lines})
+                        buf, buf_lines, length = [], [], 0
+                    for piece in self._split_oversized_chunk(line):
+                        all_chunks.append(piece)
+                        line_data.append({"page": page_num, "lines": [ln]})
+            if buf:
+                all_chunks.append("\n".join(buf))
+                line_data.append({"page": page_num, "lines": buf_lines})
+
+        vectors = await asyncio.gather(
+            *[self._encode_chunk_async(c) for c in all_chunks]
+        )
+        return {
+            "content": "\n\n".join(all_chunks),
+            "metadata": {
+                **doc_meta,
+                "source": str(file_path),
+                "chunks": len(all_chunks),
+                "type": "pdf",
+            },
+            "chunks": all_chunks,
+            "vectors": [v.tolist() for v in vectors],
+            "line_data": line_data,
+        }
+
+    # ------------------------------------------------------------------ #
+    #  Plain-text / code / markup
+    # ------------------------------------------------------------------ #
+    async def _process_text(self, file_path: Path) -> Dict[str, Any]:
+        text, extra_meta, _ = await self._extract_text(file_path)
+        chunks = self._chunk_text(text)
+        vectors = await asyncio.gather(*[self._encode_chunk_async(c) for c in chunks])
+        return {
+            "content": text,
+            "metadata": {
+                **extra_meta,
+                "source": str(file_path),
+                "chunks": len(chunks),
+                "type": "text",
+            },
+            "chunks": chunks,
+            "vectors": [v.tolist() for v in vectors],
+        }
+
+    # ------------------------------------------------------------------ #
+    #  CSV
+    # ------------------------------------------------------------------ #
+    async def _process_csv(
+        self, file_path: Path, text_field: str = "description"
+    ) -> Dict[str, Any]:
+        rows, texts, metas = [], [], []
+        with file_path.open(newline="", encoding="utf-8") as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                txt = row.get(text_field, "").strip()
+                if not txt:
+                    continue
+                texts.append(txt)
+                metas.append({k: v for k, v in row.items() if k != text_field and v})
+
+        vectors = await asyncio.gather(*[self._encode_chunk_async(t) for t in texts])
+        return {
+            "content": None,
+            "metadata": {"source": str(file_path), "rows": len(texts), "type": "csv"},
+            "chunks": texts,
+            "vectors": [v.tolist() for v in vectors],
+            "csv_row_metadata": metas,
+        }
+
+    # ------------------------------------------------------------------ #
+    #  Office docs (.doc/.docx/.pptx)
+    # ------------------------------------------------------------------ #
+    async def _process_office(self, file_path: Path) -> Dict[str, Any]:
+        loop = asyncio.get_event_loop()
+        if file_path.suffix.lower() in {".doc", ".docx"}:
+            text = await loop.run_in_executor(
+                self._executor, self._read_docx, file_path
+            )
+        else:  # .pptx
+            text = await loop.run_in_executor(
+                self._executor, self._read_pptx, file_path
+            )
+
+        chunks = self._chunk_text(text)
+        vectors = await asyncio.gather(*[self._encode_chunk_async(c) for c in chunks])
+        return {
+            "content": text,
+            "metadata": {
+                "source": str(file_path),
+                "chunks": len(chunks),
+                "type": "office",
+            },
+            "chunks": chunks,
+            "vectors": [v.tolist() for v in vectors],
+        }
+
+    # ------------------------------------------------------------------ #
+    #  JSON
+    # ------------------------------------------------------------------ #
+    async def _process_json(self, file_path: Path) -> Dict[str, Any]:
+        text = await asyncio.get_event_loop().run_in_executor(
+            self._executor, self._read_json, file_path
+        )
+        chunks = self._chunk_text(text)
+        vectors = await asyncio.gather(*[self._encode_chunk_async(c) for c in chunks])
+        return {
+            "content": text,
+            "metadata": {
+                "source": str(file_path),
+                "chunks": len(chunks),
+                "type": "json",
+            },
+            "chunks": chunks,
+            "vectors": [v.tolist() for v in vectors],
+        }
+
+    # ------------------------------------------------------------------ #
+    #  Shared helpers
+    # ------------------------------------------------------------------ #
+    async def _extract_text(self, file_path: Path) -> Union[
+        Tuple[List[Tuple[str, int, List[int]]], Dict[str, Any]],
+        Tuple[str, Dict[str, Any], List[int]],
+    ]:
+        loop = asyncio.get_event_loop()
+        if file_path.suffix.lower() == ".pdf":
+            return await loop.run_in_executor(
+                self._executor, self._extract_pdf_text, file_path
+            )
+        else:
+            text = await loop.run_in_executor(
+                self._executor, self._read_text_file, file_path
+            )
+            return text, {}, []
+
+    def _extract_pdf_text(self, file_path: Path):
+        page_chunks, meta = [], {}
+        with pdfplumber.open(file_path) as pdf:
+            meta.update(
+                {
+                    "author": pdf.metadata.get("Author", ""),
+                    "title": pdf.metadata.get("Title", file_path.stem),
+                    "page_count": len(pdf.pages),
+                }
+            )
+            for i, page in enumerate(pdf.pages, start=1):
+                lines = page.extract_text_lines()
+                sorted_lines = sorted(lines, key=lambda x: x["top"])
+                txts, nums = [], []
+                for ln_idx, L in enumerate(sorted_lines, start=1):
+                    t = L.get("text", "").strip()
+                    if t:
+                        txts.append(t)
+                        nums.append(ln_idx)
+                if txts:
+                    page_chunks.append(("\n".join(txts), i, nums))
+        return page_chunks, meta
+
+    def _read_text_file(self, file_path: Path) -> str:
+        try:
+            return file_path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            return file_path.read_text(encoding="latin-1")
+
+    def _read_docx(self, path: Path) -> str:
+        doc = Document(path)
+        return "\n".join(p.text for p in doc.paragraphs if p.text.strip())
+
+    def _read_pptx(self, path: Path) -> str:
+        prs = Presentation(path)
+        slides = []
+        for slide in prs.slides:
+            chunks = [sh.text for sh in slide.shapes if hasattr(sh, "text")]
+            slides.append("\n".join(filter(None, chunks)))
+        return "\n\n".join(slides)
+
+    def _read_json(self, path: Path) -> str:
+        obj = json.loads(path.read_text(encoding="utf-8"))
+        pretty = json.dumps(obj, indent=2, ensure_ascii=False)
+        return "\n".join(textwrap.wrap(pretty, width=120))
+
+    async def _encode_chunk_async(self, chunk: str) -> np.ndarray:
+        return await asyncio.get_event_loop().run_in_executor(
+            self._executor,
+            lambda: self.embedding_model.encode(
+                [chunk],
+                convert_to_numpy=True,
+                truncate="model_max_length",
+                normalize_embeddings=True,
+                show_progress_bar=False,
+            )[0],
+        )
+
+    # ------------------------------------------------------------------ #
+    #  Text chunking helpers
+    # ------------------------------------------------------------------ #
+    def _chunk_text(self, text: str) -> List[str]:
+        sentences = re.split(r"(?<=[\.!?])\s+", text)
+        chunks, buf, length = [], [], 0
+        for sent in sentences:
+            slen = len(sent) + 1
+            if length + slen <= self.chunk_size:
+                buf.append(sent)
+                length += slen
+            else:
+                if buf:
+                    chunks.append(" ".join(buf))
+                    buf, length = [], 0
+                while len(sent) > self.chunk_size:
+                    part, sent = sent[: self.chunk_size], sent[self.chunk_size :]
+                    chunks.append(part)
+                buf, length = [sent], len(sent)
+        if buf:
+            chunks.append(" ".join(buf))
+        return chunks
+
+    def _split_oversized_chunk(self, chunk: str, tokens: List[str] = None) -> List[str]:
+        if tokens is None:
+            tokens = self.embedding_model.tokenizer.tokenize(chunk)
+        out = []
+        for i in range(0, len(tokens), self.effective_max_length):
+            seg = tokens[i : i + self.effective_max_length]
+            out.append(self.embedding_model.tokenizer.convert_tokens_to_string(seg))
+        return out

{projectdavid-1.33.12 → projectdavid-1.33.14}/src/projectdavid/clients/synchronous_inference_wrapper.py

@@ -11,9 +11,15 @@ LOG = UtilsInterface.LoggingUtility()
 
 
 class SynchronousInferenceStream:
+    # ------------------------------------------------------------ #
+    #   GLOBAL EVENT LOOP  (single hidden thread for sync wrapper)
+    # ------------------------------------------------------------ #
     _GLOBAL_LOOP = asyncio.new_event_loop()
     asyncio.set_event_loop(_GLOBAL_LOOP)
 
+    # ------------------------------------------------------------ #
+    #   Init / setup
+    # ------------------------------------------------------------ #
     def __init__(self, inference) -> None:
         self.inference_client = inference
         self.user_id: Optional[str] = None
@@ -32,6 +38,7 @@ class SynchronousInferenceStream:
         run_id: str,
         api_key: str,
     ) -> None:
+        """Populate IDs once, so callers only provide provider/model."""
         self.user_id = user_id
         self.thread_id = thread_id
         self.assistant_id = assistant_id
@@ -39,7 +46,10 @@ class SynchronousInferenceStream:
         self.run_id = run_id
         self.api_key = api_key
 
-    def stream_chunks(
+    # ------------------------------------------------------------ #
+    #   Core sync-to-async streaming wrapper
+    # ------------------------------------------------------------ #
+    def stream_chunks(  # noqa: PLR0915
         self,
         provider: str,
         model: str,
@@ -48,9 +58,15 @@ class SynchronousInferenceStream:
         timeout_per_chunk: float = 280.0,
         suppress_fc: bool = True,
     ) -> Generator[dict, None, None]:
+        """
+        Sync generator that mirrors async `inference_client.stream_inference_response`
+        but (optionally) removes raw <fc> … </fc> output *and* JSON
+        `{"type": "function_call" …}` objects from the stream.
+        """
 
         resolved_api_key = api_key or self.api_key
 
+        # ---------- async inner generator -------------------------------- #
         async def _stream_chunks_async():
             async for chk in self.inference_client.stream_inference_response(
                 provider=provider,
@@ -65,6 +81,7 @@ class SynchronousInferenceStream:
 
         agen = _stream_chunks_async().__aiter__()
 
+        # ---------- FC-suppressor plumbing -------------------------------- #
         if suppress_fc:
             _suppressor = FunctionCallSuppressor()
             _peek_gate = PeekGate(_suppressor)
@@ -72,11 +89,15 @@ class SynchronousInferenceStream:
             def _filter_text(txt: str) -> str:
                 return _peek_gate.feed(txt)
 
+            LOG.debug("[SyncStream] Function-call suppression ACTIVE")
         else:
 
             def _filter_text(txt: str) -> str:
                 return txt
 
+            LOG.debug("[SyncStream] Function-call suppression DISABLED")
+
+        # ---------- helper to flush residual buffered text ---------------- #
         def _drain_filters() -> Optional[dict]:
             if not suppress_fc:
                 return None
@@ -97,18 +118,17 @@ class SynchronousInferenceStream:
                 }
             return None
 
+        # ---------- main sync loop ---------------------------------------- #
         while True:
             try:
                 chunk = self._GLOBAL_LOOP.run_until_complete(
                     asyncio.wait_for(agen.__anext__(), timeout=timeout_per_chunk)
                 )
 
-                # Always attach run_id
+                # Always attach run_id for front-end helpers
                 chunk["run_id"] = self.run_id
 
-                # ------------------------------------------------------
-                # allow status chunks to bypass suppression suppression
-                # -------------------------------------------------------
+                # ----- bypass filters for status / code-exec related -------- #
                 if chunk.get("type") == "status":
                     yield chunk
                     continue
@@ -124,9 +144,19 @@ class SynchronousInferenceStream:
                     yield chunk
                     continue
 
+                # ----- NEW: swallow raw JSON function_call objects ---------- #
+                if suppress_fc and chunk.get("type") == "function_call":
+                    LOG.debug(
+                        "[SyncStream] Swallowing JSON function_call chunk: %s",
+                        chunk.get("name") or "<unnamed>",
+                    )
+                    continue
+
+                # ----- text-level suppression ------------------------------- #
                 if isinstance(chunk.get("content"), str):
                     chunk["content"] = _filter_text(chunk["content"])
                     if chunk["content"] == "":
+                        # Entire segment was inside <fc> … </fc>
                         continue
 
                 yield chunk
@@ -134,21 +164,26 @@ class SynchronousInferenceStream:
             except StopAsyncIteration:
                 if tail := _drain_filters():
                     yield tail
-                LOG.info("Stream completed normally.")
+                LOG.info("[SyncStream] Stream completed normally.")
                 break
 
             except asyncio.TimeoutError:
                 if tail := _drain_filters():
                     yield tail
-                LOG.error("[TimeoutError] Chunk wait expired – aborting stream.")
+                LOG.error("[SyncStream] Timeout waiting for next chunk.")
                 break
 
-            except Exception as exc:
+            except Exception as exc:  # noqa: BLE001
                 if tail := _drain_filters():
                     yield tail
-                LOG.error("Unexpected streaming error: %s", exc, exc_info=True)
+                LOG.error(
+                    "[SyncStream] Unexpected streaming error: %s", exc, exc_info=True
+                )
                 break
 
+    # ------------------------------------------------------------ #
+    #   House-keeping
+    # ------------------------------------------------------------ #
     @classmethod
     def shutdown_loop(cls) -> None:
         if cls._GLOBAL_LOOP and not cls._GLOBAL_LOOP.is_closed():

projectdavid-1.33.12/src/projectdavid/clients/file_processor.py → projectdavid-1.33.14/src/projectdavid/clients/vision-file_processor.py

@@ -21,17 +21,19 @@ import torch
 from docx import Document
 from PIL import Image
 from pptx import Presentation
-from transformers import Blip2ForConditionalGeneration, Blip2Processor
-from ultralytics import YOLO
+from projectdavid_common import UtilsInterface
+from sentence_transformers import SentenceTransformer
+
+# from transformers import Blip2ForConditionalGeneration, Blip2Processor
+
+# from ultralytics import YOLO
 
 # OCR fallback – optional
-try:
-    import pytesseract  # noqa: F401  # pylint: disable=unused-import
-except ImportError:
-    pytesseract = None
+# try:
+#    import pytesseract  # noqa: F401  # pylint: disable=unused-import
+# except ImportError:
+#    pytesseract = None
 
-from projectdavid_common import UtilsInterface
-from sentence_transformers import SentenceTransformer
 
 log = UtilsInterface.LoggingUtility()
 
@@ -81,14 +83,6 @@ class FileProcessor:
             self.device = torch.device("cpu")
             self.torch_dtype = torch.float32
 
-        # Feature flags
-        self.use_ocr = use_ocr and pytesseract is not None
-        self.use_detection = use_detection
-        if use_ocr and pytesseract is None:
-            log.warning("OCR requested but pytesseract not installed – skipping.")
-        if self.use_detection:
-            self.detector = YOLO("yolov8x.pt").to(self.device)
-
         # Text embedder
         self.embedding_model_name = "paraphrase-MiniLM-L6-v2"
         self.embedding_model = SentenceTransformer(self.embedding_model_name)
@@ -100,35 +94,13 @@ class FileProcessor:
         self.effective_max_length = self.max_seq_length - self.special_tokens_count
         self.chunk_size = min(chunk_size, self.effective_max_length * 4)
 
-        # Image embedder
-        self.clip_model, _, self.clip_preprocess = (
-            open_clip.create_model_and_transforms(
-                image_model_name,
-                pretrained="laion2b_s32b_b79k",
-                precision="fp16" if self.device.type == "cuda" else "fp32",
-            )
-        )
-        self.clip_model = self.clip_model.to(self.device).eval()
-        self.clip_tokenizer = open_clip.get_tokenizer(image_model_name)
-
-        # Caption generator
-        self.blip_processor = Blip2Processor.from_pretrained(caption_model_name)
-        self.blip_model = (
-            Blip2ForConditionalGeneration.from_pretrained(
-                caption_model_name,
-                torch_dtype=self.torch_dtype,
-            )
-            .to(self.device)
-            .eval()
-        )
-
         # Executor & logging
         self._executor = ThreadPoolExecutor(max_workers=max_workers)
         log.info(
             "FileProcessor ready (device=%s, OCR=%s, detection=%s)",
             self.device,
-            self.use_ocr,
-            self.use_detection,
+            # self.use_ocr,
+            # self.use_detection,
         )
 
     # ------------------------------------------------------------------ #
@@ -190,90 +162,6 @@ class FileProcessor:
         ftype = self._detect_file_type(path)
         return await getattr(self, f"_process_{ftype}")(path)
 
-    # ------------------------------------------------------------------ #
-    #  Image processing (OpenCLIP + BLIP-2 + OCR + YOLO)
-    # ------------------------------------------------------------------ #
-    async def _process_image(self, file_path: Path) -> Dict[str, Any]:
-        loop = asyncio.get_event_loop()
-        img = await loop.run_in_executor(self._executor, Image.open, file_path)
-
-        # 1) Image vector
-        def enc_img():
-            with torch.no_grad():
-                t = self.clip_preprocess(img).unsqueeze(0).to(self.device)
-                v = self.clip_model.encode_image(t).squeeze()
-                return (v / v.norm()).float().cpu().numpy()
-
-        image_vec = await loop.run_in_executor(self._executor, enc_img)
-
-        # 2) Caption
-        def gen_cap():
-            inp = self.blip_processor(images=img, return_tensors="pt").to(self.device)
-            with torch.no_grad():
-                ids = self.blip_model.generate(**inp, max_new_tokens=50)
-            return self.blip_processor.decode(ids[0], skip_special_tokens=True)
-
-        caption = await loop.run_in_executor(self._executor, gen_cap)
-
-        # 3) OCR
-        if self.use_ocr:
-            text = await loop.run_in_executor(
-                self._executor, pytesseract.image_to_string, img
-            )
-            if t := text.strip():
-                caption += "\n" + t
-
-        # 4) Caption vector
-        def enc_txt():
-            with torch.no_grad():
-                tok = self.clip_tokenizer(caption).unsqueeze(0).to(self.device)
-                v = self.clip_model.encode_text(tok).squeeze()
-                return (v / v.norm()).float().cpu().numpy()
-
-        caption_vec = await loop.run_in_executor(self._executor, enc_txt)
-
-        # 5) YOLO regions
-        region_vectors = []
-        if self.use_detection:
-            dets = self.detector(img)[0]
-            for box in dets.boxes:
-                x1, y1, x2, y2 = map(int, box.xyxy[0].cpu().tolist())
-                crop = img.crop((x1, y1, x2, y2))
-                vec = self.encode_image(crop)
-                region_vectors.append(
-                    {
-                        "vector": vec.tolist(),
-                        "bbox": [x1, y1, x2, y2],
-                        "label": dets.names[int(box.cls)],
-                        "conf": float(box.conf),
-                    }
-                )
-
-        # Metadata
-        sha = hashlib.sha256(file_path.read_bytes()).hexdigest()
-        w, h = img.size
-        meta = {
-            "source": str(file_path),
-            "type": "image",
-            "width": w,
-            "height": h,
-            "mime": f"image/{file_path.suffix.lstrip('.')}",
-            "sha256": sha,
-            "embedding_model": "openclip-vit-h-14",
-            "caption": caption,
-        }
-
-        result = {
-            "content": None,
-            "metadata": meta,
-            "chunks": [caption],
-            "vectors": [image_vec.tolist()],
-            "caption_vector": caption_vec.tolist(),
-        }
-        if region_vectors:
-            result["region_vectors"] = region_vectors
-        return result
-
     # ------------------------------------------------------------------ #
     #  PDF
     # ------------------------------------------------------------------ #

{projectdavid-1.33.12 → projectdavid-1.33.14/src/projectdavid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: projectdavid
-Version: 1.33.12
+Version: 1.33.14
 Summary: Python SDK for interacting with the Entities Assistant API.
 Author-email: Francis Neequaye Armah <francis.neequaye@projectdavid.co.uk>
 License: PolyForm Noncommercial License 1.0.0

{projectdavid-1.33.12 → projectdavid-1.33.14}/src/projectdavid.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ src/projectdavid/clients/tools_client.py
 src/projectdavid/clients/users_client.py
 src/projectdavid/clients/vector_store_manager.py
 src/projectdavid/clients/vectors.py
+src/projectdavid/clients/vision-file_processor.py
 src/projectdavid/constants/platform.py
 src/projectdavid/services/logging_service.py
 src/projectdavid/synthesis/__init__.py