bizyengine 1.2.45__py3-none-any.whl → 1.2.71__py3-none-any.whl

bizyengine/bizyair_extras/third_party_api/trd_nodes_base.py

@@ -0,0 +1,183 @@
+import abc
+import io
+import json
+import logging
+import time
+from typing import List, Tuple
+
+import requests
+import torch
+from bizyairsdk import bytesio_to_image_tensor, common_upscale
+from comfy_api.latest._input_impl import VideoFromFile
+
+from bizyengine.core import (
+    BizyAirMiscBaseNode,
+    pop_api_key_and_prompt_id,
+    register_node,
+)
+from bizyengine.core.common import client
+from bizyengine.core.common.client import send_request
+from bizyengine.core.common.env_var import BIZYAIR_X_SERVER
+from bizyengine.core.nodes_base import PREFIX
+
+from ..utils.aliyun_oss import parse_upload_token, upload_file_without_sdk
+
+
+class TrdBase(abc.ABC):
+    @abc.abstractmethod
+    # Return: data, model, prompt
+    def handle_inputs(self, headers, prompt_id, **kwargs) -> Tuple[dict, str]:
+        pass
+
+    @abc.abstractmethod
+    # Return: videos, images, texts
+    def handle_outputs(
+        self, outputs: Tuple[List[VideoFromFile], List[torch.Tensor], List[str]]
+    ) -> Tuple:
+        pass
+
+
+class BizyAirTrdApiBaseNode(BizyAirMiscBaseNode, TrdBase):
+    FUNCTION = "api_call"
+    OUTPUT_NODE = False
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        register_node(cls, PREFIX)
+
+    def api_call(self, **kwargs):
+        extra_data = pop_api_key_and_prompt_id(kwargs)
+        headers = client.headers(api_key=extra_data["api_key"])
+        prompt_id = extra_data["prompt_id"]
+        headers["X-BIZYAIR-PROMPT-ID"] = prompt_id
+
+        data, model = self.handle_inputs(headers, prompt_id, **kwargs)
+        outputs = self.create_task_and_wait_for_completion(data, model, headers)
+        return self.handle_outputs(outputs)
+
+    def create_task_and_wait_for_completion(
+        self, data, model, headers
+    ) -> Tuple[List[VideoFromFile], List[torch.Tensor], List[str]]:
+        # 创建任务
+        create_task_url = f"{BIZYAIR_X_SERVER}/trd_api/{model}"
+        json_payload = json.dumps(data).encode("utf-8")
+        logging.debug(f"json_payload: {json_payload}")
+        create_api_resp = send_request(
+            url=create_task_url,
+            data=json_payload,
+            headers=headers,
+        )
+        logging.debug(
+            f"{self.NODE_DISPLAY_NAME} create task api resp: {create_api_resp}"
+        )
+
+        # 检查任务创建是否成功
+        if "data" not in create_api_resp or "request_id" not in create_api_resp["data"]:
+            raise ValueError(f"Invalid response: {create_api_resp}")
+
+        # 轮询获取结果，最多等待1小时
+        request_id = create_api_resp["data"]["request_id"]
+        logging.info(f"{self.NODE_DISPLAY_NAME} task created, request_id: {request_id}")
+        start_time = time.time()
+        status_url = f"{BIZYAIR_X_SERVER}/trd_api/{request_id}"
+        while time.time() - start_time < 3600:
+            time.sleep(10)
+            try:
+                status_api_resp = send_request(
+                    method="GET",
+                    url=status_url,
+                    headers=headers,
+                )
+            except Exception as e:
+                logging.error(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} status api error: {e}"
+                )
+                continue
+
+            if "data" not in status_api_resp:
+                logging.error(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} status api resp no data: {status_api_resp}"
+                )
+                continue
+            if "status" not in status_api_resp["data"]:
+                logging.error(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} status api resp no status: {status_api_resp}"
+                )
+                continue
+            status = status_api_resp["data"]["status"]
+            if status == "failed":
+                raise ValueError(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} failed: {status_api_resp}"
+                )
+            if status == "running":
+                continue
+
+            # 成功，获取输出结果
+            if "outputs" not in status_api_resp["data"]:
+                raise ValueError(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} no outputs: {status_api_resp}"
+                )
+            logging.info(
+                f"{self.NODE_DISPLAY_NAME} task {request_id} success: {status_api_resp}"
+            )
+            # 分别处理视频、图片、文本
+            videos = []
+            images = []
+            texts = []
+            outputs = status_api_resp["data"]["outputs"]
+            try:
+                if "videos" in outputs:
+                    for video_url in outputs["videos"]:
+                        video_resp = requests.get(video_url, stream=True, timeout=3600)
+                        video_resp.raise_for_status()  # 非 2xx 会抛异常
+                        videos.append(VideoFromFile(io.BytesIO(video_resp.content)))
+                if "images" in outputs:
+                    for image_url in outputs["images"]:
+                        image_resp = requests.get(image_url, stream=True, timeout=3600)
+                        image_resp.raise_for_status()  # 非 2xx 会抛异常
+                        images.append(
+                            bytesio_to_image_tensor(io.BytesIO(image_resp.content))
+                        )
+                if "texts" in outputs:
+                    for text in outputs["texts"]:
+                        texts.append(text)
+            except Exception as e:
+                logging.error(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} handle outputs error: {e}"
+                )
+                raise ValueError(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} handle outputs error: {e}, please download the outputs manually, outputs: {outputs}"
+                )
+
+            return (videos, images, texts)
+
+        raise ValueError(
+            f"{self.NODE_DISPLAY_NAME} task timed out, request ID: {request_id}"
+        )
+
+    def upload_file(self, bytes, file_name, headers):
+        oss_token_url = (
+            f"{BIZYAIR_X_SERVER}/upload/token?file_name={file_name}&file_type=inputs"
+        )
+        token_resp = send_request("GET", oss_token_url, headers=headers)
+        auth_info = parse_upload_token(token_resp)
+        return upload_file_without_sdk(file_content=bytes, **auth_info)
+
+    def combine_images(self, images: List[torch.Tensor]) -> torch.Tensor:
+        s = None
+        if images is not None and len(images) > 0:
+            for _, image in enumerate(images):
+                if s is None:
+                    s = image
+                else:
+                    # ComfyUI BatchImage logic
+                    if s.shape[1:] != image.shape[1:]:
+                        image = common_upscale(
+                            image.movedim(-1, 1),
+                            s.shape[2],
+                            image.shape[1],
+                            "bilinear",
+                            "center",
+                        ).movedim(1, -1)
+                    s = torch.cat((s, image), dim=0)
+        return s

bizyengine/bizyair_extras/utils/aliyun_oss.py

@@ -0,0 +1,92 @@
+import base64
+import datetime
+import hashlib
+import hmac
+import io
+import logging
+
+import requests
+
+
+def sign_request(method, bucket, object_key, headers, access_key_id, access_key_secret):
+    # This is a simplified representation. Actual OSS signing is more complex.
+    # It involves creating a canonicalized resource and headers string.
+    # Refer to Alibaba Cloud OSS documentation for precise signing details.
+
+    canonical_string = f"{method}\n"
+    canonical_string += f"{headers.get('Content-MD5', '')}\n"
+    canonical_string += f"{headers.get('Content-Type', '')}\n"
+    canonical_string += f"{headers.get('Date', '')}\n"
+
+    # Add canonicalized OSS headers if present (e.g., x-oss-meta-*)
+    for key in sorted(headers.keys()):
+        if key.lower().startswith("x-oss-"):
+            canonical_string += f"{key.lower()}:{headers[key]}\n"
+
+    canonical_string += f"/{bucket}/{object_key}"
+
+    h = hmac.new(
+        access_key_secret.encode("utf-8"),
+        canonical_string.encode("utf-8"),
+        hashlib.sha1,
+    )
+    signature = base64.b64encode(h.digest()).decode("utf-8")
+    return f"OSS {access_key_id}:{signature}"
+
+
+def upload_file_without_sdk(
+    file_content: io.BytesIO,
+    bucket,
+    object_key,
+    endpoint,
+    access_key_id,
+    access_key_secret,
+    security_token,
+    **kwargs,
+):
+    logging.info(f"Uploading file to {bucket}.{endpoint}/{object_key}")
+    date = datetime.datetime.now(datetime.timezone.utc).strftime(
+        "%a, %d %b %Y %H:%M:%S GMT"
+    )
+
+    headers = {
+        "Host": f"{bucket}.{endpoint}",
+        "Date": date,
+        "Content-Type": "application/octet-stream",
+        "Content-Length": str(file_content.getbuffer().nbytes),
+        "x-oss-security-token": security_token,
+    }
+
+    headers["Authorization"] = sign_request(
+        "PUT", bucket, object_key, headers, access_key_id, access_key_secret
+    )
+
+    url = f"https://{bucket}.{endpoint}/{object_key}"
+
+    try:
+        response = requests.put(url, headers=headers, data=file_content)
+        response.raise_for_status()  # Raise an exception for bad status codes
+        logging.info(f"File '{object_key}' uploaded successfully.")
+        return url
+    except requests.exceptions.RequestException as e:
+        logging.error(f"Error uploading file: {e}")
+        if response is not None:
+            logging.error(f"Response content: {response.text}")
+        raise e
+
+
+def parse_upload_token(resp) -> dict:
+    logging.debug(f"parsing token resp: {resp}")
+    if "data" not in resp:
+        logging.error(f"Invalid response, data not found: {resp}")
+        raise ValueError(f"Invalid response: {resp}")
+    data = resp["data"]
+    if "file" not in data:
+        logging.error(f"Invalid response, file not found: {resp}")
+        raise ValueError(f"Invalid response: {resp}")
+    file = data["file"]
+    if "storage" not in data:
+        logging.error(f"Invalid response, storage not found: {resp}")
+        raise ValueError(f"Invalid response: {resp}")
+    storage = data["storage"]
+    return file | storage

bizyengine/bizyair_extras/utils/audio.py

@@ -0,0 +1,88 @@
+import io
+
+import av
+import torchaudio
+
+
+# Adapted from ComfyUI save_audio function
+def save_audio(
+    audio,
+    filename_prefix="ComfyUI",
+    format="flac",
+    prompt=None,
+    extra_pnginfo=None,
+    quality="128k",
+) -> io.BytesIO:
+    # Opus supported sample rates
+    OPUS_RATES = [8000, 12000, 16000, 24000, 48000]
+
+    for batch_number, waveform in enumerate(audio["waveform"].cpu()):
+        # Use original sample rate initially
+        sample_rate = audio["sample_rate"]
+
+        # Handle Opus sample rate requirements
+        if format == "opus":
+            if sample_rate > 48000:
+                sample_rate = 48000
+            elif sample_rate not in OPUS_RATES:
+                # Find the next highest supported rate
+                for rate in sorted(OPUS_RATES):
+                    if rate > sample_rate:
+                        sample_rate = rate
+                        break
+                if sample_rate not in OPUS_RATES:  # Fallback if still not supported
+                    sample_rate = 48000
+
+            # Resample if necessary
+            if sample_rate != audio["sample_rate"]:
+                waveform = torchaudio.functional.resample(
+                    waveform, audio["sample_rate"], sample_rate
+                )
+
+        # Create output with specified format
+        output_buffer = io.BytesIO()
+        output_container = av.open(output_buffer, mode="w", format=format)
+
+        # Set up the output stream with appropriate properties
+        if format == "opus":
+            out_stream = output_container.add_stream("libopus", rate=sample_rate)
+            if quality == "64k":
+                out_stream.bit_rate = 64000
+            elif quality == "96k":
+                out_stream.bit_rate = 96000
+            elif quality == "128k":
+                out_stream.bit_rate = 128000
+            elif quality == "192k":
+                out_stream.bit_rate = 192000
+            elif quality == "320k":
+                out_stream.bit_rate = 320000
+        elif format == "mp3":
+            out_stream = output_container.add_stream("libmp3lame", rate=sample_rate)
+            if quality == "V0":
+                # TODO i would really love to support V3 and V5 but there doesn't seem to be a way to set the qscale level, the property below is a bool
+                out_stream.codec_context.qscale = 1
+            elif quality == "128k":
+                out_stream.bit_rate = 128000
+            elif quality == "320k":
+                out_stream.bit_rate = 320000
+        else:  # format == "flac":
+            out_stream = output_container.add_stream("flac", rate=sample_rate)
+
+        frame = av.AudioFrame.from_ndarray(
+            waveform.movedim(0, 1).reshape(1, -1).float().numpy(),
+            format="flt",
+            layout="mono" if waveform.shape[0] == 1 else "stereo",
+        )
+        frame.sample_rate = sample_rate
+        frame.pts = 0
+        output_container.mux(out_stream.encode(frame))
+
+        # Flush encoder
+        output_container.mux(out_stream.encode(None))
+
+        # Close containers
+        output_container.close()
+
+        # Write the output to file
+        output_buffer.seek(0)
+        return output_buffer

bizyengine/bizybot/__init__.py

@@ -0,0 +1,12 @@
+"""
+MCP Coordinator - A lightweight AI application coordinator
+"""
+
+__version__ = "0.1.0"
+
+from .config import Config, LLMConfig
+
+# Import main modules to make them available
+from .coordinator import Coordinator
+
+__all__ = ["Coordinator", "Config", "LLMConfig"]