Buckets:

download
raw
5.09 kB
import atexit
import inspect
import itertools
import os
import subprocess
import sys
import tempfile
import textwrap
from pathlib import Path
from typing import Any, cast
import httpx
from ragna.core import RagnaException
from ragna.deploy import Config
from ._utils import BackgroundSubprocess
__all__ = ["SAMPLE_CONTENT", "RagnaDeploy"]
SAMPLE_CONTENT = """\
Ragna is an open source project built by Quansight. It is designed to allow
organizations to explore the power of Retrieval-augmented generation (RAG) based
AI tools. Ragna provides an intuitive API for quick experimentation and built-in
tools for creating production-ready applications allowing you to quickly leverage
Large Language Models (LLMs) for your work.
The Ragna website is https://ragna.chat/. The source code is available at
https://github.com/Quansight/ragna under the BSD 3-Clause license.
"""
class RagnaDeploy:
def __init__(self, config: Config) -> None:
self.config = config
python_path, config_path = self._prepare_config()
self._process = self._deploy(config, config_path, python_path)
# In case the documentation errors before we call RagnaDeploy.terminate,
# we still need to stop the server to avoid zombie processes
atexit.register(self.terminate, quiet=True)
def _prepare_config(self) -> tuple[str, str]:
deploy_directory = Path(tempfile.mkdtemp())
python_path = os.pathsep.join(
[str(deploy_directory), os.environ.get("PYTHONPATH", "")]
)
config_path = str(deploy_directory / "ragna.toml")
self.config.local_root = deploy_directory
self.config.database_url = f"sqlite:///{deploy_directory / 'ragna.db'}"
sys.modules["__main__"].__file__ = inspect.getouterframes(
inspect.currentframe()
)[2].filename
custom_module = deploy_directory.name
custom_components = set()
with open(deploy_directory / f"{custom_module}.py", "w") as file:
# FIXME Find a way to automatically detect necessary imports
file.write("import uuid; from uuid import *\n")
file.write("import textwrap; from textwrap import*\n")
file.write("from typing import *\n")
file.write("from ragna import *\n")
file.write("from ragna.core import *\n")
for component in itertools.chain(
self.config.source_storages, self.config.assistants
):
if component.__module__ == "__main__":
custom_components.add(component)
file.write(f"{textwrap.dedent(inspect.getsource(component))}\n\n")
component.__module__ = custom_module
self.config.to_file(config_path)
for component in custom_components:
component.__module__ = "__main__"
return python_path, config_path
def _deploy(
self, config: Config, config_path: str, python_path: str
) -> BackgroundSubprocess:
env = os.environ.copy()
env["PYTHONPATH"] = python_path
def startup_fn() -> bool:
try:
return httpx.get(f"{config._url}/health").is_success
except httpx.ConnectError:
return False
if startup_fn():
raise RagnaException("ragna server is already running")
return BackgroundSubprocess(
sys.executable,
"-m",
"ragna",
"deploy",
"--api",
"--no-ui",
"--config",
config_path,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=env,
startup_fn=startup_fn,
startup_timeout=60,
)
def get_http_client(
self,
*,
authenticate: bool = False,
upload_sample_document: bool = False,
) -> tuple[httpx.Client, dict[str, Any] | None]:
if upload_sample_document and not authenticate:
raise RagnaException(
"Cannot upload a document without authenticating first. "
"Set authenticate=True when using upload_sample_document=True."
)
client = httpx.Client(base_url=self.config._url)
if authenticate:
client.get("/login", follow_redirects=True)
if upload_sample_document:
name, content = "ragna.txt", SAMPLE_CONTENT
response = client.post(
"/api/documents", json=[{"name": name}]
).raise_for_status()
document = cast(dict[str, Any], response.json()[0])
client.put(
"/api/documents",
files=[("documents", (document["id"], content.encode()))],
)
else:
document = None
return client, document
def terminate(self, quiet: bool = False) -> None:
if self._process is None:
return
output = self._process.terminate()
if output and not quiet:
stdout, _ = output
print(stdout)

Xet Storage Details

Size:
5.09 kB
·
Xet hash:
12a1486f90ce621b257525af7e749185b5af5cd1fa1840c2317c5700521b30b5

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.