from requests_toolbelt import MultipartEncoder

 import base64

 from config_files.endpoints import POSTPROCESS_ENDPOINT

 # from config_files import API_ENDPOINT_MAIN

 from flask_restx import Api, Resource, fields

 import os

 import psycopg2

 import time

 import base64

 import json

 import requests

 import typing

 from requests_toolbelt import MultipartEncoder

 debug = True

 app = Flask(__name__)

 api = Api(app, version='1.0', title='CCTV Image Upload API',

     def __setitem__(self, key, value):

         if key not in self.sources:

             self.sources[key] = {

                 "status_counts": [],

     def __call__(self):

         return self.sources

         assert status in ["OK", "FAIL"],\

             f"Invalid status was given!, status must be one of 'OK' or 'FAIL', but given '{status}'!"

                 self.sources[source]["last_send_before"] += 1

         if flag_send_event:

             self.send_event(source)

         # alert alarms only once

             normal_mode_thres=8,

             normal_mode_check_past_n=12,

         )

 @ns.route('/postprocess', )

 class PostProcesser(Resource):

     def __init__(self, *args, **kargs):

     @ns.response(400, 'Validation Error')

     def post(self):

         try:

             self.image_type = request.headers.get('Content-Type')

             self.cctv_name = base64.b64decode(request.headers.get('x-cctv-name', '')).decode('UTF-8')

             self.time_sent = request.headers.get('x-time-sent', '')

                 self.area_percent = float(self.area_percent)

             except (TypeError, ValueError) as e:

                 raise ValueError(f"Invalid value for x-area-percentage: {self.area_percent}")

             self.image = request.files.get('image')

             self.mask = request.files.get('mask')

             self.seg_image = request.files.get('seg_mask')

                     self.mask.save(f"network_test/mask_p{time.time()}.png")

                     self.seg_image.save(f"network_test/seg_p{time.time()}.png")

             self.time_sent = time.time()

             self.cctv_info = {

                 'cctv_name': self.cctv_name,

                 'cctv_latitude': self.cctv_latitude,

                 'cctv_longitude': self.cctv_longitude,

                 'time_sent': self.time_sent

             }

             # if self.cctv_name in memory:

             except :

                 pass

             pass_fail = self.pass_fail()

             if debug:

                 print(memory())

 from flask_restx import Api, Resource, fields

 import os

 from datetime import datetime

 import cv2

 import time

 import base64

 from flask import Flask

 from flask_restx import Api

 from apscheduler.schedulers.background import BackgroundScheduler

 from apscheduler.triggers.interval import IntervalTrigger

 app = Flask(__name__)

 print("ITS API Updater START")

 api = Api(app,

           version='0.1',

           title="monitoring",

     df = df.drop("roadsectionid", axis=1)

     df = df.drop("cctvresolution", axis=1)

     df = df.drop("filecreatetime", axis=1)

 url_list_sender()

 scheduler = BackgroundScheduler()

         # Prepare input data as a dictionary

         inputs = {self.session.get_inputs()[0].name: blob}

         # Run model

         outputs = self.session.run(None, inputs)

         outputs_bbox = outputs[0]

         outputs_mask = outputs[1]

         detections = self.process_detections(outputs_bbox, model_input)

         mask_maps = self.process_mask_output(detections, outputs_mask, model_input.shape)

         return detections, mask_maps

     def load_onnx_network(self):

         t1 = time.time()

         # Assuming outputs_bbox is an array with shape (N, 4+CLASS_NUM+32) where N is the number of detections

         # Extract basic bbox coordinates and scores

         x, y, w, h = outputs_bbox[:, 0], outputs_bbox[:, 1], outputs_bbox[:, 2], outputs_bbox[:, 3]

         class_ids = np.argmax(scores, axis=1)

         # Filter out small boxes

         valid_size = (w >= min_width) & (h >= min_height)

         # Apply confidence threshold

         # Prepare final arrays

         boxes = np.vstack([left, top, width, height]).T

         boxes = boxes.astype(int)

         boxes = boxes.tolist()

         filtered_confidences = filtered_confidences.tolist()

         filtered_class_ids = filtered_class_ids.tolist()

         if not len(boxes) <= 0 :

             indices = cv2.dnn.NMSBoxes(boxes, filtered_confidences, self.model_score_threshold, self.model_nms_threshold)

         else:

             indices = []

         detections = []

         for i in indices:

             # Compute the linear combination of proto masks

             # for now, plural batch operation is not supported, and this is the point where you should start.

             mask = np.tensordot(coeffs, proto_masks[0], axes=[0, 0])  # Dot product along the number of prototypes

             # Resize mask to the bounding box size, using sigmoid to normalize

             # Place the mask in the corresponding location on a full-sized mask image_binary

             full_mask = np.zeros((image_shape[0], image_shape[1]), dtype=np.uint8)

             full_mask[y1:y1+h, x1:x1+w] = final_mask

             # Combine the mask with the masks of other detections

 if __name__ == "__main__":