text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
# ping_event_interceptor.py
import asyncio
import contextlib
from collections.abc import AsyncGenerator
from private_gpt.events.interceptors.base_event_interceptor import BaseEventInterceptor
from private_gpt.events.models import Event, PingEvent
_DEFAULT_PING_INTERVAL = 15
class PingEventInterceptor(BaseEventInter... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from private_gpt.events.models._base import (
BaseContentBlock,
CacheableContentBlock,
CacheControlEphemeral,
ExtendedContentProtocol,
StandardContentProtocol,
serialize_datetime,
)
from private_gpt.events.models._callers import (
DirectCaller,
ServerToolCaller,
ToolCal... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> data.pop(key, None)
for key in ("start_timestamp", "stop_timestamp"):
if data.get(key) is None:
data.pop(key, None)
return data
def model_dump(self, **kwargs: Any) -> dict[str, Any]:
kwargs.setdefault("exclude_none", True)
kwargs.setdefaul... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> tool identifier.",
pattern=r"^srvtoolu_[a-zA-Z0-9_]+$",
)
type: Literal["code_execution_20260120"] = Field(
description="Caller type discriminator."
)
model_config = ConfigDict(extra="allow")
ToolCaller = Annotated[
DirectCaller | ServerToolCaller | ServerToolCaller... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
import base64
import re
from typing import TYPE_CHECKING, Annotated, Any, Literal, cast
from llama_index.core.base.llms.types import AudioBlock as LIAudioBlock
from llama_index.core.base.llms.types import ImageBlock as LIImageBlock
from llama_index.core.base.llms.types... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import Any, get_args
from llama_index.core.base.llms.types import AudioBlock as LIAudioBlock
from llama_index.core.base.llms.types import ContentBlock
from llama_index.core.base.llms.types import ImageBlock as LIImageBlock
from llama_index.core.base.llms.types import TextBlock as LITextBlock
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>SONDelta
| CitationsDelta
| ThinkingDelta
| SignatureDelta
| SourceDelta
| TLDRDelta
)
<|fim_prefix|>from typing import Any, Literal
from pydantic import Field
from private_gpt.chat.extensions.citation import ZylonCitation
from private_gpt.components.chunk.models import Chunk
from pr... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>egistry[f"{error_cls.__name__}Error"] = error_cls
registry[Errors.InternalServerError.__name__] = Errors.InternalServerError
return registry.get(name, RuntimeError)
@classmethod
def from_exception(
cls, error: BaseException, request_id: str | None = None
) -> "FatalErr... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import datetime
from typing import Annotated, Literal, Self
from uuid import uuid4
from pydantic import Field
from private_gpt.events.models._base import BaseContentBlock, StandardContentProtocol
from private_gpt.events.models._deltas import ContentBlockDeltaType
from private_gpt.events.models._errors i... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import enum
from datetime import datetime
from typing import Literal, Union
from uuid import uuid4
from pydantic import BaseModel, Field
from private_gpt.events.models._base import StandardContentProtocol
from private_gpt.events.models._tool_result_blocks import ContentBlockType
class OutputTokensDeta... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>leContentBlock,
StandardContentProtocol,
)
from private_gpt.events.models._content_blocks import ResultContentBlockType
class ToolReferenceBlock(CacheableContentBlock, StandardContentProtocol):
"""Reference to a tool name used inside tool_result payloads."""
type: Literal["tool_reference"] ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import Iterator
from private_gpt.events.models import Event
class SSEFormatter:
@staticmethod
def format_event(
event_type: str | None, data: str, include_wrap_event: bool = True
) -> str:
event_line = f"event: {event_type}\n" if event_type else ""
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> self._aqueue.task_done()
# Join threads if they exist
if self._sync_thread and self._sync_thread.is_alive():
self._sync_thread.join(timeout=1.0)
self._sync_thread = None
if self._async_thread and self._async_thread.is_alive()... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> )
def set_end_message(self, stop_reason: str = "end_turn") -> None:
self._send_event(
RawMessageDeltaEvent(
delta=MessageOutputDelta(stop_reason=stop_reason),
usage=Usage(
input_tokens=self._input_token_count
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import AsyncGenerator, AsyncIterator
from typing import Any
from private_gpt.events.models import (
ContentBlockType,
Event,
FatalError,
Message,
StopReasonEnum,
Usage,
)
from private_gpt.events.sse.sse_formatter import SSEFormatter
def to_message(
conte... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>der(payload),
)
<|fim_prefix|>import logging
from typing import Any
from fastapi import Request
from fastapi.encoders import jsonable_encoder
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.types import ASGIApp, Receive, Scope, Send
fro... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>dk.trace.export import ( # type: ignore
SimpleSpanProcessor,
)
except ImportError as e:
raise ImportError(
format_missing_dependency_message(
"Arize Phoenix",
extras="observability-arize-phoenix",
)
) from e
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> logger.debug("Initializing auxiliar services")
injector.get(PromptBuilderService)
injector.get(ToolService)
def apply_migrations(injector: Injector) -> None:
"""Ensure that all migrations are applied."""
logger.debug("Ensuring migrations are applied")
persistence_component = injecto... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>te_app
app = create_app(get_global_injector())
<|fim_prefix|>"""FastAPI app creation, logger configuration and main API routes."""
from private_gpt.di im<|fim_middle|>port get_global_injector
from private_gpt.launcher import crea<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>fr<|fim_suffix|> return (PGPT_HOME / p).resolve()
models_path: Path = PGPT_HOME / "models"
models_cache_path: Path = models_path / "cache"
docs_path: Path = PROJECT_ROOT_PATH / "docs"
local_data_path: Path = resolve_data_path(settings().data.local_data_folder)
prompt_templates_path: Path = (
Path(... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ver."""
<|fim_prefix|>"""<|fim_middle|>private-gpt ser<|endoftext|> | fim | zylon-ai/private-gpt | python |
from collections.abc import AsyncGenerator
from injector import inject, singleton
from private_gpt.components.chat.models.chat_config_models import (
ChatRequest,
)
from private_gpt.components.streaming.stream.stream_manager import StreamManager
from private_gpt.events.models import Event
from private_gpt.server.... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import Annotated, Any, ClassVar, Literal
from annotated_types import Ge, Le
from llama_index.core.base.llms.types import ChatMessage
from pydantic import ConfigDict, Field, WithJsonSchema, model_validator
from private_gpt.chat.input_models import (
CompletionMetadata,
MessageInput,
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import re
from typing import Any, Literal
from injector import inject, singleton
from pydantic import BaseModel
from private_gpt.chat.extensions.citation import ZylonCitation
from private_gpt.chat.input_models import (
ResponseFormatType,
SystemExtensions,
)
from private_gpt.chat.schema_models i... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from fastapi import APIRouter, Depends, Request, Response
from starlette.responses import StreamingResponse
from private_gpt.chat.input_models import (
CountTokensInput,
CountTokensOutput,
System,
Thinking,
ToolChoice,
)
from private_gpt.components.tools.types import ToolValidationMod... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
from collections.abc import AsyncGenerator
from typing import Any
from injector import inject, singleton
from pydantic i<|fim_suffix|> reasoning_effort=(
ReasoningEffort.from_str(request.thinking.type)
if request.thinking.enabled and request.thinking.ty... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ice=prompt_builder_service,
add_context_to_system_prompt=False,
)
],
)
# Add memory interceptor
.add_range("memory", requests=[condensation_interceptor])
# If the normal behavior is added to the sys... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>.models.layer_type import LayerType
from private_gpt.components.engines.chat_loop.interceptors.chat_loop_interceptor import (
ChatRequestLoopInterceptor,
)
from private_gpt.components.engines.chat_loop.models.chat_loop_interceptor_context import (
ChatLoopInterceptorContext,
)
from private_gpt.com... | fim | zylon-ai/private-gpt | python |
import asyncio
import contextlib
import logging
from collections.abc import AsyncIterator, Callable
from uuid import uuid4
from injector import inject, singleton
from llama_index.core.base.llms.types import ChatMessage
from pydantic import BaseModel
from private_gpt.components.chat.processors.chat_history.memory.tldr... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>chema_coercing_tool_interceptor import (
SchemaCoercingToolInterceptor,
)
@singleton
class ConfigureToolRequestInterceptor(ChatRequestLoopInterceptor):
"""Aggregate tool-configuration sub-interceptors into a single step."""
@inject
def __init__(
self,
null_tool_values_in... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
from injector import inject, singleton
from private_gpt.chat.input_models import PromptConfig
from private_gpt.components.engines.chat_loop.interceptors.chat_loop_interceptor import (
ChatRequestLoopInterceptor,
)
from private_gpt.components.engines.chat_loop.models.chat_loop_intercep... | fim | zylon-ai/private-gpt | python |
from injector import inject, singleton
from private_gpt.components.chat.processors.chat_history.documents.citations import (
process_chat_history_with_documents,
)
from private_gpt.components.engines.chat_loop.interceptors.chat_loop_interceptor import (
ChatRequestLoopInterceptor,
)
from private_gpt.components... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
from collections.abc import Mapping
from typing import TYPE_CHECKING, Any
from private_gpt.components.engines.chat_loop.interceptors.chat_loop_interceptor import (
ChatResponseLoopInterceptor,
)
from private_gpt.components.engines.chat_loop.models.chat_loop_interceptor_context import (... | fim | zylon-ai/private-gpt | python |
from collections.abc import Mapping
from typing import Any, Literal
from private_gpt.components.engines.chat_loop.interceptors.chat_loop_interceptor import (
ChatResponseLoopInterceptor,
)
from private_gpt.components.engines.chat_loop.models.chat_loop_interceptor_context import (
ChatLoopInterceptorContext,
)
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> )
state.input.context_stack = stack
context.set_state(state)
<|fim_prefix|>from injector import inject, singleton
from private_gpt.components.context.models.context_layer import (
ToolDefinitionsLayer,
)
from private_gpt.components.context.models.layer_type import LayerTyp... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
from httpx import HTTPStatusError
from injector import inject, singleton
from private_gpt.components.chat.models.chat_config_models import (
ChatRequest,
ToolSpec,
)
from private_gpt.components.context.models.context_layer import ToolDefinitionsLayer
from private_gpt.components.en... | fim | zylon-ai/private-gpt | python |
from uuid import uuid4
from injector import inject, singleton
from llama_index.core.llms import LLM
from private_gpt.components.chat.processors.chat_history.multimodality.multimodality_preprocessor import (
preprocess_multimodal_history,
)
from private_gpt.components.engines.chat_loop.interceptors.chat_loop_inter... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> async def intercept(self, context: ChatLoopInterceptorContext) -> None:
if context.phase != InterceptorPhase.BEFORE_ITERATION:
return
state = context.state
tools = [
self._patch_tool(tool) for tool in state.input.context_stack.all_tools()
]
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>tion_end(self, context: ChatLoopInterceptorContext) -> None:
if self._ping_task and not self._ping_task.done():
self._ping_task.cancel()
with contextlib.suppress(asyncio.CancelledError):
await self._ping_task
self._ping_task = None
async def int... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>_citation_guidelines_content(
self, documents: list[Document] | None = None
) -> str:
if self._citation_guidelines_content is None:
self._citation_guidelines_content = (
self._prompt_builder.create_citation_guidelines(
documents=documents... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import ast
import contextlib
import json
import logging
import math
from typing import Any
from injector import singleton
from private_gpt.components.chat.models.chat_config_models import ToolSpec
from private_gpt.components.context.models.context_layer import ToolDefinitionsLayer
from private_gpt.compo... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>)
if tool.type:
tokens.add(self._normalize_token(tool.type))
tokens.add(self._normalize_token(re.sub(r"_v\d+$", "", tool.type)))
return tokens
@staticmethod
def _normalize_token(value: str) -> str:
return value.strip().lower()
<|fim_prefix|>import r... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ontext.set_state(state)
return
active_from_tools = _resolve_active_skill_names(
state.input.request.messages,
maximum_loaded_skills=state.input.request.context.maximum_loaded_skills,
)
active_versions: list[SkillVersionEntity] = []
catal... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> SkillFilter
from private_gpt.components.skills.services.skill_service import SkillService
from private_gpt.server.utils.artifact_input import ArtifactType, SkillArtifact
@singleton
class SkillsValidationInterceptor(ChatRequestLoopInterceptor):
"""Resolve and validate skills once, then cache results... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>prompt_builder_service.create_chat_context_for_system_prompt(
documents=documents,
generate_citations=request.citation.enabled,
guidelines_prompt=None,
token_limit=context.state.runtime.effective_token_limit,
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>r(ChatRequestLoopInterceptor):
"""Filter tools and update user message hint for forced tool choice."""
async def intercept(self, context: ChatLoopInterceptorContext) -> None:
"""Apply tool choice policy to history and available tools."""
if context.phase == InterceptorPhase.BEFORE... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> async def intercept(self, context: ChatLoopInterceptorContext) -> None:
if context.phase != InterceptorPhase.VALIDATION:
return
request = context.state.input.request
model_id = request.system.model
llm = self._llm_component.get_llm(model_id)
model_c... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ator = await self._chat_async_service.get_stream_events(
message_id=message_id,
)
if event_generator is None:
raise ValueError(f"No event generator found for message_id: {message_id}")
cancellable_generator = self._cancellable_stream_generator(
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>{
"message_id": "msg_async_67890",
"status": "processing",
"created_at": "2025-07-10T09:11:16.003615Z",
"updated_at": "2025-07-10T09:11:20.123456Z",
... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> if not await self.stream_manager.stream_exists(message_id):
return None
return self.stream_manager.stream_events(
event_handler=StreamingEventHandler(), correlation_id=message_id
)
async def cancel_stream(self, message_id: str) -> bool | None:
"""Canc... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from fastapi import APIRouter, Depends, Request
from private_gpt.chat.input_models import CompletionInput, CompletionOutput
from private_gpt.server.chat.chat_request_mapper import ChatRequestMapper
from private_gpt.server.chat.chat_service import ChatService
from private_gpt.server.completion.completion_... | fim | zylon-ai/private-gpt | python |
import re
from collections.abc import Sequence
from typing import Literal
from uuid import uuid4
from injector import singleton
from private_gpt.chat.input_models import (
CompletionInput,
CompletionOutput,
MessageInput,
)
from private_gpt.events.models import TextBlock
from private_gpt.server.chat.chat_m... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import enum
from typing import Literal
from fastapi import APIRouter, Depends, Request
from pydantic import BaseModel, Field
from private_gpt.chat.extensions.context_filter import ContextFilter
from private_gpt.components.llm.llm_component import LLMComponent
from private_gpt.components.llm.llm_helper i... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ode_ids:
final_node_ids.add(root.id_)
nodes: list[BaseNode] = self.node_store_component.filtered_nodes(
context_filter.collection,
[artifact],
context_filter.metadata_filter,
node_ids=list(final_node_ids),
)
return [cast(... | fim | zylon-ai/private-gpt | python |
from typing import Literal
from fastapi import APIRouter, Depends, Request
from pydantic import BaseModel, Field
from private_gpt.server.embeddings.embeddings_service import (
Embedding,
EmbeddingsService,
)
from private_gpt.server.utils.auth import authenticated
embeddings_router = APIRouter(
prefix="/v... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>45123,
0.0167845,
-0.0098234,
0.0134567,
-0.0076543,
],
},
]
}
}
@singleton
class EmbeddingsService:
@inject
def __init__(self, embedding_co... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typin<|fim_suffix|>("/health", tags=["Health"])
async def health() -> HealthResponse:
"""Return ok if the system is up."""
return HealthResponse(status="ok")
<|fim_middle|>g import Literal
from fastapi import APIRouter
from pydantic import BaseModel, Field
# Not authentication or authorizat... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
import uuid
from pathlib import Path
from typing import TYPE_CHECKING, Annotated, Any, Literal
from fastapi import APIRouter, Body, Depends, Request
from pydantic import BaseModel, Field
from private_gpt.components.ingest.utils import get_extension, get_file_name
from private_gpt.componen... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> self.initialize_artifact_indices(
collection=collection,
artifact=artifact,
)
# Populate indexes
ingested_documents.extend(
self.populate_vector_index(
collection=collection,
... | fim | zylon-ai/private-gpt | python |
from collections.abc import Callable
from pathlib import Path
from typing import Any
from watchdog.events import (
FileCreatedEvent,
FileModifiedEvent,
FileSystemEvent,
FileSystemEventHandler,
)
from watchdog.observers import Observer
class IngestWatcher:
def __init__(
self, watch_path: P... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> artifact=str(ref_doc_info.metadata.get(MetadataKeys.ARTIFACT_ID.value)),
doc_metadata=ref_doc_info.metadata if ref_doc_info else None,
)
<|fim_prefix|>from typing import Any, Literal
from llama_index.core.schema import BaseNode
from llama_index.core.storage.docstore.types imp... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> return _load_file_from_disk(uri, **kwargs)
<|fim_prefix|>import io
from typing import Any, BinaryIO
from urllib.parse import urlparse
from private_gpt.components.storage.s3_helper import S3Helper
from private_gpt.di import get_global_injector
def _load_file_from_url(url: str, **kwargs: Any) -> Bina... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|># ruff: noqa: I001
import asyncio
import logging
from collections.abc import AsyncIterator
from contextlib import AsyncExitStack, asynccontextmanager
from typing import TYPE_CHECKING, Any
if TYPE_CHECKING:
from llama_index.core.tools import FunctionTool
class ClientSession:
...
cla... | fim | zylon-ai/private-gpt | python |
from typing import Any
from pydantic import BaseModel, Field, model_validator
class McpServerToolConfig(BaseModel):
"""Configuration for tool filtering from the MCP server."""
enabled: bool = Field(
default=True,
description="Enable tool filtering for the MCP server.",
)
allowed_too... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>return AudioBlock(audio=bytes_arr, format=block.mimeType)
return None
<|fim_prefix|>import base64
from collections.abc import Awaitable, Callable
from typing import TYPE_CHECKING, cast
from injector import singleton
from llama_index.core.base.llms.types import (
AudioBlock,
ContentBlock,
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from fastapi import APIRouter, Depends, Query,<|fim_suffix|>imit: int = Query(default=100, ge=1, le=1000),
) -> ModelListOutput:
models_service: ModelsService = request.state.injector.get(ModelsService)
return models_service.list_models(before_id, after_id, limit)
@models_router.get(
"/model... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>abilitySupportOutput(supported=True)
unsupported = CapabilitySupportOutput(supported=False)
return ModelCapabilitiesOutput(
batch=unsupported,
citations=CapabilitySupportOutput(
supported=self.settings.chat.allow_generate_citations
),
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import Annotated
from fastapi import APIRouter, Body, Depends, Request
from private_gpt.server.primitives.primitives_service import (
PrimitivesService,
SearchBody,
SearchResponse,
)
from private_gpt.server.utils.auth import authenticated
primitives_router = APIRouter(
prefi... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>pe of search operation, always 'keywords_search' for keyword searches",
)
keywords: list[str] = Field(
...,
description="List of keywords to find relevant chunks",
examples=[["sales", "Q3", "2023"]],
)
context_filter: ContextFilter = Field(
...,
desc... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>x_store(collection),
)
index = VectorStoreIndex.from_vector_store(
self.vector_store_component.vector_store(collection),
storage_context=storage_context,
llm=llm,
embed_model=self.embedding_component.get_embed(embed_model_id),
sh... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import base64
from datetime import datetime
from typing import Literal
from pydantic import BaseModel, Field, field_validator, model_validator
from private_gpt.components.skills.models.skill_entities import SkillFilter
from private_gpt.components.storage.models import StoredFile
class SkillFileInput(B... | fim | zylon-ai/private-gpt | python |
from typing import Annotated, Literal
from fastapi import APIRouter, Depends, Form, Header, HTTPException, Query, Request
from private_gpt.components.skills.models.skill_entities import (
SkillEntity,
SkillVersionEntity,
)
from private_gpt.components.skills.services.skill_service import SkillService
from priv... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ue in resolved.values():
if not value.mime_type:
mime_type, _ = (
("text/markdown", None)
if value.path.endswith(".md")
else mimetypes.guess_type(value.path)
)
value.mime_type = mime_type or default_mime_type
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import Literal
from fastapi import APIRouter, Depends, Request
from pydantic import BaseModel, Field
from private_gpt.chat.extensions.context_filter import ContextFilter
from private_gpt.events.models import ResultContentBlockType
from private_gpt.server.tools.tool_service import ToolService... | fim | zylon-ai/private-gpt | python |
import logging
from injector import inject, singleton
from llama_index.core.base.llms.types import ChatMessage
from pydantic import BaseModel
from private_gpt.chat.extensions.context_filter import ContextFilter
from private_gpt.components.tools.tool_factories import (
DatabaseQueryToolBuilderFactory,
Semantic... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> converted to binary directly")
IngestableArtifactType = Annotated[
FileArtifact | UriArtifact | TextArtifact,
Field(discriminator="type"),
]
ArtifactType = Annotated[
FileArtifact
| UriArtifact
| TextArtifact
| IngestedArtifact
| SqlDatabaseArtifact
| SkillArtifact,
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>"""Authentication mechanism for the API.
Define a simple mechanism to authenticate requests.
More complex authe<|fim_suffix|>).server.auth.secret):
# If the "Authorization" header is not the expected one, raise an exception.
raise NOT_AUTHENTICATED
return True
if not settings().serv... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>[
{
"amqp": {
"exchange": "ingest",
"routing_key_done": "ingest.done",
"routing_key_error": "ingest.error",
},
"properties": {"key": "value"},
}
],
descriptio... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>tings."""
<|fim_prefix|>"""S<|fim_middle|>et<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import inspect
import json
from typing import Annotated, Any, Literal
from pydantic import AnyUrl, BaseModel, ConfigDict, Field, field_validator
from private_gpt.settings.settings_loader import load_active_settings
class CorsSettings(BaseModel):
"""CORS configuration.
For more details on the ... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>ing environment variable for model {model_id}: {env_key}. "
f"Parameter '{key}' is already set as a scalar value."
)
current = current[key]
current[param_keys[-1]] = value
for key, value in environ.items():
if key.startswith("PGPT_MODEL... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> if env_value is not None:
break
value = env_value
default = None if len(split) == 1 else split[1]
if value is None and default is None:
raise ValueError(
f"Environment variable {env_var} is not set and not default was provided"
... | fim | zylon-ai/private-gpt | python |
"""general utils."""
<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
from collections.abc import AsyncIterator, Callable, Iterator
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
from typing import Generic, TypeVar
T = TypeVar("T")
U = TypeVar("U")
class AsyncIteratorError(Exception):
"""Custom exception for async i... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from collections.abc import (
AsyncGenerator,
AsyncIterable,
Awaitable,
Callable,
Generator,
Iterable,
)
from typing import (
Any,
TypeVar,
)
T = TypeVar("T")
def iter_batch(
iterable: Iterable[T] | Generator[T],
size: int,
stop_condition: Callable[[Any], boo... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
import logging
import random
from collections.abc import AsyncGenerator, AsyncIterable, Callable, Coroutine
from typing import Any, TypeVar
logger = logging.getLogger(__name__)
T = TypeVar("T")
R = TypeVar("R")
async def _clean_up_tasks(tasks: list[asyncio.Task[Any]]) -> None:
for t... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from typing import TypeVar
T = TypeVar("T")
K<|fim_suffix|>)
<|fim_middle|> = TypeVar("K")
V = TypeVar("V"<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import pandas as pd
def df_to_minimal_markdown(df: pd.DataFrame, allow_empty: bool = True) -> str:
# Pre-check
if df.columns.empty:
return ""
if df.empty and not allow_empty:
return ""
# Convert all data to strings
df_str = df.astype(str)
# Function to format a ... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>r_deps: bool = True,
) -> str:
message = f"{feature} dependencies are not installed."
if extras is None:
return message
command_prefix = (
"uv sync --inexact --extra" if keep_other_deps else "uv sync --extra"
)
if isinstance(extras, str):
return f"{message} I... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import datetime
import logging
import math
import time
from collections import deque
from typing import Any
logger = logging.getLogger(__name__)
def human_time(*args: Any, **kwargs: Any) -> str:
def timedelta_total_seconds(timedelta: datetime.timedelta) -> float:
return (
timede... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> return True
except ImportError:
return False
<|fim_prefix|>def is_m<|fim_middle|>agic_available() -> bool:
try:
import magic # noqa: F401
<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
import threading
from abc import ABC, abstractmethod
from collections.abc import AsyncGenerator, Generator
from contextlib import asynccontextmanager, contextmanager
from typing import Any, Generic, TypeVar
_T = TypeVar("_T", bound=Any)
class SimplePool(ABC, Generic[_T]):
"""A simple... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|>)
# Convert to bytes and modify to set the version bits to UUID v4
uuid_bytes = bytearray(name_uuid.bytes)
# Set the version bits to 4 for UUID v4
uuid_bytes[6] = (uuid_bytes[6] & 0x0F) | 0x40
# Set the variant bits to RFC 4122
uuid_bytes[8] = (uuid_bytes[8] & 0x3F) | 0x80
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import logging
from collections.abc import AsyncGenerator, Awaitable, Callable
from contextlib import asynccontextmanager
from typing import (
Any,
)
from retry_async import retry as retry_untyped # type: ignore
from retry_async.api import retry_call_async # type: ignore
retry_logger = logging.get... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
from importlib.metadata import PackageNotFoundError, version
from pathlib import Path
def get_version() -> str:
try:
return ver<|fim_suffix|>on.txt"
try:
return version_file.read_text(encoding="utf-8").strip()
except OSError as ... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>import asyncio
import functools
import logging
import time
from collections.abc import Callable, Coroutine
from typing import (
Any,
Pa<|fim_suffix|>er()
try:
result = await cast(Coroutine[Any, Any, T], func(*args, **kwargs))
return result
finally:
... | fim | zylon-ai/private-gpt | python |
def calculate_maximum_token_expansion(
token_limit: int | None,
context_window: int,
maximum_context_length: int | None = None,
) -> int:
if token_limit is None:
return context_window
elif maximum_context_length is not None and token_limit > maximum_context_length:
return maximum_con... | fim | zylon-ai/private-gpt | python |
<|fim_suffix|> if asyncio.iscoroutinefunction(tokenizer_fn):
tokens: list[int] = await tokenizer_fn(texts, images, audios)
return tokens
else:
result = await asyncio.to_thread(tokenizer_fn, texts, images, audios)
if isinstance(result, Awaitable):
result = await result
... | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>"""PrivateGP<|fim_suffix|> scripts."""
<|fim_middle|>T<|endoftext|> | fim | zylon-ai/private-gpt | python |
<|fim_prefix|>from __future__ import annotations
import argparse
from pathlib import Path
from typing import TYPE_CHECKING, Any
import yaml
from private_gpt.components.embedding.discovery import get_embedding_models
from private_gpt.components.llm.discovery import get_models
from private_gpt.components.model_discove... | 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.