text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>RUCTIONS = "RUNTIME_INSTRUCTIONS"
CONTEXT = "CONTEXT"
SKILL_CATALOG = "SKILL_CATALOG"
SKILL_BODY = "SKILL_BODY"
TOOL_INSTRUCTIONS = "TOOL_INSTRUCTIONS"
# State layers
TOOL_DEFINITIONS = "TOOL_DEFINITIONS"
DOCUMENT = "DOCUMENT"
<|fim_prefix|>from enum import StrEnum
class La... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>pt.components.context.services.context_stack_builder import (
ContextStackBuilder,
)
__all__ = ["ContextStackBuilder"]
<|fim_prefix|>"""Export context services."""
from private_<|fim_middle|>g<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>
return self
def add_document(
self,
document: Document,
source: str,
) -> "ContextStackBuilder":
"""Add a document layer after checking document budget."""
self.layers.append(DocumentLayer(document=document, source=source))
return self
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>atetime.now(UTC)
<|fim_prefix|>"""Provide context clo<|fim_middle|>ck utilities."""
from datetime import UTC, datetime
def utc_now() -> datetime:
"""Return an aware current UTC timestamp."""
return d<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>"""Serialize and deserialize tool<|fim_suffix|>compact JSON for context storage."""
payload: list[dict[str, object]] = []
for tool in tool_specs:
item: dict[str, object] = {}
for key in _TOOL_SPEC_KEYS:
value = getattr(tool, key)
if value is not None:
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> BY r.routineschema, r.routinename, p.ordinal
"""
)
functions = []
try:
self._ensure_connected()
if not self._engine:
return []
conn = self._engine.connect()
result = conn.execute(query)
curren... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import enum
from abc import abstractmethod
from sqlalchemy.engine import ObjectKind
from private_gpt.components.database.inspector_interface import (
DatabaseObjectType,
InspectedDatabaseObject,
)
SEPARATION = "\n"
SEPARATION_SECTION = "\n\n"
def _clean_types(type_str: str | None) -> str | No... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>__(self) -> str:
pass
class DatabaseObjectInspector(ABC):
_engine: Engine | None
_db_type: str
_is_readonly: bool
_connection: Connection | None = None
connection_string: str
def __init__(
self,
engine: Engine | None,
connection: Connection | None... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from sqlalchemy import text
from sqlalchemy.exc import SQLAlchemyError
from private_gpt.components.database.inspected_schema import (
InspectedProcedure,
InspectedProcedureParams,
)
from private_gpt.components.database.inspector_interface import (
DatabaseObjectInspector,
DatabaseObjectTy... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from sqlalchemy import inspect
from private_gpt.components.database.inspected_schema import InspectedTable
from private_gpt.components.database.inspector_interface import (
DatabaseObjectType,
InspectedDatabaseObject,
)
from private_gpt.components.database.table_like_inspector import (
Databa... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> conn = self._engine.connect()
meta = inspect(self._engine) # type: ignore
try:
data = meta.get_table_comment(table_name=table, schema=schema) # type: ignore
if data and isinstance(data, dict):
return data.get("text") or None
except ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from sqlalchemy import inspect
from private_gpt.components.database.inspected_schema import InspectedView
from private_gpt.components.database.inspector_interface import (
DatabaseObjectType,
InspectedDatabaseObject,
)
from private_gpt.compone<|fim_suffix|>
result.append(self._extract... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
import logging
from typing import TYPE_CHECKING, Any
from private_gpt.components.model_discovery.client import positive_int
from private_gpt.components.model_discovery.models import ModelKind
from private_gpt.components.model_discovery.service import discover_model_inf... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>egistry.get(target_model)
if not embed:
available = self.registry.get_all_aliases()
raise ValueError(
f"Embedding model '{target_model}' not found. Available: {available}"
)
return embed
def get_alias(self, model_id: str | None = No... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ngModelConfig, Settings
logger = logging.getLogger(__name__)
class EmbeddingInstance(BaseModel):
embedding: BaseEmbedding = Field(..., description="The Embedding instance")
alias: str | None = Field(None, description="Optional alias for the Embedding")
class Config:
arbitrary_types... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ilable}"
)
return self._factories[mode]
<|fim_prefix|>from collections.abc import Callable
from private_gpt.components.embedding.factories.base import EmbeddingFactory
from private_gpt.components.embedding.factories.mock import MockEmbeddingFactory
from private_gpt.components.embeddin... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from llama_index.core import MockEmbedding
from llama_index.core.base.embeddings.base import BaseEmbedding
from private_gpt.components.embedding.factories.base import EmbeddingFactory
from private_gpt.settings.settings import EmbeddingModelConfig, Settings
class MockEmbeddingFactory(EmbeddingFactory):
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>
def _create_embedding(
self, model_config: EmbeddingModelConfig
) -> tuple[BaseEmbedding, str | None]:
api_base = (
self.settings.openai.embedding_api_base or self.settings.openai.api_base
)
if is_openai_api_base(api_base):
return OpenAIGPT... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from llama_index.core.base.embeddings.base import BaseEm<|fim_suffix|> extras="embedding-openai-compatible",
)
) from e
api_base = (
self.settings.openai.embedding_api_base or self.settings.openai.api_base
)
api_key = (
... | fim | zylon-ai/private-gpt | python |
from collections.abc import Callable, Iterator
from injector import inject, singleton
from llama_index.core.base.embeddings.base import BaseEmbedding
@singleton
class EmbeddingRegistry:
"""A registry for Embedding (Large Language Model) components with alias support.
This class allows for the registration a... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>"""Implement iterative chat loop execution without workflow memory."""
import asyncio
import contextlib
import json
import logging
from collections.abc import AsyncGenerator
from contextlib import suppress
from dataclasses import dataclass, field
from enum import StrEnum
from functools import partial
fro... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>nts emitted during inference, and mutate loop context as needed."""
async def on_iteration_start(self, context: ChatLoopInterceptorContext) -> None:
"""Called once before each iteration — reset per-iteration state here."""
return
async def on_iteration_end(self, context: ChatLoop... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Callable, Mapping
from typing import Any, Self, cast
from pydantic import BaseModel, ConfigDict, Field
from private_gpt.components.engines.chat_loop.interceptors.chat_loop_interceptor import (
ChatRequestLoopInterceptor,
ChatResponseLoopInterceptor,
)
Condition = boo... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>t | None:
if self._block_id_map is None:
raise ValueError("Block ID map is not initialized. This should not happen.")
match event:
case RawContentBlockStartEvent(block_id=block_id):
if block_id in self._block_id_map:
raise ValueEr... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import datetime
from collections.abc import Mapping
from typing import<|fim_suffix|>
self, *, update: Mapping[str, Any] | None | None = None, deep: bool = False
) -> "EnsureTimestampInContentBlocksInterceptor":
# Return a new instance with the same logic but reset state
return ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from llama_index.core.base.llms.types import ChatMessage, MessageRole
from llama_index.core.llms.llm import ToolSelection
from private_gpt.components.engines.chat_loop.interceptors.chat_loop_interceptor import (
ChatRequestLoopInterceptor,
)
from private_gpt.components.engines.chat_loop.models.chat_l... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections import defaultdict, deque
from pydantic import Field
from private_gpt.components.context.models.context_stack import ContextStack
from private_gpt.components.context.models.layer_type import LayerType
from private_gpt.components.engines.chat_loop.interceptors.chat_loop_interceptor impor... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Callable
from typing import Any
from llama_index.core.llms.function_calling import FunctionCallingLLM
from pydantic import BaseModel, ConfigDict, Field
from private_gpt.<|fim_suffix|> Event
class ChatLoopInterceptorContext(BaseModel):
"""Carry state, llm runtime, and he... | fim | zylon-ai/private-gpt | python |
from enum import StrEnum
class InterceptorPhase(StrEnum):
"""Represent interceptor execution phase in the loop."""
VALIDATION = "validation"
BEFORE_ITERATION = "before_iteration"
STREAMING = "streaming"
AFTER_ITERATION = "after_iteration"
class TimelinePhase(StrEnum):
"""Represent timeline ... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ime.tokenizer_fn
context_stack = self.input.context_stack
original_input = self.original_input
self.runtime.tokenizer_fn = None
self.input.context_stack = ContextStack()
self.original_input = None
try:
copied = super().model_copy(update=update,... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>t_config_models import ToolSpec
SystemPromptFn: TypeAlias = (
Callable[..., str | None] | Callable[..., Awaitable[str | None]]
)
ToolsFn: TypeAlias = (
Callable[..., Sequence[ToolSpec]] | Callable[..., Awaitable[Sequence[ToolSpec]]]
)
<|fim_prefix|>from collections.abc import Awaitable, Callable,... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from llama_index.core.base.llms.types import ChatMessage, MessageRole, TextBlock
def latest_user_text(messages: list[ChatMessage]) -> str:
"""Return the last user text content from conversation."""
for message in reversed(messages):
if message.role != MessageRole.USER:
contin... | fim | zylon-ai/private-gpt | python |
from llama_index.core.base.llms.types import MessageRole, TextBlock
from private_gpt.components.chat.models.chat_config_models import (
ChatRequest,
ResolvedChatRequest,
)
from private_gpt.components.context.models.context_layer import (
DocumentLayer,
ToolDefinitionsLayer,
UserInstructionsLayer,
)... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
from typing import TYPE_CHECKING, Any
from llama_index.core.agent.workflow.workflow_events import ToolCallResult
from llama_index.core.base.llms.types import (
AudioBlock,
ImageBlock,
TextBlock,
)
from llama_index.core.llms import ChatMessage
from llama_index.core.tools import ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import json
from collections.abc import Callable
from typing import Any
from llama_index.core.schema import NodeWithScore
from private_gpt.components.engines.citations.types import Document
from private_gpt.components.engines.citations.utils import (
ORIGINAL_END_TOKEN,
ORIGINAL_START_TOKEN,
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ze, process and filter words
words = word_tokenize(cleaned)
words = self.process_words(words, lang=lang, **kwargs)
words = self.filter_words(words, **kwargs)
# Return unique words
return set(words)
def score_term(self, term: str, text: str) -> float:
c... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> metadata = chunk.metadata or {}
metadata.update(chunk.document.doc_metadata or {})
metadata.update(
{
MetadataNode.SCORE.value: chunk.score,
}
)
return cls(
id_=chunk.id or str(chunk.document.artifact),
... | fim | zylon-ai/private-gpt | python |
import json
import logging
import random
import re
import string
from concurrent.futures import ThreadPoolExecutor
from typing import TYPE_CHECKING, Any
from llama_index.core.base.llms.types import ChatMessage, MessageRole, TextBlock
from llama_index.core.schema import MetadataMode, NodeWithScore
from private_gpt.com... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import math
def calculate_validation_timing(
file_size: int | None,
) -> tuple[float | None, float | None]:
"""Calculate interval and jitter for file validation based on file size.
Args:
file_size: File size in bytes
Returns:
Tuple of (interval, jitter) in seconds
"... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
import logging
from collections.abc import Callable
from pathlib import Path
from typing import TYPE_CHECKING, Any
from injector import inject, singleton
from llama_index.core.indices.base import BaseIndex
from llama_index.core.schema import BaseNode
from llama_index.core.vector_stores imp... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>too many pages
try:
pages = int(file_info.config.get("pages", 0))
if pages > 0 and pages > settings().data.limits.max_file_pages:
warnings.append(IngestionValidationErrors.BIG_FILE_PAGES)
except (ValueError, TypeError):
pass # pages is n... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import enum
from llama_index.core.schema import BaseNode
class MetadataKeys(enum.StrEnum):
"""General metadata keys."""
# General
COLLECTION = "collection"
FILE_HASH = "hash"
# BE
ARTIFACT_ID = "artifact_id"
FILENAME = "file_name"
FILETYPE = "file_type"
PROJECT_ID ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
import csv
import re
from contextlib import suppress
from typing import TYPE_CHECKING, Any
import pandas as pd
if TYPE_CHECKING:
from pandas import Series
VALID_DATETIME_FORMATS = [
r"^\d{4}-\d{2}-\d{2}$", # YYYY-MM-DD
r"^\d{2}/\d{2}/\d{4}$", # MM/DD/Y... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import enum
class IngestionValidationErrors(enum.StrEnum):
# Invalid files
INVALID_FILE_SIZE = "zpgt.ingest.invalid_file_size.error"
MALFORMED_FILE = "zpgt.ingest.malformed_file.error"
# Unknown information
UNKNOWN_FILE_EXTENSION = "zpgt.ingest.invalid_file_extension.error"
MISM... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import ClassVar
from private_gpt.celery.notify import ProgressStatus, ProgressStep
class IngestionProgressSteps(ProgressStep):
"""Possible steps for the ingestion progress."""
VALIDATION = "Validation"
PARSE = "Parse"
STORAGE = "Storage"
class ValidationProgressStatus(Pro... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Sequence
from typing import Any
from llama_index.core.schema import BaseNode, TransformComponent
from private_gpt.components.readers.nodes.tree_node import TreeNode
from private_gpt.components.readers.node<|fim_suffix|>de in nodes if isinstance(tree_node, TreeNode)
]
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>.getvalue()).decode("utf-8")
<|fim_prefix|>import base64
import io
import logging
import re
from collections.abc import Sequence
from typing import Any
from llama_index.core.schema import BaseNode, MetadataMode, TransformComponent
from PIL import Image, ImageDraw
from private_gpt.settings.settings impor... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>"""Simple node parser."""
from collections.abc import Sequence
from typing im<|fim_suffix|>equence[BaseNode], show_progress: bool = False, **kwargs: Any
) -> list[BaseNode]:
def process_node(
node: TreeNode, root: TreeNode, prev_node: TreeNode | None
) -> TreeNode | None:
... | fim | zylon-ai/private-gpt | python |
import asyncio
import base64
import logging
import re
from collections.abc import Sequence
from typing import Any
from llama_index.core.base.llms.types import ImageBlock
from llama_index.core.llms import LLM
from llama_index.core.schema import BaseNode, MetadataMode, TransformComponent
from private_gpt.components.con... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
import base64
import logging
import re
from collections.abc import Sequence
from typing import Any
from llama_index.core.base.llms.types import ImageBlock
from llama_index.core.llms import LLM
from llama_index.core.schema import BaseNode, MetadataMode, TransformComponent
from private_gpt.... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>"""Simple node parser."""
from collections.abc import Sequence
from typing import TYPE_CHECKING, Any
from llama_index.core.schema import TransformComponent
from private_gpt.components.readers.nodes.tree_node import TreeNode
if TYPE_CHECKING:
from llama_index.core.schema import BaseNode
DEFAULT_WIN... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import base64
import logging
import re
from collections.abc import Sequence
from typing import Any
from llama_index.core.schema import BaseNode, MetadataMode, TransformComponent
from private_gpt.settings.settings import settings
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO if not s... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Sequence
from typing import Any
from llama_index.core.schema import BaseNode, MetadataMode, TransformComponent
from private_gpt.components.ingest.metadata_helper import MetadataNode
from private_gpt.components.llm.llm_helper import TokenizerFn
from private_gpt.components.read... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import re
from collections.abc import Sequence
from typing import Any
from llama_index.core.schema import BaseNode, Meta<|fim_suffix|>ATTERNS["list"], next_line)
)
def _is_paragraph_continuation(
self, current_lines: list[str], next_line: str
) -> bool:
last_line = curren... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import re
from collections.abc import Sequence
from typing import Any
from llama_index.core.schema import BaseNode, TransformComponent
from pydantic import Field
from private_gpt.components.ingest.metad<|fim_suffix|>hidden_regex=re.compile(hidden_regex, re.MULTILINE),
)
<|fim_middle|>ata_helper ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Sequence
from typing import Any
from llama_index.core.schema import BaseNode, TransformComponent
from private_gpt.components.ingest.metadata_helper import MetadataFlags
from private_gpt.components.readers.nodes import SectionNode, TreeNode
class MarkNoPrunableNodesTransform... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> re.match(self.PATTERNS["heading_underline_1"], next_line)
and len(next_line) > 0
):
normalized_lines.append(f"# {current_stripped}")
i += 2 # Skip the underline
continue
... | fim | zylon-ai/private-gpt | python |
from __future__ import annotations
import re
from typing import TYPE_CHECKING, Any
import pandas as pd
from bs4 import BeautifulSoup
from bs4.element import NavigableString, Tag
from llama_index.core.schema import MetadataMode, TransformComponent
from mistune import HTMLRenderer, create_markdown
from pydantic import ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Sequence
from typing import Any
from llama_index.core.schema import BaseNode, TransformComponent
from private_gpt.components.readers.nodes import DocumentRootNode
class RefreshTreeNodeTransform(TransformComponent):
"""Refresh tree node transform."""
@classmethod
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import re
from collections.abc import Sequence
from typing import Any
import numpy as np
from llama_index.core.schema import BaseNode, MetadataMode, TransformComponent
class RemoveHeaderAndFooterTransform(TransformComponent):
"""Remove headers and footers from PDF content using fuzzy matching."""
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>des: Sequence[BaseNode]
) -> Sequence[BaseNode]:
for node in nodes:
content = node.get_content(MetadataMode.NONE)
matches = list(re.finditer(self._regex, content))
for match in matches:
content = content.replace(match.group(0), IMAGE_PLACEHO... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>in text_splits
]
# Reduce the dimensions of the text_splits list
text_splits = [item for sublist in nested_texts for item in sublist]
if len(text_splits) > 1:
node.text = ""
# Create chunks for sentences/text_spl... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
import logging
import re
from collections.abc import Callable, Sequence
from typing import Any, cast
from llama_index.core.schema import BaseNode, MetadataMode, TransformComponent
from pydantic import Field
logger = logging.getLogger(__name__)
class AddTitleHeaderTransform(TransformComp... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import subprocess
from collections.abc import Callable
from pathlib import Path
from typing import Any
from pydantic import BaseModel, Field
from private_gpt.celery.notify import NotifyProtocol
from private_gpt.components.ingest.metadata_helper import MetadataKeys
class FileInfo(BaseModel):
file_n... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ations."""
<|fim_prefix|>"""L<|fim_middle|>LM implement<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>,
)
@abstractmethod
def get_metadata(self, **kwargs: Any) -> LLMMetadata | MultiModalLLMMetadata:
pass
<|fim_prefix|>from abc import ABC, abstractmethod
from typing import Any, Optional
from llama_index.core.base.llms.types import LLMMetadata
from llama_index.core.multi_modal_llms im... | fim | zylon-ai/private-gpt | python |
from collections.abc import Sequence
from typing import Any
from llama_index.core.base.llms.types import (
ChatMessage,
ChatResponse,
LLMMetadata,
MessageRole,
)
from llama_index.core.llms import MockLLM
from llama_index.core.llms.function_calling import FunctionCallingLLM
from llama_index.core.llms.ll... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
import importlib
import json
import logging
from collections.abc import Sequence
from typing import TYPE_CHECKING, Any, cast
from llama_index.core.base.llms.types import (
ChatMessage,
ChatResponse,
ChatResponseAsyncGen,
ChatResponseGen,
TextBlock,
)
from llama_index.co... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import importlib
from typing import TYPE_CHECKING, Any, cast
if TYPE_CHECKING:
from llama_index.llms.openai_like import ( # type: ignore[import-not-found,import-untyped]
OpenAILike as OpenAILikeBase,
)
from private_gpt.c<|fim_suffix|>like LLM",
extras="llm-openai-com... | fim | zylon-ai/private-gpt | python |
import importlib
from typing import TYPE_CHECKING, Any, cast
if TYPE_CHECKING:
from llama_index.llms.openai_like import ( # type: ignore[import-not-found,import-untyped]
OpenAILikeResponses as OpenAILikeResponsesBase,
)
from private_gpt.components.llm.custom.openairesponses import (
Patch... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import importlib
import logging
from collections.abc import Sequence
from typing import TYPE_CHECKING, Any, cast
from llama_index.core.base.llms.types import (
ChatMessage,
ChatResponse,
ChatResponseAsyncGen,
ChatResponseGen,
MessageRole,
ToolCallBlock,
)
from private_gpt.compone... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>a."""
return LLMMetadata(
context_window=self.context_window,
num_output=self.max_new_tokens,
model_name="Sagemaker",
)
@retry(is_async=False, tries=_MAX_RETRIES, jitter=_JITTER, logger=logger)
@llm_completion_callback()
def stream_complete(... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>eturn last_item
async def astream_structured_chat(
self,
output_cls: type[Model],
messages: Sequence[ChatMessage],
tools: Sequence[BaseTool] | None = None,
reasoning_effort: ReasoningEffort = ReasoningEffort.NONE,
**kwargs: Any,
) -> typing.AsyncGen... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>y,
messages: Sequence[ChatMessage],
tools: Sequence[BaseTool] | None = None,
reasoning_effort: ReasoningEffort = ReasoningEffort.NONE,
**kwargs: Any,
) -> AsyncGenerator[ChatResponse, None]:
# Check if reasoning_effort budget is enabled for this model
if... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>OpenAI, determine api_type per model (some models are responses-only).
# For other endpoints, probe once and apply the result to all models.
use_per_model_openai = is_openai_api_base(api_base)
probed_api_type: str | None = None
if not use_per_model_openai:
probed_api_type = _probe_... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> raise e
return None
<|fim_prefix|>import logging
from abc import ABC, abstractmethod
from typing import Any
from llama_index.core.llms import LLM
from pydantic import BaseModel, Field
from private_gpt.components.llm.prompt_helper import get_tokenizer
from private_gpt.components.... | fim | zylon-ai/private-gpt | python |
from llama_index.core.llms import LLM
from private_gpt.components.llm.factories.base import LLMFactory
from private_gpt.components.llm.tokenizers.tokenizer_base import TokenizerBase
from private_gpt.components.model_discovery.url_utils import is_openai_api_base
from private_gpt.settings.settings import LLMModelConfig,... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ef _load_patched_openai() -> type[Any]:
try:
from private_gpt.components.llm.custom.openai import PatchedOpenAILLM
return PatchedOpenAILLM
except ImportError as e:
raise ImportError(
format_missing_dependency_message(
"OpenAI LLM",
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>,
extras="llm-openai-compatible",
)
) from e
class OpenAILikeCompletionsFactory(LLMFactory):
"""Chat Completions factory for OpenAI-compatible endpoints (vLLM, Ollama, etc.)."""
def __init__(self, settings: Settings):
super().__init__(settings)
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from llama_index.core.llms import LLM
from private_gpt.components.llm.custom.mock import FunctionCallingLL<|fim_suffix|>ings import LLMModelConfig
class MockLLMFactory(LLMFactory):
def _create_llm(
self, model_config: LLMModelConfig, tokenizer: TokenizerBase | None = None
) -> tuple[LLM... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from llama_index.core.llms import LLM
from private_gpt.components.llm.factories.base import LLMFactory
from private_gpt.components.llm.tokenizers.tokenizer_base import TokenizerBase
from private_gpt.settings.settings import LLMModelConfig
class OpenAILLMFactory(LLMFactory):
"""Main OpenAI factory.
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Callable
from pri<|fim_suffix|>ider in _PROVIDERS.items()
}
def get_factory(self, mode: str) -> LLMFactory:
if mode not in self._factories:
available = ", ".join(sorted(self._factories)) or "none"
raise ValueError(
f... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> ) -> tuple[LLM, str | None]:
if is_openai_api_base(self.openai_settings.api_base):
from private_gpt.components.llm.factories.responses.openai import (
OpenAIResponsesFactory,
)
return OpenAIResponsesFactory(self.settings)._create_llm(
... | fim | zylon-ai/private-gpt | python |
from typing import cast
from llama_index.core.llms import LLM
from private_gpt.components.llm.factories.base import LLMFactory
from private_gpt.components.llm.factories.responses.generic import (
OpenAIResponsesLLMLoader,
)
from private_gpt.components.llm.tokenizers.tokenizer_base import TokenizerBase
from privat... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import Any, cast
from llama_index.core.llms import LLM
from private_gpt.components.llm.factories.base import LLMFactory
from private_gpt.components.llm.tokenizers.tokenizer_base import TokenizerBase
from private_gpt.settings.settings import LLMModelConfig, Settings
from private_gpt.utils.dep... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> raise ValueError(
f"Default model '{self._default_model_id}' not found in registered models"
)
if not self.registry.get(LLMRegistry.default()):
self.registry.register(LLMRegistry.default(), default_instance)
logge... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> texts: TextLike | None = None,
images: ImageLike | None = None,
audios: AudioLike | None = None,
**kwargs: Any,
) -> TokenizedInput:
tokens = tokenizer(texts=texts, images=images, audios=audios, **kwargs)
return tokens
return fn
def get_tokenizer() ... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>io import AioRpcError # type: ignore
from tritonclient.utils import InferenceServerException # type: ignore
return *base_exceptions, AioRpcError, InferenceServerException
except ImportError:
return base_exceptions
MODEL_NOT_AVAILABLE_EXCEPTION_TYPES = _get_exception_types(... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|># create a enum with differ<|fim_suffix|>""
class LLM:
# Default priority for LLM
DEFAULT_PRIORITY = Priority.NO_PRIORITY
# Different priorities for different use cases
CHAT_PRIORITY = Priority.REAL_TIME
SUMMARY_PRIORITY = Priority.NO_PRIORITY
REPORT_P... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>t '
"encoding and decoding.",
FutureWarning,
stacklevel=2,
)
from private_gpt.components.llm.tokenizers.registry import TokenizerRegistry
base: TokenizerBase = TokenizerRegistry.get_tokenizer(
tokenizer_mode=tokenizer_mode, model_id=model_id, *... | fim | zylon-ai/private-gpt | python |
__all__ = [
"PromptStyle",
]
<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
from collections.abc import Sequence
from typing import Any, Literal
import jinja2
from llama_index.core.base.llms.types import (
AudioBlock,
ChatMessage,
ImageBlock,
MessageRole,
)
from llama_index.core.tools import BaseTool
from private_gpt.components.llm.models import R... | fim | zylon-ai/private-gpt | python |
import logging
from abc import ABC, abstractmethod
from collections.abc import Sequence
from io import IOBase
from typing import Any, Protocol, runtime_checkable
from llama_index.core.base.llms.types import ChatMessage
from llama_index.core.tools import BaseTool
from pydantic import BaseModel, ConfigDict
from private... | fim | zylon-ai/private-gpt | python |
from collections.abc import Callable
from typing import Any
from private_gpt.components.llm.prompt_styles.prompt_style_base import PromptStyleBase
PromptStyleProvider = type[PromptStyleBase] | Callable[..., PromptStyleBase]
_EXTERNAL_PROMPT_STYLE_FACTORIES: dict[str, PromptStyleProvider] = {}
def register_prompt_s... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>e or alias of the LLM component to unregister.
"""
if name not in self._registry:
raise KeyError(f"LLM component '{name}' is not registered.")
del self._registry[name]
def get(self, name: str) -> LLMInstance | None:
"""Retrieve an LLM component by its name ... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>le_parser.last_content_delta
):
return ChatResponse(
message=ChatMessage(
role=MessageRole.ASSISTANT,
content=current_text,
),
delta=delta_text,
)
return None
<|fim_prefix|>from... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Callable
from typing <|fim_suffix|>
) -> TextParserBase | None:
factory = _EXTERNAL_TEXT_PARSER_FACTORIES.get(
prompt_style
) or _BUILTIN_TEXT_PARSER_FACTORIES.get(prompt_style)
if factory is not None:
return factory(*args, **... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>xt content from.
request: ChatCompletionRequest
The request object that was used to generate the model_output.
Returns:
str
The extracted text content.
"""
return model_output
def extract_text_content_streaming(
self,
p... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import Any
from private_gpt.components.llm.tokenizers.tiktoken import TikTokenTokenizer
from private_gpt.components.llm.tokenizers.tokenizer_base import (
AudioLike,
ImageLike,
TextLike,
TokenizedInput,
TokenizerBase,
)
class EstimatorTokenizer(TokenizerBase):
"""Tok... | fim | zylon-ai/private-gpt | python |
from pathlib import Path
from typing import Any, TypeVar, cast
from transformers import ( # type: ignore[import-not-found]
PreTrainedTokenizerBase,
ProcessorMixin,
)
from private_gpt.components.llm.tokenizers.tokenizer_base import (
AudioLike,
ImageLike,
TextLike,
TokenizedInput,
Tokenize... | 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.