root
/
tabby
mirror of https://gitee.com/zhang_1334717033/tabby.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: update tabby-python-client

r0.4
Meng Zhang 2023-10-18 20:50:15 -07:00
parent 5cd32eb7c0
commit aacfd35464
14 changed files with 672 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
clients/tabby-python-client/setup.py
View File

@ -7,7 +7,7 @@ long_description = (here / "README.md").read_text(encoding="utf-8")
setup(
name="tabby-python-client",
version="0.1.0",
version="0.3.0",
description="A client library for accessing Tabby Server",
long_description=long_description,
long_description_content_type="text/markdown",

2
clients/tabby-python-client/tabby_client/api/v1/health.py
View File

@ -19,7 +19,7 @@ def _get_kwargs(
cookies: Dict[str, Any] = client.get_cookies()
return {
"method": "post",
"method": "get",
"url": url,
"headers": headers,
"cookies": cookies,

16
clients/tabby-python-client/tabby_client/models/__init__.py
View File

@ -1,17 +1,33 @@
""" Contains all the data models used in inputs/outputs """
from .chat_completion_chunk import ChatCompletionChunk
from .chat_completion_request import ChatCompletionRequest
from .choice import Choice
from .completion_request import CompletionRequest
from .completion_response import CompletionResponse
from .health_state import HealthState
from .hit import Hit
from .hit_document import HitDocument
from .log_event_request import LogEventRequest
from .message import Message
from .search_response import SearchResponse
from .segments import Segments
from .snippet import Snippet
from .version import Version
__all__ = (
"ChatCompletionChunk",
"ChatCompletionRequest",
"Choice",
"CompletionRequest",
"CompletionResponse",
"HealthState",
"Hit",
"HitDocument",
"LogEventRequest",
"Message",
"SearchResponse",
"Segments",
"Snippet",
"Version",
)

57
clients/tabby-python-client/tabby_client/models/chat_completion_chunk.py Normal file
View File

@ -0,0 +1,57 @@
from typing import Any, Dict, List, Type, TypeVar
import attr
T = TypeVar("T", bound="ChatCompletionChunk")
@attr.s(auto_attribs=True)
class ChatCompletionChunk:
"""
Attributes:
content (str):
"""
content: str
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
content = self.content
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update(
{
"content": content,
}
)
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
d = src_dict.copy()
content = d.pop("content")
chat_completion_chunk = cls(
content=content,
)
chat_completion_chunk.additional_properties = d
return chat_completion_chunk
@property
def additional_keys(self) -> List[str]:
return list(self.additional_properties.keys())
def __getitem__(self, key: str) -> Any:
return self.additional_properties[key]
def __setitem__(self, key: str, value: Any) -> None:
self.additional_properties[key] = value
def __delitem__(self, key: str) -> None:
del self.additional_properties[key]
def __contains__(self, key: str) -> bool:
return key in self.additional_properties

76
clients/tabby-python-client/tabby_client/models/chat_completion_request.py Normal file
View File

@ -0,0 +1,76 @@
from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
import attr
if TYPE_CHECKING:
from ..models.message import Message
T = TypeVar("T", bound="ChatCompletionRequest")
@attr.s(auto_attribs=True)
class ChatCompletionRequest:
"""
Example:
{'messages': [{'content': 'What is tail recursion?', 'role': 'user'}, {'content': "It's a kind of optimization
in compiler?", 'role': 'assistant'}, {'content': 'Could you share more details?', 'role': 'user'}]}
Attributes:
messages (List['Message']):
"""
messages: List["Message"]
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
messages = []
for messages_item_data in self.messages:
messages_item = messages_item_data.to_dict()
messages.append(messages_item)
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update(
{
"messages": messages,
}
)
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
from ..models.message import Message
d = src_dict.copy()
messages = []
_messages = d.pop("messages")
for messages_item_data in _messages:
messages_item = Message.from_dict(messages_item_data)
messages.append(messages_item)
chat_completion_request = cls(
messages=messages,
)
chat_completion_request.additional_properties = d
return chat_completion_request
@property
def additional_keys(self) -> List[str]:
return list(self.additional_properties.keys())
def __getitem__(self, key: str) -> Any:
return self.additional_properties[key]
def __setitem__(self, key: str, value: Any) -> None:
self.additional_properties[key] = value
def __delitem__(self, key: str) -> None:
del self.additional_properties[key]
def __contains__(self, key: str) -> bool:
return key in self.additional_properties

4
clients/tabby-python-client/tabby_client/models/completion_request.py
View File

@ -23,7 +23,9 @@ class CompletionRequest:
language (Union[Unset, None, str]): Language identifier, full list is maintained at
https://code.visualstudio.com/docs/languages/identifiers Example: python.
segments (Union[Unset, None, Segments]):
user (Union[Unset, None, str]):
user (Union[Unset, None, str]): A unique identifier representing your end-user, which can help Tabby to monitor
& generating
reports.
"""
prompt: Union[Unset, None, str] = UNSET

3
clients/tabby-python-client/tabby_client/models/completion_response.py
View File

@ -12,6 +12,9 @@ T = TypeVar("T", bound="CompletionResponse")
@attr.s(auto_attribs=True)
class CompletionResponse:
"""
Example:
{'choices': [{'index': 0, 'text': 'string'}], 'id': 'string'}
Attributes:
id (str):
choices (List['Choice']):

60
clients/tabby-python-client/tabby_client/models/health_state.py
View File

@ -1,7 +1,13 @@
from typing import Any, Dict, List, Type, TypeVar
from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union, cast
import attr
from ..types import UNSET, Unset
if TYPE_CHECKING:
from ..models.version import Version
T = TypeVar("T", bound="HealthState")
@ -11,18 +17,35 @@ class HealthState:
Attributes:
model (str):
device (str):
compute_type (str):
arch (str):
cpu_info (str):
cpu_count (int):
cuda_devices (List[str]):
version (Version):
chat_model (Union[Unset, None, str]):
"""
model: str
device: str
compute_type: str
arch: str
cpu_info: str
cpu_count: int
cuda_devices: List[str]
version: "Version"
chat_model: Union[Unset, None, str] = UNSET
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
model = self.model
device = self.device
compute_type = self.compute_type
arch = self.arch
cpu_info = self.cpu_info
cpu_count = self.cpu_count
cuda_devices = self.cuda_devices
version = self.version.to_dict()
chat_model = self.chat_model
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
@ -30,25 +53,48 @@ class HealthState:
{
"model": model,
"device": device,
"compute_type": compute_type,
"arch": arch,
"cpu_info": cpu_info,
"cpu_count": cpu_count,
"cuda_devices": cuda_devices,
"version": version,
}
)
if chat_model is not UNSET:
field_dict["chat_model"] = chat_model
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
from ..models.version import Version
d = src_dict.copy()
model = d.pop("model")
device = d.pop("device")
compute_type = d.pop("compute_type")
arch = d.pop("arch")
cpu_info = d.pop("cpu_info")
cpu_count = d.pop("cpu_count")
cuda_devices = cast(List[str], d.pop("cuda_devices"))
version = Version.from_dict(d.pop("version"))
chat_model = d.pop("chat_model", UNSET)
health_state = cls(
model=model,
device=device,
compute_type=compute_type,
arch=arch,
cpu_info=cpu_info,
cpu_count=cpu_count,
cuda_devices=cuda_devices,
version=version,
chat_model=chat_model,
)
health_state.additional_properties = d

78
clients/tabby-python-client/tabby_client/models/hit.py Normal file
View File

@ -0,0 +1,78 @@
from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
import attr
if TYPE_CHECKING:
from ..models.hit_document import HitDocument
T = TypeVar("T", bound="Hit")
@attr.s(auto_attribs=True)
class Hit:
"""
Attributes:
score (float):
doc (HitDocument):
id (int):
"""
score: float
doc: "HitDocument"
id: int
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
score = self.score
doc = self.doc.to_dict()
id = self.id
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update(
{
"score": score,
"doc": doc,
"id": id,
}
)
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
from ..models.hit_document import HitDocument
d = src_dict.copy()
score = d.pop("score")
doc = HitDocument.from_dict(d.pop("doc"))
id = d.pop("id")
hit = cls(
score=score,
doc=doc,
id=id,
)
hit.additional_properties = d
return hit
@property
def additional_keys(self) -> List[str]:
return list(self.additional_properties.keys())
def __getitem__(self, key: str) -> Any:
return self.additional_properties[key]
def __setitem__(self, key: str, value: Any) -> None:
self.additional_properties[key] = value
def __delitem__(self, key: str) -> None:
del self.additional_properties[key]
def __contains__(self, key: str) -> bool:
return key in self.additional_properties

92
clients/tabby-python-client/tabby_client/models/hit_document.py Normal file
View File

@ -0,0 +1,92 @@
from typing import Any, Dict, List, Type, TypeVar
import attr
T = TypeVar("T", bound="HitDocument")
@attr.s(auto_attribs=True)
class HitDocument:
"""
Attributes:
body (str):
filepath (str):
git_url (str):
kind (str):
language (str):
name (str):
"""
body: str
filepath: str
git_url: str
kind: str
language: str
name: str
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
body = self.body
filepath = self.filepath
git_url = self.git_url
kind = self.kind
language = self.language
name = self.name
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update(
{
"body": body,
"filepath": filepath,
"git_url": git_url,
"kind": kind,
"language": language,
"name": name,
}
)
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
d = src_dict.copy()
body = d.pop("body")
filepath = d.pop("filepath")
git_url = d.pop("git_url")
kind = d.pop("kind")
language = d.pop("language")
name = d.pop("name")
hit_document = cls(
body=body,
filepath=filepath,
git_url=git_url,
kind=kind,
language=language,
name=name,
)
hit_document.additional_properties = d
return hit_document
@property
def additional_keys(self) -> List[str]:
return list(self.additional_properties.keys())
def __getitem__(self, key: str) -> Any:
return self.additional_properties[key]
def __setitem__(self, key: str, value: Any) -> None:
self.additional_properties[key] = value
def __delitem__(self, key: str) -> None:
del self.additional_properties[key]
def __contains__(self, key: str) -> bool:
return key in self.additional_properties

64
clients/tabby-python-client/tabby_client/models/message.py Normal file
View File

@ -0,0 +1,64 @@
from typing import Any, Dict, List, Type, TypeVar
import attr
T = TypeVar("T", bound="Message")
@attr.s(auto_attribs=True)
class Message:
"""
Attributes:
role (str):
content (str):
"""
role: str
content: str
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
role = self.role
content = self.content
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update(
{
"role": role,
"content": content,
}
)
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
d = src_dict.copy()
role = d.pop("role")
content = d.pop("content")
message = cls(
role=role,
content=content,
)
message.additional_properties = d
return message
@property
def additional_keys(self) -> List[str]:
return list(self.additional_properties.keys())
def __getitem__(self, key: str) -> Any:
return self.additional_properties[key]
def __setitem__(self, key: str, value: Any) -> None:
self.additional_properties[key] = value
def __delitem__(self, key: str) -> None:
del self.additional_properties[key]
def __contains__(self, key: str) -> bool:
return key in self.additional_properties

79
clients/tabby-python-client/tabby_client/models/search_response.py Normal file
View File

@ -0,0 +1,79 @@
from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
import attr
if TYPE_CHECKING:
from ..models.hit import Hit
T = TypeVar("T", bound="SearchResponse")
@attr.s(auto_attribs=True)
class SearchResponse:
"""
Attributes:
num_hits (int):
hits (List['Hit']):
"""
num_hits: int
hits: List["Hit"]
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
num_hits = self.num_hits
hits = []
for hits_item_data in self.hits:
hits_item = hits_item_data.to_dict()
hits.append(hits_item)
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update(
{
"num_hits": num_hits,
"hits": hits,
}
)
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
from ..models.hit import Hit
d = src_dict.copy()
num_hits = d.pop("num_hits")
hits = []
_hits = d.pop("hits")
for hits_item_data in _hits:
hits_item = Hit.from_dict(hits_item_data)
hits.append(hits_item)
search_response = cls(
num_hits=num_hits,
hits=hits,
)
search_response.additional_properties = d
return search_response
@property
def additional_keys(self) -> List[str]:
return list(self.additional_properties.keys())
def __getitem__(self, key: str) -> Any:
return self.additional_properties[key]
def __setitem__(self, key: str, value: Any) -> None:
self.additional_properties[key] = value
def __delitem__(self, key: str) -> None:
del self.additional_properties[key]
def __contains__(self, key: str) -> bool:
return key in self.additional_properties

71
clients/tabby-python-client/tabby_client/models/snippet.py Normal file
View File

@ -0,0 +1,71 @@
from typing import Any, Dict, List, Type, TypeVar
import attr
T = TypeVar("T", bound="Snippet")
@attr.s(auto_attribs=True)
class Snippet:
"""
Attributes:
filepath (str):
body (str):
score (float):
"""
filepath: str
body: str
score: float
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
filepath = self.filepath
body = self.body
score = self.score
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update(
{
"filepath": filepath,
"body": body,
"score": score,
}
)
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
d = src_dict.copy()
filepath = d.pop("filepath")
body = d.pop("body")
score = d.pop("score")
snippet = cls(
filepath=filepath,
body=body,
score=score,
)
snippet.additional_properties = d
return snippet
@property
def additional_keys(self) -> List[str]:
return list(self.additional_properties.keys())
def __getitem__(self, key: str) -> Any:
return self.additional_properties[key]
def __setitem__(self, key: str, value: Any) -> None:
self.additional_properties[key] = value
def __delitem__(self, key: str) -> None:
del self.additional_properties[key]
def __contains__(self, key: str) -> bool:
return key in self.additional_properties

78
clients/tabby-python-client/tabby_client/models/version.py Normal file
View File

@ -0,0 +1,78 @@
from typing import Any, Dict, List, Type, TypeVar
import attr
T = TypeVar("T", bound="Version")
@attr.s(auto_attribs=True)
class Version:
"""
Attributes:
build_date (str):
build_timestamp (str):
git_sha (str):
git_describe (str):
"""
build_date: str
build_timestamp: str
git_sha: str
git_describe: str
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
build_date = self.build_date
build_timestamp = self.build_timestamp
git_sha = self.git_sha
git_describe = self.git_describe
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update(
{
"build_date": build_date,
"build_timestamp": build_timestamp,
"git_sha": git_sha,
"git_describe": git_describe,
}
)
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
d = src_dict.copy()
build_date = d.pop("build_date")
build_timestamp = d.pop("build_timestamp")
git_sha = d.pop("git_sha")
git_describe = d.pop("git_describe")
version = cls(
build_date=build_date,
build_timestamp=build_timestamp,
git_sha=git_sha,
git_describe=git_describe,
)
version.additional_properties = d
return version
@property
def additional_keys(self) -> List[str]:
return list(self.additional_properties.keys())
def __getitem__(self, key: str) -> Any:
return self.additional_properties[key]
def __setitem__(self, key: str, value: Any) -> None:
self.additional_properties[key] = value
def __delitem__(self, key: str) -> None:
del self.additional_properties[key]
def __contains__(self, key: str) -> bool:
return key in self.additional_properties