text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>import importlib
import logging
import os
import re
from functools import lru_cache
from pathlib import Path
from typing import Any, Literal, TypeAlias, assert_never, cast
import huggingface_hub # type: ignore[import-not-found]
from huggingface_hub import HfApi, hf_hub_download # type: ignore[import-no... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import Any
from llama_index.core import get_tokenizer
from private_gpt.components.llm.tokenizers.tokenizer_base import (
AudioLike,
ImageLike,
TextLike,
TokenizedInput,
TokenizerBase,
)
class MockTokenizer(TokenizerBase):
@classmethod
def from_pretrained(cls, *a... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>find_local_model",
"find_repo_candidates",
"has_all_safetensors",
"has_tokenizer_files",
"validate_model_path",
]
<|fim_prefix|>"""Model Discovery, Cache, and Download System.
Clear separation of responsibilities:
- model_cache.py: All c<|fim_middle|>ache utilities (finding, checking, con... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> """
def decorator(func: Callable[P, T]) -> Callable[P, T]:
if not enabled:
return func
@functools.wraps(func)
async def async_wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
model_id = kwargs.get("model_id")
if not isinstance(model_id,... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> repo_id if "models--" in repo_id else "models--" + repo_id.replace("/", "--")
)
all_candidates = find_repo_candidates(base_path, hf_model_id)
for candidate in all_candidates:
if validate_model_path(candidate, tokenizer_only):
logger.debug(f"Found valid model at: {candidat... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
import asyncio
import fcntl
import json
import logging
import os
import sys
import time
from pathlib import Path
from typing import TYPE_CHECKING, Any
if TYPE_CHECKING:
from io import TextIOWrapper
from private_gpt.components.llm.tokenizers.models.model_cache impo... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
import logging
from pathlib import Path
from private_gpt.components.llm.tokenizers.models.model_cache import val<|fim_suffix|>h
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
)
logger = logging.getLogger... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Callable
from typing import Any
from private_gpt.components.llm.tokenizers.models.auto_discovery import (
auto_discover_model,
)
from private_gpt.components.llm.tokenizers.tokenizer_base import TokenizerBase
TokenizerProvider = Callable[..., TokenizerBase]
_EXTERNAL_TOKE... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|><|fim_prefix|>from collections.abc import Sequence
from typing import Any
import httpx
from private_gpt.components.llm.tokenizers.tokenizer_base import (
AudioLike,
ImageLike,
TextLike,
TokenizedInput,
TokenizerBase,
)
class RemoteTokenizeTokenizer(TokenizerBase):
"""Tokenizer ... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>rn TokenizedInput(input_ids=input_ids)
return TokenizedInput(input_ids=self._encoding.encode(str(texts)))
def get_vocab(self) -> dict[str, int]:
raise NotImplementedError(
"TikTokenTokenizer does not expose a local vocabulary"
)
def get_added_vocab(self) -> d... | fim | zylon-ai/private-gpt | python |
from abc import ABC, abstractmethod
from collections.abc import Sequence
from dataclasses import dataclass
from io import IOBase
from typing import Any
@dataclass
class TokenizedInput(list[int]):
input_ids: list[int]
def __post_init__(self) -> None:
super().__init__(self.input_ids)
TextLike = str |... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import Any
import numpy as np
from PIL import Image
from private_gpt.components.llm.tokenizers.tokenizer_base import (
AudioLike,
ImageLike,
TextLike,
)
def build_minimal_messages(
texts: TextLike | None = None,
images: ImageLike | None = None,
audios: AudioLike | N... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>se MalformedJSON(f"Failed to parse JSON: {e!s}") from e
<|fim_prefix|># SPDX-License-Identifier: Apache-2.0
import json
from json import JSONDecodeError, JSONDecoder
from typing import Any
import partial_json_parser # type: ignore
from partial_json_parser.core.exceptions import MalformedJSON # type: i... | fim | zylon-ai/private-gpt | python |
import re
from collections.abc import Callable
from concurrent.futures import ThreadPoolExecutor
from llama_index.core.utils import iter_batch
class MarkdownHelper:
@staticmethod
def _sanity_data(markdown: str) -> str:
"""Process a single chunk of markdown text."""
processed = markdown
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ral["trim", "summary"],
**kwargs: Any,
) -> "BaseMemory":
provider = _PROVIDERS.get(type)
if provider is None:
raise ValueError(f"Unknown memory type: {type}")
return provider(**kwargs)
<|fim_prefix|>from collections.abc import Callable
from typing import TY... | fim | zylon-ai/private-gpt | python |
import enum
import json
from collections.abc import Awaitable, Callable
from typing import Any, Literal
from llama_index.core.base.llms.types import ChatMessage, MessageRole
from llama_index.core.bridge.pydantic import Field, model_validator
from llama_index.core.llms.llm import LLM
from llama_index.core.memory.types ... | fim | zylon-ai/private-gpt | python |
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING
from private_gpt.components.migrations.models import AppliedMigration
if TYPE_CHECKING:
from private_gpt.components.migrations.models import Migration
class MigrationBackend(ABC):
@abstractmethod
def has_migration_table(self) -> bool:
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
from datetime import UTC, datetime
from typing import TYPE_CHECKING
from sqlalchemy import inspect as sa_inspect
from sqlalchemy import text
from private_gpt.components.migrations.backend.base import MigrationBackend
from private_gpt.components.migrations.models import AppliedMigration
i... | fim | zylon-ai/private-gpt | python |
from collections.abc import Callable
from dataclasses import dataclass
from sqlalchemy.engine import Connection
@dataclass(frozen=True)
class AppliedMigration:
version: str
description: str
checksum: str | None
@dataclass(frozen=True)
class Migration:
version: str
description: str
up: Calla... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
import threading
from private_gpt.components.migrations.backend.base import MigrationBackend
from private_gpt.components.migrations.models import Migration
logger = logging.getLogger(__name__)
class MigrationRunner:
def __init__(self, backend: MigrationBackend) -> None:
self... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>scovery helpers."""
<|fim_prefix|>"<|fim_middle|>""Shared model di<|endoftext|> | fim | zylon-ai/private-gpt | python |
from __future__ import annotations
import logging
from dataclasses import dataclass
from datetime import UTC, datetime
from typing import TYPE_CHECKING, Any
from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
import requests
from pydantic import ValidationError
from private_gpt.components.model_disco... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
from dataclasses import dataclass
from enum import StrEnum
from typing import TYPE_CHECKING, Any
if TYPE_CHECKING:
from private_gpt.chat.input_models import ModelInfoOutput
class ModelProvider(StrEnum):
OPENAI = "openai"
LLAMA_CPP = "llamacpp"
OLLAMA ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>"""Provider-s<|fim_suffix|>trategies."""
<|fim_middle|>pecific model discovery s<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>compile(
r"(^|[-_/:.\s])("
r"text[-_/.]?embedding"
r"|embeddings?"
r"|embed"
r"|nomic[-_/.]?embed"
r"|bge"
r"|e5"
r"|gte"
r"|sentence[-_/.]?transformers?"
r")($|[-_/:.\s])",
re.IGNORECASE,
)
class RegexModelClassifier:
"""Shared name-based classifier used ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
import logging
from typing import TYPE_CHECKING
from private_gpt.components.model_discovery.models import (
ClassifiedModel,
ModelClassificationResult,
ModelKind,
ModelProvider,
)
from private_gpt.components.model_discovery.providers.base import RegexMo... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> for item in extract_model_items(payload.get("data"))
if isinstance(item, dict) and isinstance(item.get("id"), str)
}
items: list[dict[str, Any]] = []
for item in extract_model_items(payload.get("models")):
if not isinstance(item, dict):
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> reasoning_options if isinstance(reasoning_options, list) else []
)
vision = capabilities.get("vision") is True
tools = capabilities.get("trained_for_tool_use") is True
thinking = any(
option in {"on", "low", "medium", "high"} for option in reasoning_opt... | fim | zylon-ai/private-gpt | python |
from __future__ import annotations
from typing import TYPE_CHECKING, Any
from private_gpt.components.model_discovery.client import model_info_from_item
from private_gpt.components.model_discovery.models import (
ClassifiedModel,
ModelClassificationResult,
ModelKind,
ModelProvider,
)
if TYPE_CHECKING:... | fim | zylon-ai/private-gpt | python |
from __future__ import annotations
from typing import TYPE_CHECKING
from private_gpt.components.model_discovery.models import (
ClassifiedModel,
ModelClassificationResult,
ModelKind,
ModelProvider,
)
from private_gpt.components.model_discovery.providers.base import RegexModelClassifier
from private_gp... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
from typing import TYPE_CHECKING, Any
from private_gpt.components.model_discovery.models import (
ClassifiedModel,
ModelClassificationResult,
ModelKind,
ModelProvider,
)
if TYPE_CHECKING:
from private_gpt.components.model_discovery.models import Un... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>f<|fim_suffix|>t(api_base=api_base, api_key=api_key, timeout=timeout)
<|fim_middle|>rom __future__ import annotations
from typing import TYPE_CHECKING
from private_gpt.components.model_discovery.client import DiscoveryHttpClient
from private_gpt.components.model_discovery.models import (
ModelDiscov... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
from typing import TYPE_CHEC<|fim_suffix|>viders.base import (
ModelDiscoveryStrategy,
OpenAICompatStrategy,
)
class StrategyChain:
def __init__(
self,
discovery_strategies: tuple[ModelDiscoveryStrategy, ...] | None = None,
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>host(value) == OPENAI_API_HOST
<|fim_prefix|>from __future__ import annotations
from urllib.parse import urlsplit, urlunsplit
OPENAI_API_HOST = "api.openai.com"
def _with_scheme(value: str) -> str:
value = value.strip()
if "://" in value:
return value
return f"https://{value}"
de... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
from typing import Any, Literal
from llama_index.core.base.llms.types import AudioBlock, TextBlock
from llama_index.core.callbacks import CallbackManager
from llama_index.core.llms import LLM, ChatMessage, MessageRole
from llama_index.core.program.utils import FlexibleModel
from llama_inde... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> + self._prompt_builder.create_image_interpretation_response(
user_query=user_query, content=final_content
)
.format()
.strip()
+ "\n\n"
)
if not response.strip():
response = IMAGE_NOT_PROCESSABLE
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> is None:
available = ", ".join(sorted(_PROVIDERS)) or "none"
raise ValueError(
f"Node store '{self._settings.node_store.index_store}' is not supported. "
f"Available: {available}"
)
return provider(self._settings, collection)
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>f raise_error:
raise ValueError(f"doc_id {doc_id} not found.")
else:
return None
return json_to_doc_tree(json)
async def aget_document(
self, doc_id: str, raise_error: bool = True
) -> BaseNode | None:
"""Get a document from the ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import sqlalchemy
from llama_index.storage.kvstore.postgres import PostgresKVStore # type: ignore
class PatchedPostgresKVStore(PostgresKVStore): # type: ignore
"""Patched PostgresKVStore that escapes the table name.
Our tables names contain "-" (they are uuids),
which are not supported by... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
import psycopg2
import sqlalchemy
from llama_index.storage.kvstore.postgres import PostgresKVStore # type: ignore
from sqlalchemy.orm import Session, sessionmaker
logger = logging.getLogger(__name__)
class PatchedPostgresKVStore(PostgresKVStore): # type: ignore
"""Patched Postgres... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>rations_table,
)
]
MIGRATIONS = [
# Initial migration
*INITIAL_MIGRATIONS,
# Skill Models
*SKILL_MIGRATIONS,
]
<|fim_prefix|>from sqlalchemy import text
from sqlalchemy.engine import Connection
from private_gpt.components.migrations.models import Migration
from private_gpt.components... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
import threading
from typing import Any
from injector import inject, singleton
from private_gpt.components.migrations.backend.base import MigrationBackend
from private_gpt.components.migrations.runner import MigrationRunner
from private_gpt.components.persistence.migrations import MIGRAT<... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from typing import Protocol
from sqlalchemy.ext.asyncio import AsyncSes<|fim_suffix|>ion]
async_session: async_sessionmaker[AsyncSession]
class SQLAlchemyRepositoryBase:
def __init__(self, persistence_component... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
import threading
from importlib.util import find_spec
from private_gpt.utils.dependencies import format_missing_dependency_message
if find_spec("psycopg2") is None or find_spec("sqlalchemy") is None:
raise ImportError(
format_missing_dependency_message(
"Postgres c... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from llama_index.core import QueryBun<|fim_suffix|>o Llama Index nodes."""
def _postprocess_nodes(
self, nodes: list[NodeWithScore], query_bundle: QueryBundle | None = None
) -> list[NodeWithScore]:
new_nodes: list[NodeWithScore] = []
for nodes_with_score in nodes:
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from llama_index.core.bridge.pydantic import Field
from llama_index.core.postprocessor.types import BaseNodePostprocessor
from llama_index.core.schema import (
MetadataMode,
NodeRelationship,
NodeWithScore,
QueryBundle,
)
from private_gpt.components.node_store.node_store_component import ... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>rmalized_right = right_candidates + [None] * (
max_length - len(right_candidates)
)
normalized_left = left_candidates + [None] * (max_length - len(left_candidates))
# Last successfully expanded nodes in each direction
right_expanded, left_expanded = current_nod... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>e(
node=child,
distance=node.distance
+ self._weighted_jump(node.node, child, "down"),
)
connected_nodes.append(child_with_distance)
return connected_nodes
def _weighted_jump(
self, from_node:... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>
new_split_indices: list[int] = split_indices.copy()
for i in split_indices:
node = sorted_nodes[i]
siblings = node.parent.children if node.parent else []
if len(siblings) > 1:
section_siblings = [n for n in siblings if self._is_split_poi... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> parent_to_children:
parent_to_children[parent_id] = []
parent_to_children[parent_id].append(node)
elif isinstance(tree_node, TableNode):
table_root_ids.add(tree_node.id_)
expanded_nodes.append(node)
if not table_roo... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
from abc import ABC
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import TYPE_CHECKING, cast
from llama_index.core.postprocessor.types import BaseNodePostprocessor
from llama_index.core.schema import (
BaseNode,
MetadataMode,
NodeWithScore,
Que... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> )
node.node.excluded_llm_metadata_keys.append("next_texts")
return nodes
<|fim_prefix|>from llama_index.core.bridge.pydantic import Field
from llama_index.core.postprocessor.types import BaseNodePostprocessor
from llama_index.core.schema import NodeWithScore, QueryBundle
fr... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
from collections.abc import Callable, Sequence
from datetime import datetime
from typing import TYPE_CHECKING, Any
import injector
from injector import singleton
from jinja2 import TemplateNotFound
from llama_index.core import BasePromptTemplate
from llama_index.core.base.llms.types import... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> template = self.env.from_string(template_str)
return RichPromptTemplate(
template=template,
template_str=template_str,
template_kwargs=template_kwargs,
)
<|fim_prefix|>from pathlib import Path
from typing import Any
from injector import singleton
fro... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>t_to_messages
from llama_index.core.llms import ChatMessage
from llama_index.core.prompts.base import BasePromptTemplate
from llama_index.core.types import BaseOutputParser
class RichPromptTemplate(BasePromptTemplate):
"""A prompt template that uses Jinja2 templates for formatting."""
kwargs: d... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>rs.registry import ReaderRegistry
__all__ = [
"ReaderComponent",
"ReaderFactory",
"ReaderFactoryRegistry",
"ReaderRegistry",
"register_reader",
]
<|fim_prefix|>from private_gpt.components.readers.factories import (
ReaderFactory,
ReaderFactoryRegistry,
register_reader,
)
f... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
from abc import abstractmethod
from collections.abc import AsyncIterable
from typing import Any
from llama_index.core import Document
from llama_index.core.readers.base import BaseReader
from llama_index.core.schema import BaseComponent, BaseNode
from pydantic import ConfigDict
from priva... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>_request_headers(self.docling_settings)
async with aiohttp.ClientSession() as session, session.get(
f"{self.base_url}/result/{task_id}", headers=headers
) as response:
response.raise_for_status()
result = await response.json()
return DoclingA... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> """Calculate processing priority based on file size and page count.
Priority levels:
- 0: High priority (small files < 1MB and <= 100 pages)
- 1: Low priority (files > 10MB or > 50 pages)
"""
file_size = len(file_bytes)
# High priority: files under 1MB
if file_size < 1_000_0... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>(f"Document conversion failed: {e}") from e
if conversion_result.status not in ["success", "partial_success"]:
raise ValueError(
f"Document conversion failed with status: {conversion_result.status}. "
f"Errors: {conversion_result.errors}"
)
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>nCountIntoNodesTransform.from_defaults()
# Be sure that references are right
yield RefreshTreeNodeTransform.from_defaults()
<|fim_prefix|>from collections.abc import Iterable
from llama_index.core.schema import TransformComponent
from private_gpt.components.ingest.transformations.combine_tree_tr... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ESSERACT[lang]
except KeyError as e:
raise ValueError(f"Language {lang} not supported by Tesseract") from e
def convert_to_rapidocr_lang(lang: str) -> str:
"""Convert language code to RapidOCR format.
Args:
lang: Language code in format like 'en-US', 'es-ES'
Returns:
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from private_gpt.com<|fim_suffix|>)
__all__ = [
"ReaderFactory",
"ReaderFactoryRegistry",
"register_reader",
]
<|fim_middle|>ponents.readers.factories.base import ReaderFactory
from private_gpt.components.readers.factories.factory import (
ReaderFactoryRegistry,
register_reader,
<|end... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> extension: str | None = None) -> IngestionReader:
pass
<|fim_prefix|>from abc import ABC, abstractmethod
from injector import Injector
from private_gpt.components.readers.base_reader import IngestionReader
from private_gpt.settings.settings import Settings
class ReaderFactory(ABC):
def __... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>Reader(
factory.settings.docling,
reader_settings=factory.settings.transformation.docling,
llm_component=llm_component,
)
_PROVIDERS: dict[str, DoclingModeProvider] = {
"api": _create_docling_api_reader,
}
def register_docling_mode(mode: str, provider: DoclingModeProvid... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Callable
from injector import Injector, inject, singleton
from private_gpt.components.readers.factories.base import ReaderFactory
from private_gpt.components.readers.factories.docling import DoclingReaderFactory
from private_gpt.components.readers.factories.markitdown import ... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ras="ingest-markitdown",
)
) from e
return MarkItDownReader()
<|fim_prefix|>from private_gpt.components.readers.base_reader import IngestionReader
from private_gpt.components.readers.factories.base import ReaderFactory
from private_gpt.utils.dependencies import format_... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>age(
"PPTX reader",
extras="ingest-documents",
)
) from e
return PPTX2MdReader(reader_settings=self.settings.transformation.pptx)
<|fim_prefix|>from private_gpt.components.readers.base_reader import IngestionReader
from private_g... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>_missing_dependency_message(
"Text reader",
)
) from e
return TextReader()
_EXTENSION_READERS = {
".csv": _delimiter_reader,
".tsv": _delimiter_reader,
".psv": _delimiter_reader,
".eml": _email_reader,
".html": _html_reader,
".htm": _html_r... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>fr<|fim_suffix|>l__ = ["MarkItDownReader"]
<|fim_middle|>om private_gpt.components.readers.markitdown.markitdown_reader import (
MarkItDownReader,
)
__al<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>markdown or result.text_content or ""
logger.debug("Finished MarkItDown conversion of file: %s", file_path)
yield Document(
text=content,
extra_info=extra_info if extra_info is not None else {},
)
<|fim_prefix|>import logging
from collections.abc import Ite... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>vate_gpt.components.readers.nodes.tree_node import TreeNode
__all__ = [
"ChunkNode",
"DiffNode",
"DocumentRootNode",
"ImageNode",
"ListItemNode",
"ListNode",
"SectionNode",
"TableNode",
"TableRowNode",
"TextNode",
"TreeNode",
]
NodeType = (
ChunkNode
|... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> converting to string.",
)
<|fim_prefix|>from pydantic import Field
from private_gpt.components.readers.nodes.text_node import TextNode
class ChunkNode(TextNode):
"""Chunk tree node."""
text_separator: str = Field(
default="",
desc<|fim_middle|>ription="Separator between te... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import Union
from llama_index.core.schema import MetadataMode
from private_gpt.components.readers.nodes.text_node import TextNode
from private_gpt.components.readers.nodes.tree_node import TreeMetadataMode, TreeNode
class DiffProcessor:
@staticmethod
def diff(
ref_text: str... | fim | zylon-ai/private-gpt | python |
import builtins
import json
from hashlib import sha256
from typing import Any, Self
from private_gpt.components.readers.nodes.partial_node import PartialNode
from private_gpt.components.readers.nodes.tree_node import TreeMetadataMode, TreeNode
class DocumentRootNode(TreeNode):
"""Root node representing the docum... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ude_children,
include_tree=include_tree,
**kwargs,
)
<|fim_prefix|>from typing import Any
from private_gpt.<|fim_middle|>components.readers.nodes import DocumentRootNode
class FragmentRootNode(DocumentRootNode):
"""A subclass of DocumentRoot representing the root of ... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> metadata mode.",
)
@classmethod
def from_node(
cls, node: TreeNode, modes: list[TreeMetadataMode] | None = None
) -> "FrozenNode":
"""Create a FrozenNode from a TreeNode."""
modes = modes or list(TreeMetadataMode)
return cls(
id_=node.id_,
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>TreeMetadataMode.RAG
):
if self.children:
child_content = self.text_seperator.join(
child.get_content(metadata_mode) for child in self.children
)
text = self.text_seperator.join(filter(None, [content, child_content]))
... | fim | zylon-ai/private-gpt | python |
from pydantic import Field
from private_gpt.components.readers.nodes.text_node import TextNode
from private_gpt.components.readers.nodes.tree_node import TreeMetadataMode, TreeNode
class ListNode(TextNode):
"""List node."""
num_items: int = Field(
default=0,
description="Number of items in t... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>...",
)
line_parts.append(f"{NodeColor.BRANCH.value}[{preview}]")
# Add node count if configured
if self.config.show_node_count:
children_count = len(node.children or [])
line_parts.append(f"{NodeColor.BRANCH.value}[{children_count} ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import builtins
from typing import Any, Self
from pydantic import Field
from private_gpt.components.readers.nodes.t<|fim_suffix|> include_parent=include_parent,
include_children=include_children,
**kwargs,
)
@classmethod
def from_dict(cls, data: builtins.dict[str... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> return None
<|fim_prefix|>from llama_index.core.schema import MetadataMode
from private_gpt.components.ingest.metadata_helper import MetadataFlags
from private_gpt.components.readers.nodes.text_node import TextNode
from private_gpt.components.readers.nodes.tree_node import TreeMetadataMode, TreeNode
c... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ismatch: {len(row)} != {len(self.df.columns)}"
)
self.df.loc[len(self.df)] = row
<|fim_prefix|>import builtins
import enum
import re
from typing import Any, Self
import numpy as np
import pandas as pd
from pydantic import BaseModel, Field
from private_gpt.components.ingest.processors... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>.RAG
):
if self.children:
child_content = self.text_separator.join(
child.get_content(metadata_mode) for child in self.children
)
text = self.text_separator.join(filter(None, [content, child_content]))
if metadata_mod... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ary for all nodes
nodes_by_id: dict[str, TreeNode] = {node.id_: node for node in nodes}
full_nodes_by_id: dict[str, TreeNode] = (
{node.id_: node for node in root_node.flatten()} if root_node else {}
)
# Group nodes by their parent_id
missing_parent_ids... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import json
from typing import Any
from llama_index.core.schema import BaseNode
from private_gpt.components.readers.nodes import DiffNode
from private_gpt.components.readers.nodes.chunk_node import ChunkNode
from private_gpt.components.readers.nodes.document_node import DocumentRootNode
from private_gpt... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>t("parent_id") == self.id_
]
for child in root_children:
self.add_child(child)
<|fim_prefix|>import base64
import pickle
from typing import Any
from private_gpt.components.readers.nodes import DocumentRootNode, TreeNode
from private_gpt.components.readers.nodes.partial_node im... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>nt, list[ZoneImageMap]] = {}
# Group zone images by slide
for zi in zone_images:
if zi.slide_index not in grouped_zone_images_by_slide:
grouped_zone_images_by_slide[zi.slide_index] = []
grouped_zone_images_by_slide[zi.slide_index].append(zi)
... | fim | zylon-ai/private-gpt | python |
import asyncio
import base64
import logging
import re
import shutil
import tempfile
import uuid
from collections.abc import AsyncIterable
from enum import Enum
from pathlib import Path
from typing import Any
from llama_index.core.ingestion import arun_transformations
from llama_index.core.schema import BaseNode, Docum... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>rkdown_normalization_transform import (
MarkdownNormalizerTransform,
)
from private_gpt.components.ingest.transformations.markdown_to_tree_transform import (
MarkdownTreeNodeParser,
)
from private_gpt.components.ingest.transformations.refresh_tree_node_transform import (
RefreshTreeNodeTransfo... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>e(self, extension: str | None) -> str | None:
return self.registry.get_reader_name(extension)
def get_reader_names(
self,
name: str | None = None,
extension: str | None = None,
) -> list[str]:
if name and name != "auto":
return [name]
r... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from injector import inject, singleton
_DEFAULT_EXTENSION_READERS: dict[str, list[str]] = {
# Binary document formats prefer the existing default readers first.
# Optional alternative readers like MarkItDown can still be tried when available.
".pdf": ["markitdown", "docling"],
".pptx": ["... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> first_chunk = False
# Convert chunk to strings and format rows
chunk_str = chunk.astype(str)
for row in chunk_str.values.tolist():
markdown_lines.append(format_row(row))
# Join all Markdown lines into a single string... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import contextlib
import datetime
import logging
import re
from collections.abc import Iterator
from email.message import Message
from email.parser import BytesParser
from email.policy import default
from email.utils import getaddresses, parsedate_to_datetime
from pathlib import Path
from typing import An... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> namespace elements and hidden content
for element in soup.find_all(
["ix:header", "ix:hidden", "ix:references", "ix:resources"]
):
element.decompose()
# Remove elements with display:none or hidden attributes
for element in soup.find_all(style=re.co... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>xcept UnicodeDecodeError:
continue # Try next encoding
async def lazy_load_data(
self,
file_info: FileInfo,
extra_info: dict[str, Any] | None = None,
execute_transformations: bool = True,
*args: Any,
**load_kwargs: Any,
) -> AsyncIt... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>dbox.sandbox_component import SandboxComponent
__all__ = [
"LocalSandboxProvider",
"LocalSandboxSession",
"SandboxCodeOptions",
"SandboxComponent",
"SandboxExecOptions",
"SandboxExecutionResult",
"SandboxProvider",
"SandboxSession",
"register_sandbox",
]
<|fim_prefix|>... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>sion."""
@abstractmethod
def exec(
self, command: str, options: SandboxExecOptions | None = None
) -> SandboxExecutionResult:
"""Execute a shell command in the sandbox."""
@abstractmethod
def run_code(
self, code: str, options: SandboxCodeOptions | None = None... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import os
import subprocess
import sys
import time
from private_gpt.components.sandbox.base import (
SandboxCodeOptions,
SandboxExecOptions,
SandboxExecutionResult,
SandboxProvider,
SandboxSession,
)
from private_gpt.settings.settings import Settings
class LocalSandboxSession(Sandbo... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>lable: {available}"
)
provider = provider_factory(self._settings)
self._providers[name] = provider
return provider
<|fim_prefix|>from private_gpt.components.sandbox.base import SandboxProvider, SandboxProviderFactory
from private_gpt.components.sandbox.local import Loca... | fim | zylon-ai/private-gpt | python |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.