feat : 代码梳理 移除所有敏感密钥 通过环境变量方式配置

app/service/design_batch/design_batch_celery.py

@@ -4,7 +4,7 @@ import threading
 from celery import Celery
 from minio import Minio
 
-from app.core.config import *
+from app.core.config import settings
 from app.service.design_batch.item import BodyItem, TopItem, BottomItem, OthersItem
 from app.service.design_batch.utils.MQ import publish_status
 from app.service.design_batch.utils.organize import organize_body, organize_clothing, organize_others
@@ -12,12 +12,12 @@ from app.service.design_batch.utils.save_json import oss_upload_json
 from app.service.design_batch.utils.synthesis_item import update_base_size_priority, synthesis, synthesis_single
 
 id_lock = threading.Lock()
-celery_app = Celery('tasks', broker=f'amqp://rabbit:123456@18.167.251.121:5672//', backend='rpc://', BROKER_CONNECTION_RETRY_ON_STARTUP=True)
+celery_app = Celery('tasks', broker=f'amqp://{settings.MQ_USERNAME}:{settings.MQ_PASSWORD}@{settings.MQ_HOST}:{settings.MQ_PORT}//', backend='rpc://')
 celery_app.conf.worker_log_format = '%(asctime)s %(filename)s [line:%(lineno)d] %(levelname)s %(message)s'
 celery_app.conf.worker_hijack_root_logger = False
 logging.getLogger('pika').setLevel(logging.WARNING)
 logger = logging.getLogger()
-minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
+minio_client = Minio(settings.MINIO_URL, access_key=settings.MINIO_ACCESS, secret_key=settings.MINIO_SECRET, secure=settings.MINIO_SECURE)
 
 print("start")
 
@@ -51,10 +51,12 @@ def process_layer(item, layers):
         front_layer, back_layer = organize_others(item)
         layers.append(front_layer)
         layers.append(back_layer)
+        return None
     else:
         front_layer, back_layer = organize_clothing(item)
         layers.append(front_layer)
         layers.append(back_layer)
+        return None
 
 
 @celery_app.task
@@ -76,12 +78,11 @@ def batch_design(objects_data, tasks_id, json_name):
             for item in object['items']:
                 item_results.append(process_item(item, basic))
             layers = []
-            body_size = None
             for item in item_results:
-                body_size = process_layer(item, layers)
+                process_layer(item, layers)
             layers = sorted(layers, key=lambda s: s.get("priority", float('inf')))
 
-            layers, new_size = update_base_size_priority(layers, body_size)
+            layers, new_size = update_base_size_priority(layers)
 
             for lay in layers:
                 items_response['layers'].append({

app/service/design_batch/pipeline/back_perspective.py

@@ -18,11 +18,11 @@ class BackPerspective:
                 result['back_perspective_url'] = file_path
                 return result
             else:
-                seg_result = get_seg_result("1", result['image'])[0]
+                seg_result = get_seg_result(result['image'])[0]
         elif result['name'] in ['blouse', 'outwear', 'dress', 'tops']:
             seg_result = result['seg_result']
         else:
-            seg_result = get_seg_result("1", result['image'])[0]
+            seg_result = get_seg_result(result['image'])[0]
 
         m = self.thicken_contours_and_display(seg_result, thickness=10, color=(0, 0, 0))
         back_sketch = result['image'].copy()
@@ -34,7 +34,8 @@ class BackPerspective:
         result['back_perspective_url'] = f"{resp.bucket_name}/{resp.object_name}"
         return result
 
-    def thicken_contours_and_display(self, mask, thickness=10, color=(0, 0, 0)):
+    @staticmethod
+    def thicken_contours_and_display(mask, thickness=10, color=(0, 0, 0)):
         mask = mask.astype(np.uint8) * 255
         # 查找轮廓
         contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
@@ -48,9 +49,9 @@ class BackPerspective:
             # 在空白图像上绘制白色的轮廓
             cv2.drawContours(blank, [contour], -1, 255, thickness=thick)
             # 找到轮廓的中心（可以用重心等方法近似）
-            M = cv2.moments(contour)
-            cx = int(M['m10'] / M['m00'])
-            cy = int(M['m01'] / M['m00'])
+            m = cv2.moments(contour)
+            cx = int(m['m10'] / m['m00'])
+            cy = int(m['m01'] / m['m00'])
             # 进行距离变换，离中心越近的值越小
             dist_transform = cv2.distanceTransform(255 - blank, cv2.DIST_L2, 5)
             # 根据距离变换的值来决定是否保留像素，离中心近的像素更容易被保留

app/service/design_batch/pipeline/color.py

@@ -79,9 +79,9 @@ class Color:
     def get_pattern(single_color):
         if single_color is None:
             raise False
-        R, G, B = single_color.split(' ')
+        r, g, b = single_color.split(' ')
         pattern = np.zeros([1, 1, 3], np.uint8)
-        pattern[0, 0, 0] = int(B)
-        pattern[0, 0, 1] = int(G)
-        pattern[0, 0, 2] = int(R)
+        pattern[0, 0, 0] = int(b)
+        pattern[0, 0, 1] = int(g)
+        pattern[0, 0, 2] = int(r)
         return pattern

app/service/design_batch/pipeline/keypoint.py

@@ -3,7 +3,7 @@ import logging
 import numpy as np
 from pymilvus import MilvusClient
 
-from app.core.config import *
+from app.core.config import KEYPOINT_RESULT_TABLE_FIELD_SET, MILVUS_TABLE_KEYPOINT, settings
 from app.service.design_fast.utils.design_ensemble import get_keypoint_result
 from app.service.utils.decorator import ClassCallRunTime, RunTime
 
@@ -21,12 +21,12 @@ class KeyPoint:
     def __call__(self, result):
         if result['name'] in ['blouse', 'skirt', 'dress', 'outwear', 'trousers', 'tops', 'bottoms']:  # 查询是否有数据 且类别相同 相同则直接读 不同则推理后更新
             # result['clothes_keypoint'] = self.infer_keypoint_result(result)
-            site = 'up' if result['name'] in ['blouse', 'outwear', 'dress', 'tops'] else 'down'
+            # 'up' if result['name'] in ['blouse', 'outwear', 'dress', 'tops'] else 'down'
             # keypoint_cache = search_keypoint_cache(result["image_id"], site)
             # keypoint_cache = self.keypoint_cache(result, site)
             keypoint_cache = False
             # 取消向量查询 直接过模型推理
-            if keypoint_cache is False:
+            if not keypoint_cache:
                 keypoint_infer_result, site = self.infer_keypoint_result(result)
                 result['clothes_keypoint'] = self.save_keypoint_cache(result["image_id"], keypoint_infer_result, site)
             else:
@@ -55,8 +55,8 @@ class KeyPoint:
              }
         ]
         try:
-            client = MilvusClient(uri=MILVUS_URL, token=MILVUS_TOKEN, db_name=MILVUS_ALIAS)
-            res = client.upsert(collection_name=MILVUS_TABLE_KEYPOINT, data=data)
+            client = MilvusClient(uri=settings.MILVUS_URL, token=settings.MILVUS_TOKEN, db_name=settings.MILVUS_ALIAS)
+            client.upsert(collection_name=MILVUS_TABLE_KEYPOINT, data=data)
             client.close()
             return dict(zip(KEYPOINT_RESULT_TABLE_FIELD_SET, result.reshape(12, 2).astype(int).tolist()))
         except Exception as e:
@@ -79,7 +79,7 @@ class KeyPoint:
         ]
 
         try:
-            client = MilvusClient(uri=MILVUS_URL, token=MILVUS_TOKEN, db_name=MILVUS_ALIAS)
+            client = MilvusClient(uri=settings.MILVUS_URL, token=settings.MILVUS_TOKEN, db_name=settings.MILVUS_ALIAS)
             client.upsert(
                 collection_name=MILVUS_TABLE_KEYPOINT,
                 data=data
@@ -92,7 +92,7 @@ class KeyPoint:
     @RunTime
     def keypoint_cache(self, result, site):
         try:
-            client = MilvusClient(uri=MILVUS_URL, token=MILVUS_TOKEN, db_name=MILVUS_ALIAS)
+            client = MilvusClient(uri=settings.MILVUS_URL, token=settings.MILVUS_TOKEN, db_name=settings.MILVUS_ALIAS)
             keypoint_id = result['image_id']
             res = client.query(
                 collection_name=MILVUS_TABLE_KEYPOINT,

app/service/design_batch/pipeline/loading.py

@@ -1,9 +1,6 @@
-import io
 import logging
 
 import cv2
-import numpy as np
-from PIL import Image
 
 from app.service.utils.new_oss_client import oss_get_image
 

app/service/design_batch/pipeline/print_painting.py

@@ -9,6 +9,7 @@ from app.service.utils.new_oss_client import oss_get_image
 
 class PrintPainting:
     def __init__(self, minio_client):
+        self.random_seed = None
         self.minio_client = minio_client
 
     def __call__(self, result):
@@ -408,7 +409,7 @@ class PrintPainting:
                 change_mask = print_mask[start_h: length_h, start_w: length_w]
                 # get real part into change mask
                 _, change_mask = cv2.threshold(change_mask, 220, 255, cv2.THRESH_BINARY)
-                mask = cv2.bitwise_not(painting_dict['mask_inv_print'])
+                cv2.bitwise_not(painting_dict['mask_inv_print'])
                 img_fg[start_h:start_h + painting_dict['dim_print_h'], start_w:start_w + painting_dict['dim_print_w'], :] = change_region
 
         clothes_mask_print = cv2.bitwise_not(print_mask)

app/service/design_batch/pipeline/segmentation.py

@@ -4,7 +4,7 @@ import os
 import cv2
 import numpy as np
 
-from app.core.config import SEG_CACHE_PATH
+from app.core.config import settings
 from app.service.design_fast.utils.design_ensemble import get_seg_result
 from app.service.utils.decorator import ClassCallRunTime
 from app.service.utils.new_oss_client import oss_get_image
@@ -36,11 +36,11 @@ class Segmentation:
             # preview 过模型 不缓存
             if "preview_submit" in result.keys() and result['preview_submit'] == "preview":
                 # 推理获得seg 结果
-                seg_result = get_seg_result(result["image_id"], result['image'])
+                seg_result = get_seg_result(result['image'])
             # submit 过模型 缓存
             elif "preview_submit" in result.keys() and result['preview_submit'] == "submit":
                 # 推理获得seg 结果
-                seg_result = get_seg_result(result["image_id"], result['image'])
+                seg_result = get_seg_result(result['image'])
                 self.save_seg_result(seg_result, result['image_id'])
             #  null  正常流程 加载本地缓存 无缓存则过模型
             else:
@@ -49,7 +49,7 @@ class Segmentation:
                 # 判断缓存和实际图片size是否相同
                 if not _ or result["image"].shape[:2] != seg_result.shape:
                     # 推理获得seg 结果
-                    seg_result = get_seg_result(result["image_id"], result['image'])
+                    seg_result = get_seg_result(result['image'])
                     self.save_seg_result(seg_result, result['image_id'])
             result['seg_result'] = seg_result
 
@@ -63,7 +63,7 @@ class Segmentation:
 
     @staticmethod
     def save_seg_result(seg_result, image_id):
-        file_path = f"{SEG_CACHE_PATH}{image_id}.npy"
+        file_path = f"{settings.SEG_CACHE_PATH}{image_id}.npy"
         try:
             np.save(file_path, seg_result)
             logger.debug(f"保存成功 ：{os.path.abspath(file_path)}")
@@ -72,7 +72,7 @@ class Segmentation:
 
     @staticmethod
     def load_seg_result(image_id):
-        file_path = f"{SEG_CACHE_PATH}{image_id}.npy"
+        file_path = f"{settings.SEG_CACHE_PATH}{image_id}.npy"
         # logger.info(f"load seg file name is :{SEG_CACHE_PATH}{image_id}.npy")
         try:
             seg_result = np.load(file_path)

app/service/design_batch/pipeline/split.py

@@ -4,9 +4,7 @@ import logging
 import cv2
 import numpy as np
 from PIL import Image
-from cv2 import cvtColor, COLOR_BGR2RGBA
 
-from app.core.config import AIDA_CLOTHING
 from app.service.design_fast.utils.conversion_image import rgb_to_rgba
 from app.service.design_fast.utils.transparent import sketch_to_transparent
 from app.service.design_fast.utils.upload_image import upload_png_mask
@@ -40,7 +38,7 @@ class Split(object):
                 result_front_image = np.zeros_like(rgba_image)
                 front_mask = cv2.resize(front_mask, new_size)
                 result_front_image[front_mask != 0] = rgba_image[front_mask != 0]
-                result_front_image_pil = Image.fromarray(cvtColor(result_front_image, COLOR_BGR2RGBA))
+                result_front_image_pil = Image.fromarray(cv2.cvtColor(result_front_image, cv2.COLOR_BGR2RGBA))
                 if 'transparent' in result.keys():
                     #  用户自选区域transparent
                     transparent = result['transparent']
@@ -98,21 +96,21 @@ class Split(object):
                 result_back_image = np.zeros_like(rgba_image)
                 back_mask = cv2.resize(back_mask, new_size)
                 result_back_image[back_mask != 0] = rgba_image[back_mask != 0]
-                result_back_image_pil = Image.fromarray(cvtColor(result_back_image, COLOR_BGR2RGBA))
+                result_back_image_pil = Image.fromarray(cv2.cvtColor(result_back_image, cv2.COLOR_BGR2RGBA))
                 result['back_image'], result["back_image_url"], _ = upload_png_mask(self.minio_client, result_back_image_pil, f'{generate_uuid()}', mask=None)
                 mask_image[back_mask != 0] = [0, 255, 0]
 
                 rbga_mask = rgb_to_rgba(mask_image, front_mask + back_mask)
-                mask_pil = Image.fromarray(cvtColor(rbga_mask.astype(np.uint8), COLOR_BGR2RGBA))
+                mask_pil = Image.fromarray(cv2.cvtColor(rbga_mask.astype(np.uint8), cv2.COLOR_BGR2RGBA))
                 image_data = io.BytesIO()
                 mask_pil.save(image_data, format='PNG')
                 image_data.seek(0)
                 image_bytes = image_data.read()
-                req = oss_upload_image(oss_client=self.minio_client, bucket=AIDA_CLOTHING, object_name=f"mask/mask_{generate_uuid()}.png", image_bytes=image_bytes)
+                req = oss_upload_image(oss_client=self.minio_client, bucket="aida-clothing", object_name=f"mask/mask_{generate_uuid()}.png", image_bytes=image_bytes)
                 result['mask_url'] = req.bucket_name + "/" + req.object_name
             # 创建中间图层
             result_pattern_image_rgba = rgb_to_rgba(result['pattern_image'], result['mask'])
-            result_pattern_image_pil = Image.fromarray(cvtColor(result_pattern_image_rgba, COLOR_BGR2RGBA))
+            result_pattern_image_pil = Image.fromarray(cv2.cvtColor(result_pattern_image_rgba, cv2.COLOR_BGR2RGBA))
             result['pattern_image'], result['pattern_image_url'], _ = upload_png_mask(self.minio_client, result_pattern_image_pil, f'{generate_uuid()}')
             return result
         except Exception as e:

app/service/design_batch/utils/MQ.py

@@ -2,16 +2,17 @@ import json
 
 import pika
 
-from app.core.config import RABBITMQ_PARAMS, BATCH_DESIGN_RABBITMQ_QUEUES
+from app.core.config import settings
+from app.core.rabbit_mq_config import RABBITMQ_PARAMS
 
 
 def publish_status(task_id, progress, result):
     connection = pika.BlockingConnection(pika.ConnectionParameters(**RABBITMQ_PARAMS))
     channel = connection.channel()
-    channel.queue_declare(queue=BATCH_DESIGN_RABBITMQ_QUEUES, durable=True)
+    channel.queue_declare(queue=settings.BATCH_DESIGN_RABBITMQ_QUEUES, durable=True)
     message = {'task_id': task_id, 'progress': progress, "result": result}
     channel.basic_publish(exchange='',
-                          routing_key=BATCH_DESIGN_RABBITMQ_QUEUES,
+                          routing_key=settings.BATCH_DESIGN_RABBITMQ_QUEUES,
                           body=json.dumps(message),
                           properties=pika.BasicProperties(
                               delivery_mode=2,

app/service/design_batch/utils/design_ensemble.py

@@ -16,7 +16,7 @@ import torch
 import torch.nn.functional as F
 import tritonclient.http as httpclient
 
-from app.core.config import *
+from app.core.config import DESIGN_MODEL_URL, DESIGN_MODEL_NAME
 
 """
     keypoint
@@ -91,29 +91,29 @@ def seg_preprocess(img_path):
 
 
 # @ RunTime
-def get_seg_result(image_id, image):
+def get_seg_result(image):
     image, ori_shape = seg_preprocess(image)
     client = httpclient.InferenceServerClient(url=f"{DESIGN_MODEL_URL}")
     transformed_img = image.astype(np.float32)
     # 输入集
     inputs = [
-        httpclient.InferInput(SEGMENTATION['input'], transformed_img.shape, datatype="FP32")
+        httpclient.InferInput(DESIGN_MODEL_NAME, transformed_img.shape, datatype="FP32")
     ]
     inputs[0].set_data_from_numpy(transformed_img, binary_data=True)
     # 输出集
     outputs = [
-        httpclient.InferRequestedOutput(SEGMENTATION['output'], binary_data=True),
+        httpclient.InferRequestedOutput("seg_input__0", binary_data=True),
     ]
-    results = client.infer(model_name=SEGMENTATION['new_model_name'], inputs=inputs, outputs=outputs)
+    results = client.infer(model_name=DESIGN_MODEL_NAME, inputs=inputs, outputs=outputs)
     # 推理
     # 取结果
-    inference_output1 = results.as_numpy(SEGMENTATION['output'])
-    seg_result = seg_postprocess(int(image_id), inference_output1, ori_shape)
+    inference_output1 = results.as_numpy("seg_input__0")
+    seg_result = seg_postprocess(inference_output1, ori_shape)
     return seg_result
 
 
 # no cache
-def seg_postprocess(image_id, output, ori_shape):
+def seg_postprocess(output, ori_shape):
     seg_logit = F.interpolate(torch.tensor(output).float(), size=ori_shape, scale_factor=None, mode='bilinear', align_corners=False)
     seg_pred = seg_logit.cpu().numpy()
     return seg_pred[0]

app/service/design_batch/utils/organize.py

@@ -98,6 +98,8 @@ def calculate_start_point(keypoint_type, scale, clothes_point, body_point, offse
     """
     Align left
     Args:
+        offset:
+        resize_scale:
         keypoint_type: string, "waistband" | "shoulder" | "ear_point"
         scale: float
         clothes_point: dict{'left': [x1, y1, z1], 'right': [x2, y2, z2]}

app/service/design_batch/utils/progress.py

@@ -1,6 +1,6 @@
 import logging
 
-from app.service.design_fast.utils.redis_utils import Redis
+from app.service.utils.redis_utils import Redis
 
 logger = logging.getLogger(__name__)
 

app/service/design_batch/utils/redis_utils.py

@@ -1,99 +0,0 @@
-import redis
-
-from app.core.config import REDIS_HOST, REDIS_PORT
-
-
-class Redis(object):
-    """
-    redis数据库操作
-    """
-
-    @staticmethod
-    def _get_r():
-        host = REDIS_HOST
-        port = REDIS_PORT
-        db = 0
-        r = redis.StrictRedis(host, port, db)
-        return r
-
-    @classmethod
-    def write(cls, key, value, expire=None):
-        """
-        写入键值对
-        """
-        # 判断是否有过期时间，没有就设置默认值
-        if expire:
-            expire_in_seconds = expire
-        else:
-            expire_in_seconds = 100
-        r = cls._get_r()
-        r.set(key, value, ex=expire_in_seconds)
-
-    @classmethod
-    def read(cls, key):
-        """
-        读取键值对内容
-        """
-        r = cls._get_r()
-        value = r.get(key)
-        return value.decode('utf-8') if value else value
-
-    @classmethod
-    def hset(cls, name, key, value):
-        """
-        写入hash表
-        """
-        r = cls._get_r()
-        r.hset(name, key, value)
-
-    @classmethod
-    def hget(cls, name, key):
-        """
-        读取指定hash表的键值
-        """
-        r = cls._get_r()
-        value = r.hget(name, key)
-        return value.decode('utf-8') if value else value
-
-    @classmethod
-    def hgetall(cls, name):
-        """
-        获取指定hash表所有的值
-        """
-        r = cls._get_r()
-        return r.hgetall(name)
-
-    @classmethod
-    def delete(cls, *names):
-        """
-        删除一个或者多个
-        """
-        r = cls._get_r()
-        r.delete(*names)
-
-    @classmethod
-    def hdel(cls, name, key):
-        """
-		删除指定hash表的键值
-        """
-        r = cls._get_r()
-        r.hdel(name, key)
-
-    @classmethod
-    def expire(cls, name, expire=None):
-        """
-        设置过期时间
-        """
-        if expire:
-            expire_in_seconds = expire
-        else:
-            expire_in_seconds = 100
-        r = cls._get_r()
-        r.expire(name, expire_in_seconds)
-
-
-if __name__ == '__main__':
-    redis_client = Redis()
-    # print(redis_client.write(key="1230", value=0))
-    redis_client.write(key="1230", value=10)
-    # print(redis_client.read(key="1230"))

app/service/design_batch/utils/synthesis_item.py

@@ -13,9 +13,12 @@ import logging
 import cv2
 import numpy as np
 from PIL import Image
-
+from minio import Minio
+from app.core.config import settings
 from app.service.utils.generate_uuid import generate_uuid
-from app.service.utils.oss_client import oss_upload_image
+from app.service.utils.new_oss_client import oss_upload_image
+
+minio_client = Minio(settings.MINIO_URL, access_key=settings.MINIO_ACCESS, secret_key=settings.MINIO_SECRET, secure=settings.MINIO_SECURE)
 
 
 def positioning(all_mask_shape, mask_shape, offset):
@@ -136,7 +139,7 @@ def synthesis(data, size, basic_info):
         image_bytes = image_data.read()
         bucket_name = "aida-results"
         object_name = f'result_{generate_uuid()}.png'
-        req = oss_upload_image(bucket=bucket_name, object_name=object_name, image_bytes=image_bytes)
+        oss_upload_image(oss_client=minio_client, bucket=bucket_name, object_name=object_name, image_bytes=image_bytes)
         return f"{bucket_name}/{object_name}"
         # return f"aida-results/{minio_client.put_object('aida-results', f'result_{generate_uuid()}.png', io.BytesIO(image_bytes), len(image_bytes), content_type='image/png').object_name}"
 
@@ -177,11 +180,11 @@ def synthesis_single(front_image, back_image):
     # oss upload
     bucket_name = 'aida-results'
     object_name = f'result_{generate_uuid()}.png'
-    req = oss_upload_image(bucket=bucket_name, object_name=object_name, image_bytes=image_bytes)
+    oss_upload_image(oss_client=minio_client, bucket=bucket_name, object_name=object_name, image_bytes=image_bytes)
     return f"{bucket_name}/{object_name}"
 
 
-def update_base_size_priority(layers, size):
+def update_base_size_priority(layers):
     # 计算透明背景图片的宽度
     min_x = min(info['position'][1] for info in layers)
     x_list = []

app/service/design_batch/utils/upload_image.py

@@ -12,7 +12,6 @@ import logging
 
 import cv2
 
-from app.core.config import *
 from app.service.utils.new_oss_client import oss_upload_image
 
 
@@ -25,15 +24,15 @@ def upload_png_mask(minio_client, front_image, object_name, mask=None):
             # 将掩模的3通道转换为4通道，白色部分不透明，黑色部分透明
             rgba_image = cv2.cvtColor(mask_inverted, cv2.COLOR_BGR2BGRA)
             rgba_image[rgba_image[:, :, 0] == 0] = [0, 0, 0, 0]
-            req = oss_upload_image(oss_client=minio_client, bucket=AIDA_CLOTHING, object_name=f"mask/mask_{object_name}.png", image_bytes=cv2.imencode('.png', rgba_image)[1])
-            mask_url = f"{AIDA_CLOTHING}/mask/mask_{object_name}.png"
+            req = oss_upload_image(oss_client=minio_client, bucket="aida-clothing", object_name=f"mask/mask_{object_name}.png", image_bytes=cv2.imencode('.png', rgba_image)[1])
+            mask_url = f"aida-clothing/mask/mask_{object_name}.png"
 
         image_data = io.BytesIO()
         front_image.save(image_data, format='PNG')
         image_data.seek(0)
         image_bytes = image_data.read()
-        req = oss_upload_image(oss_client=minio_client, bucket=AIDA_CLOTHING, object_name=f"image/image_{object_name}.png", image_bytes=image_bytes)
-        image_url = f"{AIDA_CLOTHING}/image/image_{object_name}.png"
+        req = oss_upload_image(oss_client=minio_client, bucket="aida-clothing", object_name=f"image/image_{object_name}.png", image_bytes=image_bytes)
+        image_url = f"aida-clothing/image/image_{object_name}.png"
         return front_image, image_url, mask_url
     except Exception as e:
         logging.warning(f"upload_png_mask runtime exception : {e}")