update

Dockerfile

@@ -5,6 +5,7 @@ RUN apt update && apt-get install -y python3 python3-dev python3-pip
 RUN python3 -m pip install fastapi pydantic loguru --break-system-packages
 RUN python3 -m pip install requests python-multipart --break-system-packages
 RUN python3 -m pip install uvicorn --break-system-packages
+RUN python3 -m pip install tenacity --break-system-packages
 
 # 为了让user用户可以访问/root目录
 RUN useradd -m -u 1000 user

docker_as_a_service/docker_as_a_service.py

@@ -51,14 +51,19 @@ async def stream_generator(request_obj):
         # Get list of existing files before download
         existing_file_before_download = []
 
-        video_id = request_obj.client_command
-        cmd = [
-            '/root/.dotnet/tools/BBDown',
-            video_id,
-            '--use-app-api',
-            '--work-dir', 
-            f'{os.path.abspath(temp_dir)}'
-        ]
+        if request_obj.endpoint == "down_bilibili":
+            video_id = request_obj.client_command
+            cmd = [
+                '/root/.dotnet/tools/BBDown',
+                video_id,
+                '--use-app-api',
+                '--work-dir', 
+                f'{os.path.abspath(temp_dir)}'
+            ]
+        else:
+            assert False, "Invalid endpoint"
+
+
         cmd = ' '.join(cmd)
         yield yield_message(cmd)
         process = subprocess.Popen(cmd,
@@ -125,6 +130,12 @@ async def stream_generator(request_obj):
         yield python_obj_to_pickle_file_bytes(dsacm)
 
 
+def simple_generator(return_obj):
+    dsacm = DockerServiceApiComModel(
+        server_message=return_obj,
+    )
+    yield python_obj_to_pickle_file_bytes(dsacm)
+
 @app.post("/stream")
 async def stream_response(file: UploadFile = File(...)):
     # read the file in memory, treat it as pickle file, and unpickle it
@@ -134,12 +145,46 @@ async def stream_response(file: UploadFile = File(...)):
     with io.BytesIO(content) as f:
         request_obj = pickle.load(f)
     # process the request_obj
+    request_obj.endpoint = "down_bilibili"
     return StreamingResponse(stream_generator(request_obj), media_type="application/octet-stream")
 
+@app.post("/search")
+async def stream_response(file: UploadFile = File(...)):
+    # read the file in memory, treat it as pickle file, and unpickle it
+    import pickle
+    import io
+    content = await file.read()
+    with io.BytesIO(content) as f:
+        request_obj = pickle.load(f)
+
+    # process the request_obj
+    keyword = request_obj.client_command
+
+    from experimental_mods.get_search_kw_api_stop import search_videos
+    # Default parameters for video search
+    csrf_token = '40a227fcf12c380d7d3c81af2cd8c5e8'  # Using default from main()
+    search_type = 'default'
+    max_pages = 1
+    output_path = 'search_results'
+    config_path = 'experimental_mods/config.json'
+
+    # Search for videos and return the first result
+    videos = search_videos(
+        keyword=keyword,
+        csrf_token=csrf_token,
+        search_type=search_type,
+        max_pages=max_pages,
+        output_path=output_path,
+        config_path=config_path,
+        early_stop=True
+    )
+
+    return StreamingResponse(simple_generator(videos), media_type="application/octet-stream")
+
 @app.get("/")
 async def hi():
     return "Hello, this is Docker as a Service (DaaS)!"
-    
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=49000)

docker_as_a_service/experimental_mods/config.json

@@ -0,0 +1,6 @@
+{
+  "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36",
+  "cookie": "buvid3=902A16D7-B19F-790B-FF85-197C38F3227462114infoc; b_nut=1731952262; b_lsid=10DF102ED6_19340664283; _uuid=84EEC61010-CE55-DAC4-68C10-CFA6108F89C8963816infoc; buvid_fp=b2f71cc1058da966a62a2caf13596b1f; buvid4=0C27B28C-406E-B88B-D232-51167891712B62902-024111817-wg%2Bfug1OO8Jl5lXoeCp0dw%3D%3D; enable_web_push=DISABLE; home_feed_column=4; browser_resolution=1313-699; bili_ticket=eyJhbGciOiJIUzI1NiIsImtpZCI6InMwMyIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MzIyMTE0NjMsImlhdCI6MTczMTk1MjIwMywicGx0IjotMX0.xKiEBdcpGFZy7Qv2wCExcBoRK-LGtvv_wvmCbuDoCN8; bili_ticket_expires=1732211403; CURRENT_FNVAL=4048; sid=5h1fpj7o; rpdid=|(k|kmJk)Y|u0J'u~JumlkkY)"
+}
+
+

docker_as_a_service/experimental_mods/docker_as_a_service.py

@@ -0,0 +1,151 @@
+"""
+DaaS (Docker as a Service) is a service 
+that allows users to run docker commands on the server side.
+"""
+
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from pydantic import BaseModel, Field
+from typing import Optional, Dict
+import time
+import os
+import asyncio
+import subprocess
+import uuid
+import threading
+import queue
+
+app = FastAPI()
+
+class DockerServiceApiComModel(BaseModel):
+    client_command: Optional[str] = Field(default=None, title="Client command", description="The command to be executed on the client side")
+    client_file_attach: Optional[dict] = Field(default=None, title="Client file attach", description="The file to be attached to the client side")
+    server_message: Optional[str] = Field(default=None, title="Server standard error", description="The standard error from the server side")
+    server_std_err: Optional[str] = Field(default=None, title="Server standard error", description="The standard error from the server side")
+    server_std_out: Optional[str] = Field(default=None, title="Server standard output", description="The standard output from the server side")
+    server_file_attach: Optional[dict] = Field(default=None, title="Server file attach", description="The file to be attached to the server side")
+
+
+def python_obj_to_pickle_file_bytes(obj):
+    import pickle
+    import io
+    with io.BytesIO() as f:
+        pickle.dump(obj, f)
+        return f.getvalue()
+
+def yield_message(message):
+    dsacm = DockerServiceApiComModel(server_message=message)
+    return python_obj_to_pickle_file_bytes(dsacm)
+
+def read_output(stream, output_queue):
+    while True:
+        line_stdout = stream.readline()
+        print('recv')
+        if line_stdout:
+            output_queue.put(line_stdout)
+        else:
+            break
+
+
+async def stream_generator(request_obj):
+    import tempfile
+    # Create a temporary directory
+    with tempfile.TemporaryDirectory() as temp_dir:
+
+        # Construct the docker command
+        download_folder = temp_dir
+
+        # Get list of existing files before download
+        existing_file_before_download = []
+
+        video_id = request_obj.client_command
+        cmd = [
+            # 'docker', 'run', '--rm',
+            # '-v', f'{download_folder}:/downloads',
+            # 'bbdown',
+            # video_id,
+            # '--use-app-api',
+            # '--work-dir', '/downloads'
+            "while true; do date; sleep 1; done"
+        ]
+        cmd = ' '.join(cmd)
+        yield yield_message(cmd)
+        process = subprocess.Popen(cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    shell=True,
+                    text=True)
+
+        stdout_queue = queue.Queue()
+        thread = threading.Thread(target=read_output, args=(process.stdout, stdout_queue))
+        thread.daemon = True
+        thread.start()
+        stderr_queue = queue.Queue()
+        thread = threading.Thread(target=read_output, args=(process.stderr, stderr_queue))
+        thread.daemon = True
+        thread.start()
+
+        while True:
+            print("looping")
+            # Check if there is any output in the queue
+            try:
+                output_stdout = stdout_queue.get_nowait()  # Non-blocking get
+                if output_stdout:
+                    print(output_stdout)
+                    yield yield_message(output_stdout)
+
+                output_stderr = stderr_queue.get_nowait()  # Non-blocking get
+                if output_stderr:
+                    print(output_stdout)
+                    yield yield_message(output_stderr)
+            except queue.Empty:
+                pass  # No output available
+
+            # Break the loop if the process has finished
+            if process.poll() is not None:
+                break
+            
+            await asyncio.sleep(0.25)
+
+        # Get the return code
+        return_code = process.returncode
+        yield yield_message("(return code:) " + str(return_code))
+
+        # print(f"Successfully downloaded video {video_id}")
+        existing_file_after_download = list(os.listdir(download_folder))
+        # get the difference
+        downloaded_files = [
+            f for f in existing_file_after_download if f not in existing_file_before_download
+        ]
+        downloaded_files_path = [
+            os.path.join(download_folder, f) for f in existing_file_after_download if f not in existing_file_before_download
+        ]
+        # read file 
+        server_file_attach = {}
+        for fp, fn in zip(downloaded_files_path, downloaded_files):
+            with open(fp, "rb") as f:
+                file_bytes = f.read()
+                server_file_attach[fn] = file_bytes
+
+        dsacm = DockerServiceApiComModel(
+            server_message="complete",
+            server_file_attach=server_file_attach,
+        )
+        yield python_obj_to_pickle_file_bytes(dsacm)
+
+
+@app.post("/stream")
+async def stream_response(file: UploadFile = File(...)):
+    # read the file in memory, treat it as pickle file, and unpickle it
+    import pickle
+    import io
+    content = await file.read()
+    with io.BytesIO(content) as f:
+        request_obj = pickle.load(f)
+    # process the request_obj
+    return StreamingResponse(stream_generator(request_obj), media_type="application/octet-stream")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=48000)

docker_as_a_service/experimental_mods/docker_to_api copy.py

@@ -0,0 +1,97 @@
+import os
+import pickle
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import StreamingResponse
+from io import BytesIO
+import subprocess
+
+app = FastAPI()
+
+@app.post("/container_task")
+async def container_task(file: UploadFile = File(...)):
+    # Save the uploaded file to disk
+    input_filepath = "input.pkl"
+    with open(input_filepath, "wb") as f:
+        f.write(await file.read())
+
+    # Process the unpickle_param from the file
+    try:
+        with open(input_filepath, 'rb') as f:
+            unpickle_param = pickle.load(f)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to unpickle the input file: {str(e)}")
+
+    # Execute the Docker command
+    command = ["docker", "run", "--rm", "bbdown", str(unpickle_param)]
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    # Stream the output of the command
+    stdout_stream = BytesIO()
+    stderr_stream = BytesIO()
+
+    # Create a generator to stream output
+    def stream_output():
+        while True:
+            output = process.stdout.readline()
+            if output == b"" and process.poll() is not None:
+                break
+            if output:
+                stdout_stream.write(output)
+
+        stderr_output = process.stderr.read()
+        stderr_stream.write(stderr_output)
+        yield ""
+
+    # Return the StreamingResponse for the current output
+    async def response_stream():
+        for _ in stream_output():
+            yield stdout_stream.getvalue()
+            stdout_stream.seek(0)  # Rewind for next read
+            stdout_stream.truncate()  # Clear for next fill
+
+    # Run the process and wait for completion
+    process.wait()
+
+    # Check for errors
+    if process.returncode != 0:
+        raise HTTPException(status_code=500, detail=f"Docker command failed with error: {stderr_stream.getvalue().decode()}")
+
+    # Create a new pickle file as output
+    output_filepath = "output.pkl"
+    with open(output_filepath, 'wb') as f:
+        f.write(b"Your output data here.")  # Replace this with actual output data
+
+    # Return the output file
+    return StreamingResponse(open(output_filepath, "rb"), media_type='application/octet-stream',
+                             headers={"Content-Disposition": f"attachment; filename={os.path.basename(output_filepath)}"})
+
+# To run the application, use: uvicorn your_file_name:app --reload
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+import time
+import asyncio
+
+app = FastAPI()
+
+async def stream_generator():
+    for i in range(10):
+        yield f"Data chunk {i}\n"
+        await asyncio.sleep(1)  # Simulating some delay
+
+@app.get("/stream")
+async def stream_response():
+    return StreamingResponse(stream_generator(), media_type="text/plain")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=8000)
+
+
+def client_call(*args, **kwargs):
+
+    result = execute(*args, **kwargs)
+
+    result.text
+    result.file_manifest
+    result.files
+

docker_as_a_service/experimental_mods/get_bilibili_resource copy.py

@@ -0,0 +1,37 @@
+from toolbox import update_ui, get_conf, promote_file_to_downloadzone, update_ui_lastest_msg, generate_file_link
+
+
+def download_bilibili(video_id, only_audio, user_name, chatbot, history):
+    # run : docker run --rm -v $(pwd)/downloads:/downloads bbdown BV1LSSHYXEtv --use-app-api --work-dir /downloads
+    import os
+    import subprocess
+    from toolbox import get_log_folder
+
+    download_folder_rel = get_log_folder(user=user_name, plugin_name="shared")
+    download_folder = os.path.abspath(download_folder_rel)
+
+    # Get list of existing files before download
+    existing_file_before_download = list(os.listdir(download_folder))
+
+    # Construct the docker command
+    cmd = [
+        'docker', 'run', '--rm',
+        '-v', f'{download_folder}:/downloads',
+        'bbdown',
+        video_id,
+        '--use-app-api',
+        '--work-dir', '/downloads'
+    ]
+    if only_audio:
+        cmd.append('--audio-only')
+
+
+    # Execute the command
+    result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+    # print(f"Successfully downloaded video {video_id}")
+    existing_file_after_download = list(os.listdir(download_folder))
+    # get the difference
+    downloaded_files = [os.path.join(download_folder_rel, f) for f in existing_file_after_download if f not in existing_file_before_download]
+
+    return downloaded_files
+

docker_as_a_service/experimental_mods/get_bilibili_resource.py

@@ -0,0 +1,34 @@
+from toolbox import update_ui, get_conf, promote_file_to_downloadzone, update_ui_lastest_msg, generate_file_link
+from shared_utils.docker_as_service_api import stream_daas
+from shared_utils.docker_as_service_api import DockerServiceApiComModel
+
+def download_bilibili(video_id, only_audio, user_name, chatbot, history):
+    # run : docker run --rm -v $(pwd)/downloads:/downloads bbdown BV1LSSHYXEtv --use-app-api --work-dir /downloads
+    import os
+    import subprocess
+    from toolbox import get_log_folder
+
+    chatbot.append([None, "Processing..."])
+    yield from update_ui(chatbot, history)
+
+    client_command = f'{video_id} --audio-only' if only_audio else video_id
+    server_url = get_conf('DAAS_SERVER_URL')
+    docker_service_api_com_model = DockerServiceApiComModel(client_command=client_command)
+    save_file_dir = get_log_folder(user_name, plugin_name='media_downloader')
+    for output_manifest in stream_daas(docker_service_api_com_model, server_url, save_file_dir):
+        status_buf = ""
+        status_buf += "DaaS message: \n\n"
+        status_buf += output_manifest['server_message'].replace('\n', '<br/>')
+        status_buf += "\n\n"
+        status_buf += "DaaS standard error: \n\n"
+        status_buf += output_manifest['server_std_err'].replace('\n', '<br/>')
+        status_buf += "\n\n"
+        status_buf += "DaaS standard output: \n\n"
+        status_buf += output_manifest['server_std_out'].replace('\n', '<br/>')
+        status_buf += "\n\n"
+        status_buf += "DaaS file attach: \n\n"
+        status_buf += str(output_manifest['server_file_attach'])
+        yield from update_ui_lastest_msg(status_buf, chatbot, history)
+
+    return output_manifest['server_file_attach']
+

docker_as_a_service/experimental_mods/get_search_kw_api_stop.py

@@ -0,0 +1,138 @@
+import os
+import re
+import time
+import json
+import random
+import requests
+import argparse
+from loguru import logger
+from datetime import datetime, timezone, timedelta
+from typing import List, Dict
+from tenacity import retry, stop_after_attempt, wait_random
+
+def update_and_save_data(new_data: List[Dict], filename: str):
+    if os.path.exists(filename):
+        with open(filename, 'r', encoding='utf-8') as f:
+            existing_data = json.load(f)
+    else:
+        existing_data = []
+
+    existing_bvids = set(video['bvid'] for video in existing_data)
+
+    for video in new_data:
+        if video['bvid'] not in existing_bvids:
+            existing_data.append(video)
+            existing_bvids.add(video['bvid'])
+
+    with open(filename, 'w', encoding='utf-8') as f:
+        json.dump(existing_data, f, ensure_ascii=False, indent=4)
+
+    print(f"数据已更新并保存到 {filename}")
+    return existing_data
+
+def extract_and_combine(text):
+    match = re.search(r'(.*?)<em class="keyword">(.*?)</em>(.*)', text)
+    if match:
+        combined = match.group(1) + match.group(2) + match.group(3)
+        return combined
+    return text
+
+def convert_timestamp_to_beijing_time(timestamp):
+    utc_time = datetime.fromtimestamp(timestamp, timezone.utc)
+    beijing_time = utc_time + timedelta(hours=8)
+    return beijing_time.strftime('%Y-%m-%d %H:%M:%S')
+
+def load_headers(config_path):
+    with open(config_path, 'r', encoding='utf-8') as f:
+        config = json.load(f)
+    print(f"已从 {config_path} 加载配置，请求头为：{config}")
+    return config
+
+
+@retry(stop=stop_after_attempt(3), wait=wait_random(min=1, max=3))
+def make_api_request(url, headers):
+    response = requests.get(url=url, headers=headers)
+    response.raise_for_status()
+    return response.json()
+
+def search_videos(keyword, csrf_token, search_type, max_pages=5, output_path=None, config_path='config.json', early_stop=False):
+    url_template = "https://api.bilibili.com/x/web-interface/search/type?search_type=video&keyword={keyword}&page={page}&order={search_type}&duration=0&tids=0"
+    headers = load_headers(config_path)
+    videos = []
+    existing_bvids = set()
+
+    if early_stop and output_path:
+        output_file = f"search_results_{keyword.replace(' ', '_')}_{search_type}.json"
+        file_path = os.path.join(output_path, output_file)
+        if os.path.exists(file_path):
+            with open(file_path, 'r', encoding='utf-8') as f:
+                existing_data = json.load(f)
+                existing_bvids = set(video['bvid'] for video in existing_data)
+
+    for page in range(1, max_pages + 1):
+        url = url_template.format(keyword=keyword, page=page, search_type=search_type)
+        try:
+            data = make_api_request(url, headers)
+
+            if data['code'] != 0:
+                logger.error(f"Error fetching page {page}: {data['message']}")
+                break
+
+            if 'result' not in data['data']:
+                logger.info(f"No more results found on page {page}")
+                break
+
+            result = data['data']['result']
+
+            if not result:
+                logger.info(f"No more results found on page {page}")
+                break
+
+            new_videos = []
+            for video in result:
+                video_data = {
+                    'title': extract_and_combine(video['title']),
+                    'author': video['author'],
+                    'author_id': video['mid'],
+                    'bvid': video['bvid'],
+                    '播放量': video['play'],
+                    '弹幕': video['danmaku'],
+                    '评论': video['review'],
+                    '点赞': video['favorites'],
+                    '发布时间': convert_timestamp_to_beijing_time(video['pubdate']),
+                    '视频时长': video['duration'],
+                    'tag': video['tag'],
+                    'description': video['description']
+                }
+                new_videos.append(video_data)
+
+            new_bvids = set(video['bvid'] for video in new_videos)
+            duplicate_count = len(new_bvids.intersection(existing_bvids))
+            logger.info(f"Page {page}: {duplicate_count} out of {len(new_videos)} videos already exist in the dataset.")
+
+            videos.extend(new_videos)
+            logger.info(f"Collected {len(videos)} videos from {page} pages")
+            time.sleep(random.uniform(1, 3))  # Random delay between 1 and 3 seconds
+
+        except Exception as e:
+            logger.error(f"Error on page {page}: {str(e)}")
+            break
+
+    return videos
+
+def main():
+    parser = argparse.ArgumentParser(description="Search for videos on Bilibili")
+    parser.add_argument("--keyword", default='天文馆的猫', help="Search keyword")
+    parser.add_argument("--csrf_token", default='40a227fcf12c380d7d3c81af2cd8c5e8', help="CSRF token for authentication")
+    parser.add_argument("--search_type", default='default', choices=['pubdate', 'default', 'stow', 'dm', 'click'], help="Search order type")
+    parser.add_argument("--max_pages", default=1, type=int, help="Maximum number of pages to fetch")    
+    parser.add_argument("--output_path", default='search_results', help="Output directory for search results")
+    parser.add_argument("--interval", default=1, type=int, help="Interval in hours between searches")
+    parser.add_argument("--early_stop", default=True, help="Enable early stopping if all videos on a page already exist in the dataset")
+    args = parser.parse_args()
+
+    videos = search_videos(args.keyword, args.csrf_token, args.search_type, args.max_pages, args.output_path, early_stop=args.early_stop)
+    print(videos)
+
+if __name__ == "__main__":
+    main()

docker_as_a_service/experimental_mods/test_docker_to_api.py

@@ -0,0 +1,69 @@
+import requests
+import pickle
+import io
+import os
+from pydantic import BaseModel, Field
+from typing import Optional, Dict
+
+class DockerServiceApiComModel(BaseModel):
+    client_command: Optional[str] = Field(default=None, title="Client command", description="The command to be executed on the client side")
+    client_file_attach: Optional[dict] = Field(default=None, title="Client file attach", description="The file to be attached to the client side")
+    server_message: Optional[str] = Field(default=None, title="Server standard error", description="The standard error from the server side")
+    server_std_err: Optional[str] = Field(default=None, title="Server standard error", description="The standard error from the server side")
+    server_std_out: Optional[str] = Field(default=None, title="Server standard output", description="The standard output from the server side")
+    server_file_attach: Optional[dict] = Field(default=None, title="Server file attach", description="The file to be attached to the server side")
+
+def process_received(received: DockerServiceApiComModel, save_file_dir="./daas_output"):
+    # Process the received data
+    if received.server_message:
+        print(f"Recv message: {received.server_message}")
+    if received.server_std_err:
+        print(f"Recv standard error: {received.server_std_err}")
+    if received.server_std_out:
+        print(f"Recv standard output: {received.server_std_out}")
+    if received.server_file_attach:
+        # print(f"Recv file attach: {received.server_file_attach}")
+        for file_name, file_content in received.server_file_attach.items():
+            new_fp = os.path.join(save_file_dir, file_name)
+            new_fp_dir = os.path.dirname(new_fp)
+            if not os.path.exists(new_fp_dir):
+                os.makedirs(new_fp_dir, exist_ok=True)
+            with open(new_fp, 'wb') as f:
+                f.write(file_content)
+        print(f"Saved file attach to {save_file_dir}")
+
+def send_file_and_stream_response(docker_service_api_com_model, server_url):
+    # Prepare the file
+    # Pickle the object
+    pickled_data = pickle.dumps(docker_service_api_com_model)
+
+    # Create a file-like object from the pickled data
+    file_obj = io.BytesIO(pickled_data)
+
+    # Prepare the file for sending
+    files = {'file': ('docker_service_api_com_model.pkl', file_obj, 'application/octet-stream')}
+
+    # Send the POST request
+    response = requests.post(server_url, files=files, stream=True)
+
+    max_full_package_size = 1024 * 1024 * 1024 * 1  # 1 GB
+
+    # Check if the request was successful
+    if response.status_code == 200:
+        # Process the streaming response
+        for chunk in response.iter_content(max_full_package_size):
+            if chunk:
+                received = pickle.loads(chunk)
+                process_received(received)
+
+    else:
+        print(f"Error: Received status code {response.status_code}")
+        print(response.text)
+
+# Usage
+if __name__ == "__main__":
+    server_url = "http://localhost:49000/stream"  # Replace with your server URL
+    docker_service_api_com_model = DockerServiceApiComModel(
+        client_command='BV1LSSHYXEtv --audio-only',
+    )
+    send_file_and_stream_response(docker_service_api_com_model, server_url)

docker_as_a_service/shared_utils/docker_as_service_api.py

@@ -3,13 +3,13 @@ import pickle
 import io
 import os
 from pydantic import BaseModel, Field
-from typing import Optional, Dict
+from typing import Optional, Dict, Any
 from loguru import logger
 
 class DockerServiceApiComModel(BaseModel):
     client_command: Optional[str] = Field(default=None, title="Client command", description="The command to be executed on the client side")
     client_file_attach: Optional[dict] = Field(default=None, title="Client file attach", description="The file to be attached to the client side")
-    server_message: Optional[str] = Field(default=None, title="Server standard error", description="The standard error from the server side")
+    server_message: Optional[Any] = Field(default=None, title="Server standard error", description="The standard error from the server side")
     server_std_err: Optional[str] = Field(default=None, title="Server standard error", description="The standard error from the server side")
     server_std_out: Optional[str] = Field(default=None, title="Server standard output", description="The standard output from the server side")
     server_file_attach: Optional[dict] = Field(default=None, title="Server file attach", description="The file to be attached to the server side")