dify-oapi2 0.1.0__py3-none-any.whl

dify_oapi/core/http/transport/sync_transport.py

@@ -0,0 +1,220 @@
+import json
+import os
+import time
+from collections.abc import Generator
+from typing import Literal, overload
+
+import httpx
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.json import JSON
+from dify_oapi.core.log import logger
+from dify_oapi.core.model.base_request import BaseRequest
+from dify_oapi.core.model.base_response import BaseResponse
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.raw_response import RawResponse
+from dify_oapi.core.model.request_option import RequestOption
+from dify_oapi.core.type import T
+
+from ._misc import _build_header, _build_url, _get_sleep_time, _merge_dicts, _unmarshaller
+
+
+def _format_log_details(
+    method: str, url: str, headers: dict, queries: list[tuple[str, str]] | dict, body_data: dict | None
+) -> str:
+    """Format log details"""
+    details = [f"{method} {url}"]
+    if headers:
+        details.append(f"headers: {JSON.marshal(headers)}")
+    if queries:
+        queries_dict = dict(queries) if isinstance(queries, list) else queries
+        details.append(f"params: {JSON.marshal(queries_dict)}")
+    if body_data:
+        details.append(f"body: {JSON.marshal(body_data)}")
+    return ", ".join(details)
+
+
+def _handle_stream_error(response: httpx.Response) -> bytes:
+    """Handle streaming response errors"""
+    try:
+        error_detail = response.read()
+        error_message = error_detail.decode("utf-8", errors="ignore").strip()
+    except Exception:
+        error_message = f"Error response with status code {response.status_code}"
+    logger.warning(f"Streaming request failed: {response.status_code}, detail: {error_message}")
+    return f"data: [ERROR] {error_message}\n\n".encode()
+
+
+def _stream_generator(
+    conf: Config,
+    req: BaseRequest,
+    *,
+    url: str,
+    headers: dict[str, str],
+    json_: dict | None,
+    data: dict | None,
+    files: dict | None,
+    http_method: HttpMethod,
+) -> Generator[bytes, None, None]:
+    method_name = http_method.name
+    body_data = _merge_dicts(json_, files, data)
+
+    for retry in range(conf.max_retry_count + 1):
+        if retry > 0:
+            sleep_time = _get_sleep_time(retry)
+            logger.info(f"in-request: sleep {sleep_time}s")
+            time.sleep(sleep_time)
+
+        try:
+            with (
+                httpx.Client() as client,
+                client.stream(
+                    method_name,
+                    url,
+                    headers=headers,
+                    params=tuple(req.queries),
+                    json=json_,
+                    data=data,
+                    files=files,
+                    timeout=conf.timeout,
+                ) as response,
+            ):
+                logger.debug(
+                    f"{_format_log_details(method_name, url, headers, req.queries, body_data)}, stream response"
+                )
+
+                if response.status_code != 200:
+                    yield _handle_stream_error(response)
+                    return
+
+                try:
+                    yield from response.iter_bytes()
+                except Exception as e:
+                    logger.exception("Streaming failed during chunk reading")
+                    yield f"data: [ERROR] Stream interrupted: {str(e)}\n\n".encode()
+                return
+
+        except httpx.RequestError as e:
+            err_msg = f"{e.__class__.__name__}: {e!r}"
+            log_details = _format_log_details(method_name, url, headers, req.queries, body_data)
+
+            if retry < conf.max_retry_count:
+                logger.info(f"in-request: retrying ({retry + 1}/{conf.max_retry_count}) {log_details}, exp: {err_msg}")
+                continue
+            logger.info(
+                f"in-request: request failed, retried ({retry}/{conf.max_retry_count}) {log_details}, exp: {err_msg}"
+            )
+            raise
+
+
+class Transport:
+    @staticmethod
+    @overload
+    def execute(
+        conf: Config,
+        req: BaseRequest,
+        *,
+        stream: Literal[True],
+        option: RequestOption | None,
+    ) -> Generator[bytes, None, None]: ...
+
+    @staticmethod
+    @overload
+    def execute(conf: Config, req: BaseRequest) -> BaseResponse: ...
+
+    @staticmethod
+    @overload
+    def execute(conf: Config, req: BaseRequest, *, option: RequestOption | None) -> BaseResponse: ...
+
+    @staticmethod
+    @overload
+    def execute(
+        conf: Config,
+        req: BaseRequest,
+        *,
+        unmarshal_as: type[T],
+        option: RequestOption | None,
+    ) -> T: ...
+
+    @staticmethod
+    def execute(
+        conf: Config,
+        req: BaseRequest,
+        *,
+        stream: bool = False,
+        unmarshal_as: type[T] | type[BaseResponse] | None = None,
+        option: RequestOption | None = None,
+    ):
+        unmarshal_as = unmarshal_as or BaseResponse
+        option = option or RequestOption()
+
+        if req.http_method is None:
+            raise RuntimeError("HTTP method is required")
+
+        url = _build_url(conf.domain, req.uri, req.paths)
+        headers = _build_header(req, option)
+
+        # Prepare request body
+        json_, files, data = None, None, None
+        if req.files:
+            files = req.files
+            if req.body is not None:
+                data = json.loads(JSON.marshal(req.body))
+        elif req.body is not None:
+            json_ = json.loads(JSON.marshal(req.body))
+
+        if stream:
+            return _stream_generator(
+                conf, req, url=url, headers=headers, json_=json_, data=data, files=files, http_method=req.http_method
+            )
+
+        # Set local proxy
+        original_no_proxy = os.environ.get("NO_PROXY", "")
+        if "localhost" not in original_no_proxy:
+            os.environ["NO_PROXY"] = f"{original_no_proxy},localhost,127.0.0.1".strip(",")
+
+        method_name = req.http_method.name
+        body_data = _merge_dicts(json_, files, data)
+
+        with httpx.Client() as client:
+            for retry in range(conf.max_retry_count + 1):
+                if retry > 0:
+                    sleep_time = _get_sleep_time(retry)
+                    logger.info(f"in-request: sleep {sleep_time}s")
+                    time.sleep(sleep_time)
+
+                try:
+                    response = client.request(
+                        method_name,
+                        url,
+                        headers=headers,
+                        params=tuple(req.queries),
+                        json=json_,
+                        data=data,
+                        files=files,
+                        timeout=conf.timeout,
+                    )
+                    break
+                except httpx.RequestError as e:
+                    err_msg = f"{e.__class__.__name__}: {e!r}"
+                    log_details = _format_log_details(method_name, url, headers, req.queries, body_data)
+
+                    if retry < conf.max_retry_count:
+                        logger.info(
+                            f"in-request: retrying ({retry + 1}/{conf.max_retry_count}) {log_details}, exp: {err_msg}"
+                        )
+                        continue
+                    logger.info(
+                        f"in-request: request failed, retried ({retry}/{conf.max_retry_count}) {log_details}, exp: {err_msg}"
+                    )
+                    raise
+
+            logger.debug(
+                f"{_format_log_details(method_name, url, headers, req.queries, body_data)} {response.status_code}"
+            )
+
+            raw_resp = RawResponse()
+            raw_resp.status_code = response.status_code
+            raw_resp.headers = dict(response.headers)
+            raw_resp.content = response.content
+            return _unmarshaller(raw_resp, unmarshal_as)

dify_oapi/core/json.py

@@ -0,0 +1,61 @@
+import copy
+import datetime
+import io
+from json import JSONEncoder, dumps, loads
+from typing import Any, overload
+
+from .const import UTF_8
+from .type import T
+
+
+class JSON:
+    @staticmethod
+    @overload
+    def marshal(obj: None, indent=None) -> None:
+        pass
+
+    @staticmethod
+    @overload
+    def marshal(obj: Any, indent=None) -> str:
+        pass
+
+    @staticmethod
+    def marshal(obj: Any, indent=None) -> str | None:
+        if obj is None:
+            return None
+        return dumps(obj, cls=Encoder, indent=indent, ensure_ascii=False)
+
+    @staticmethod
+    def unmarshal(json_str: str, clazz: type[T]) -> T:
+        dict_obj = loads(json_str)
+        return clazz(**dict_obj)
+
+
+class Encoder(JSONEncoder):
+    def default(self, o: Any) -> Any:
+        if isinstance(o, io.BufferedReader):
+            return o.__str__()
+        if hasattr(o, "__dict__"):
+            return filter_null(copy.deepcopy(vars(o)))
+        if isinstance(o, datetime.datetime):
+            return o.strftime("%Y-%m-%d %H:%M:%S")
+        if isinstance(o, bytes):
+            return str(o, encoding=UTF_8)
+        if isinstance(o, int):
+            return int(o)
+        if isinstance(o, float):
+            return float(o)
+        if isinstance(o, set):
+            return list(o)
+        return super().default(o)
+
+
+def filter_null(d: dict) -> dict:
+    if isinstance(d, dict):
+        for k, v in list(d.items()):
+            if isinstance(v, dict):
+                filter_null(v)
+            elif v is None:
+                del d[k]
+
+    return d

dify_oapi/core/log.py

@@ -0,0 +1,8 @@
+import logging
+import sys
+
+logger = logging.getLogger("Dify")
+handler = logging.StreamHandler(sys.stdout)
+handler.setFormatter(logging.Formatter("[Dify] [%(asctime)s] [%(levelname)s] %(message)s"))
+logger.addHandler(handler)
+logger.setLevel(logging.WARNING)

dify_oapi/core/misc.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=False)
+class HiddenText(str):
+    secret: str
+    redacted: str
+
+    def __new__(cls, secret: str, redacted: str):
+        obj = super().__new__(cls, redacted)
+        return obj
+
+    @property
+    def __dict__(self):  # type: ignore[override]
+        return self.__repr__()
+
+    def __repr__(self) -> str:
+        return f"<HiddenText {str(self)!r}>"
+
+    def __str__(self) -> str:
+        return self.redacted
+
+    # This is useful for testing.
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, type(self)):
+            return False
+
+        # The string being used for redaction doesn't also have to match,
+        # just the raw, original string.
+        return self.secret == other.secret
+
+    def encode(self, encoding="utf-8", errors="strict"):
+        # Needed for building as bytes for httpx request
+        # Encode into bytes for transmission over the network.
+        return self.secret.encode(encoding, errors)
+
+
+# if __name__ == '__main__':
+#     ht = HiddenText("secret", "****")
+#     print(vars(ht), "\n", ht)

dify_oapi/core/model/base_request.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+from dify_oapi.core.enum import HttpMethod
+
+
+class BaseRequest:
+    def __init__(self) -> None:
+        self.http_method: HttpMethod | None = None
+        self.uri: str | None = None
+        self.paths: dict[str, str] = {}
+        self.queries: list[tuple[str, str]] = []
+        self.headers: dict[str, str] = {}
+        self.body: dict = {}
+        self.files: dict | None = None
+
+    def add_query(self, k: str, v: Any) -> None:
+        if isinstance(v, list | tuple):
+            for i in v:
+                self.queries.append((k, str(i)))
+        else:
+            self.queries.append((k, str(v)))

dify_oapi/core/model/base_response.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel, Field
+
+from .raw_response import RawResponse
+
+
+class BaseResponse(BaseModel):
+    raw: RawResponse | None = None
+    code: str | None = Field(default=None, exclude=True)
+    msg_: str | None = Field(default=None, validation_alias="msg", exclude=True)
+    message_: str | None = Field(default=None, validation_alias="message", exclude=True)
+
+    @property
+    def msg(self) -> str | None:
+        if self.msg_ is not None:
+            return self.msg_
+
+        if self.message_ is not None:
+            return self.message_
+
+        if self.raw is not None and self.raw.content is not None:
+            return self.raw.content.decode("utf-8")
+
+        return None
+
+    @property
+    def success(self) -> bool:
+        return self.code is None

dify_oapi/core/model/config.py

@@ -0,0 +1,9 @@
+from dify_oapi.core.enum import LogLevel
+
+
+class Config:
+    def __init__(self):
+        self.domain: str | None = None
+        self.timeout: float | None = None  # Client timeout in seconds, default is no timeout
+        self.log_level: LogLevel = LogLevel.WARNING  # Log level, default is WARNING
+        self.max_retry_count: int = 3  # Maximum retry count after request failure. Default is 3

dify_oapi/core/model/raw_request.py

@@ -0,0 +1,5 @@
+class RawRequest:
+    def __init__(self):
+        self.uri: str | None = None
+        self.headers: dict[str, str] = {}
+        self.body: bytes | None = None

dify_oapi/core/model/raw_response.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel, Field
+
+from dify_oapi.core.const import CONTENT_TYPE
+
+
+class RawResponse(BaseModel):
+    status_code: int | None = None
+    headers: dict[str, str] = Field(default_factory=dict)
+    content: bytes | None = None
+
+    def set_content_type(self, content_type: str) -> None:
+        self.headers[CONTENT_TYPE] = content_type
+
+    @property
+    def content_type(self) -> str | None:
+        content_type = self.headers.get(CONTENT_TYPE) or self.headers.get(CONTENT_TYPE.lower())
+        return content_type

dify_oapi/core/model/request_option.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+
+class RequestOption:
+    def __init__(self):
+        self.api_key: str | None = None
+        self.headers: dict[str, str] = {}
+
+    @staticmethod
+    def builder() -> RequestOptionBuilder:
+        return RequestOptionBuilder()
+
+
+class RequestOptionBuilder:
+    def __init__(self) -> None:
+        self._request_option: RequestOption = RequestOption()
+
+    def api_key(self, api_key: str) -> RequestOptionBuilder:
+        self._request_option.api_key = api_key
+        return self
+
+    def headers(self, headers: dict[str, str]) -> RequestOptionBuilder:
+        self._request_option.headers = headers
+        return self
+
+    def build(self) -> RequestOption:
+        return self._request_option

dify_oapi/core/type.py

@@ -0,0 +1,5 @@
+from typing import TypeVar
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+T = TypeVar("T", bound=BaseResponse)

dify_oapi/core/utils/strings.py

@@ -0,0 +1,8 @@
+class Strings:
+    @staticmethod
+    def is_not_empty(s: str | None) -> bool:
+        return not Strings.is_empty(s)
+
+    @staticmethod
+    def is_empty(s: str | None) -> bool:
+        return s is None or len(s) == 0

dify_oapi2-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 LangGenius
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.