diff --git a/edenai_apis/apis/affinda/client.py b/edenai_apis/apis/affinda/client.py
index e3ae5a84..144d0bc8 100644
--- a/edenai_apis/apis/affinda/client.py
+++ b/edenai_apis/apis/affinda/client.py
@@ -484,19 +484,29 @@ def create_document(
         files: Optional[Dict[str, BufferedReader]] = None
 
         if file.type == "url":
-            payload["url"] = file.file
+             payload["url"] = file.file
         elif file.type == "file":
-            files = {"file": open(file.file, "rb")}
-
-        return Document(
-            **self.__requests(
-                method=HTTPMethod.POST,
-                url=f"{self.BASE_URL}/documents",
-                headers=self.headers,
-                files=files,
-                data=payload,
+            with open(file.file, "rb") as f:
+                files = {"file": f}
+                return Document(
+                    **self.__requests(
+                        method=HTTPMethod.POST,
+                        url=f"{self.BASE_URL}/documents",
+                        headers=self.headers,
+                        files=files,
+                        data=payload,
+                    )
+                )
+        else:
+            return Document(
+                **self.__requests(
+                    method=HTTPMethod.POST,
+                    url=f"{self.BASE_URL}/documents",
+                    headers=self.headers,
+                    files=None,
+                    data=payload,
+                )
             )
-        )
 
     def delete_document(self, identifier: str) -> None:
         """Delete the document with the given identifier.
diff --git a/edenai_apis/apis/amazon/amazon_ocr_api.py b/edenai_apis/apis/amazon/amazon_ocr_api.py
index 28333b37..d499667c 100644
--- a/edenai_apis/apis/amazon/amazon_ocr_api.py
+++ b/edenai_apis/apis/amazon/amazon_ocr_api.py
@@ -111,22 +111,23 @@ def ocr__ocr(
     def ocr__identity_parser(
         self, file: str, file_url: str = ""
     ) -> ResponseType[IdentityParserDataClass]:
-        file_ = open(file, "rb")
 
-        payload = {
-            "DocumentPages": [
-                {
-                    "Bytes": file_.read(),
-                    "S3Object": {"Bucket": self.api_settings["bucket"], "Name": "test"},
-                }
-            ]
-        }
-
-        original_response = handle_amazon_call(
-            self.clients["textract"].analyze_id, **payload
-        )
+        with open(file, "rb") as file_:
+            payload = {
+                "DocumentPages": [
+                    {
+                        "Bytes": file_.read(),
+                        "S3Object": {
+                            "Bucket": self.api_settings["bucket"],
+                            "Name": "test",
+                        },
+                    }
+                ]
+            }
 
-        file_.close()
+            original_response = handle_amazon_call(
+                self.clients["textract"].analyze_id, **payload
+            )
 
         items: Sequence[InfosIdentityParserDataClass] = []
         for document in original_response["IdentityDocuments"]:
diff --git a/edenai_apis/apis/api4ai/api4ai_api.py b/edenai_apis/apis/api4ai/api4ai_api.py
index 41d43dca..dda0ffc3 100644
--- a/edenai_apis/apis/api4ai/api4ai_api.py
+++ b/edenai_apis/apis/api4ai/api4ai_api.py
@@ -95,12 +95,10 @@ def image__object_detection(
         """
         This function is used to detect objects in an image.
         """
-        file_ = open(file, "rb")
-        files = {"image": file_}
-        response = requests.post(self.urls["object_detection"], files=files)
-        original_response = response.json()
-
-        file_.close()
+        with open(file, "rb") as file_:
+            files = {"image": file_}
+            response = requests.post(self.urls["object_detection"], files=files)
+            original_response = response.json()
 
         if "failure" in original_response["results"][0]["status"]["code"]:
             raise ProviderException(
@@ -135,14 +133,13 @@ def image__object_detection(
     def image__face_detection(
         self, file: str, file_url: str = ""
     ) -> ResponseType[FaceDetectionDataClass]:
-        file_ = open(file, "rb")
-        payload = {
-            "image": file_,
-        }
-        # Get response
-        response = requests.post(self.urls["face_detection"], files=payload)
-        original_response = response.json()
-        file_.close()
+        with open(file, "rb") as file_:
+            payload = {
+                "image": file_,
+            }
+            # Get response
+            response = requests.post(self.urls["face_detection"], files=payload)
+            original_response = response.json()
 
         # Handle errors
         if "failure" in original_response["results"][0]["status"]["code"]:
@@ -200,13 +197,11 @@ def image__face_detection(
     def image__anonymization(
         self, file: str, file_url: str = ""
     ) -> ResponseType[AnonymizationDataClass]:
-        file_ = open(file, "rb")
-        files = {"image": file_}
-        response = requests.post(self.urls["anonymization"], files=files)
+        with open(file, "rb") as file_:
+            files = {"image": file_}
+            response = requests.post(self.urls["anonymization"], files=files)
 
-        original_response = response.json()
-
-        file_.close()
+            original_response = response.json()
 
         if "failure" in original_response["results"][0]["status"]["code"]:
             raise ProviderException(
@@ -246,27 +241,26 @@ def image__anonymization(
     def image__logo_detection(
         self, file: str, file_url: str = "", model: Optional[str] = None
     ) -> ResponseType[LogoDetectionDataClass]:
-        file_ = open(file, "rb")
-        payload = {
-            "image": file_,
-        }
-        # Get response
-        response = requests.post(
-            self.urls["logo_detection"].format(model=model), files=payload
-        )
-        if response.status_code >= 400:
-            error_message = ""
-            try:
-                error_message = response.json().get("message", "")
-            except:
-                pass
-            error_message = (
-                error_message or "Something went wrong when calling the provider"
+        with open(file, "rb") as file_:
+            payload = {
+                "image": file_,
+            }
+            # Get response
+            response = requests.post(
+                self.urls["logo_detection"].format(model=model), files=payload
             )
-            raise ProviderException(error_message, code=response.status_code)
+            if response.status_code >= 400:
+                error_message = ""
+                try:
+                    error_message = response.json().get("message", "")
+                except:
+                    pass
+                error_message = (
+                    error_message or "Something went wrong when calling the provider"
+                )
+                raise ProviderException(error_message, code=response.status_code)
 
-        original_response = response.json()
-        file_.close()
+            original_response = response.json()
         # Handle errors
         if "failure" in original_response["results"][0]["status"]["code"]:
             raise ProviderException(
@@ -309,19 +303,18 @@ def image__logo_detection(
     def image__explicit_content(
         self, file: str, file_url: str = ""
     ) -> ResponseType[ExplicitContentDataClass]:
-        file_ = open(file, "rb")
-        payload = {
-            "image": file_,
-        }
-        # Get response
-        response = requests.post(self.urls["nsfw"], files=payload)
-        try:
-            original_response = response.json()
-        except JSONDecodeError as exp:
-            raise ProviderException(
-                message="Internal server error", code=response.status_code
-            ) from exp
-        file_.close()
+        with open(file, "rb") as file_:
+            payload = {
+                "image": file_,
+            }
+            # Get response
+            response = requests.post(self.urls["nsfw"], files=payload)
+            try:
+                original_response = response.json()
+            except JSONDecodeError as exp:
+                raise ProviderException(
+                    message="Internal server error", code=response.status_code
+                ) from exp
 
         # Handle errors
         if (
@@ -370,9 +363,8 @@ def ocr__ocr(
         language: str,
         file_url: str = "",
     ) -> ResponseType[OcrDataClass]:
-        file_ = open(file, "rb")
-        response = requests.post(self.urls["ocr"], files={"image": file_})
-        file_.close()
+        with open(file, "rb") as file_:
+            response = requests.post(self.urls["ocr"], files={"image": file_})
 
         error = get_errors_from_response(response)
         if error is not None:
diff --git a/edenai_apis/apis/base64/base64_api.py b/edenai_apis/apis/base64/base64_api.py
index 52188547..6d12dca8 100644
--- a/edenai_apis/apis/base64/base64_api.py
+++ b/edenai_apis/apis/base64/base64_api.py
@@ -106,12 +106,11 @@ def _get_response(self, response: requests.Response) -> Any:
             raise ProviderException(response.text, code=response.status_code)
 
     def _send_ocr_document(self, file: str, model_type: str) -> Dict:
-        file_ = open(file, "rb")
-        image_as_base64 = (
-            f"data:{mimetypes.guess_type(file)[0]};base64,"
-            + base64.b64encode(file_.read()).decode()
-        )
-        file_.close()
+        with open(file, "rb") as file_:
+            image_as_base64 = (
+                f"data:{mimetypes.guess_type(file)[0]};base64,"
+                + base64.b64encode(file_.read()).decode()
+            )
 
         data = {"modelTypes": [model_type], "image": image_as_base64}
 
@@ -176,20 +175,17 @@ def ocr__financial_parser(
     def ocr__identity_parser(
         self, file: str, file_url: str = ""
     ) -> ResponseType[IdentityParserDataClass]:
-        file_ = open(file, "rb")
-
-        image_as_base64 = (
-            f"data:{mimetypes.guess_type(file)[0]};base64,"
-            + base64.b64encode(file_.read()).decode()
-        )
-
-        payload = json.dumps({"image": image_as_base64})
+        with open(file, "rb") as file_:
+            image_as_base64 = (
+                f"data:{mimetypes.guess_type(file)[0]};base64,"
+                + base64.b64encode(file_.read()).decode()
+            )
 
-        headers = {"Content-Type": "application/json", "Authorization": self.api_key}
+            payload = json.dumps({"image": image_as_base64})
 
-        response = requests.post(url=self.url, headers=headers, data=payload)
+            headers = {"Content-Type": "application/json", "Authorization": self.api_key}
 
-        file_.close()
+            response = requests.post(url=self.url, headers=headers, data=payload)
 
         original_response = self._get_response(response)
 
@@ -335,22 +331,22 @@ def image__face_compare(
         if file1_url and file2_url:
             payload = json.dumps({"url": file1_url, "queryUrl": file2_url})
         else:
-            file_reference_ = open(file1, "rb")
-            file_query_ = open(file2, "rb")
-            image_reference_as_base64 = (
-                f"data:{mimetypes.guess_type(file1)[0]};base64,"
-                + base64.b64encode(file_reference_.read()).decode()
-            )
-            image_query_as_base64 = (
-                f"data:{mimetypes.guess_type(file2)[0]};base64,"
-                + base64.b64encode(file_query_.read()).decode()
-            )
-            payload = json.dumps(
-                {
-                    "document": image_reference_as_base64,
-                    "query": image_query_as_base64,
-                }
-            )
+            with open(file1, "rb") as file_reference_, open(file2, "rb") as file_query_:
+          
+                image_reference_as_base64 = (
+                    f"data:{mimetypes.guess_type(file1)[0]};base64,"
+                    + base64.b64encode(file_reference_.read()).decode()
+                )
+                image_query_as_base64 = (
+                    f"data:{mimetypes.guess_type(file2)[0]};base64,"
+                    + base64.b64encode(file_query_.read()).decode()
+                )
+                payload = json.dumps(
+                    {
+                        "document": image_reference_as_base64,
+                        "query": image_query_as_base64,
+                    }
+                )
 
         response = requests.request("POST", url, headers=headers, data=payload)
         original_response = self._get_response(response)
@@ -474,12 +470,12 @@ def ocr__anonymization_async__launch_job(
         self, file: str, file_url: str = ""
     ) -> AsyncLaunchJobResponseType:
         data_job_id = {}
-        file_ = open(file, "rb")
-        image_as_base64 = (
-            f"data:{mimetypes.guess_type(file)[0]};base64,"
-            + base64.b64encode(file_.read()).decode()
-        )
-        file_.close()
+        with open(file, "rb") as file_:
+            image_as_base64 = (
+                f"data:{mimetypes.guess_type(file)[0]};base64,"
+                + base64.b64encode(file_.read()).decode()
+            )
+       
         payload = json.dumps(
             {
                 "image": image_as_base64,
diff --git a/edenai_apis/apis/clarifai/clarifai_api.py b/edenai_apis/apis/clarifai/clarifai_api.py
index 0b0a6b5a..82cbd5d0 100644
--- a/edenai_apis/apis/clarifai/clarifai_api.py
+++ b/edenai_apis/apis/clarifai/clarifai_api.py
@@ -432,7 +432,8 @@ def image__logo_detection(
         with open(file, "rb") as file_:
             file_content = file_.read()
         try:
-            width, height = Img.open(file).size
+            with Img.open(file) as img:
+                width, height = img.size
         except UnidentifiedImageError:
             raise ProviderException("This image type is not supported.")
 
diff --git a/edenai_apis/apis/deepl/deepl_api.py b/edenai_apis/apis/deepl/deepl_api.py
index 701ac2ab..a0aec5f1 100644
--- a/edenai_apis/apis/deepl/deepl_api.py
+++ b/edenai_apis/apis/deepl/deepl_api.py
@@ -84,33 +84,30 @@ def translation__document_translation(
         mimetype = mimetypes.guess_type(file)[0]
         extension = mimetypes.guess_extension(mimetype)
 
-        file_ = open(file, "rb")
-
-        files = {
-            "file": file_,
-        }
-
-        data = {"target_lang": target_language, "source_lang": source_language}
-
-        try:
-            response = requests.post(
-                f"{self.url}document", headers=self.header, data=data, files=files
-            )
-        except:
-            raise ProviderException(
-                "Something went wrong when performing document translation!!", 500
-            )
-        if response.status_code >= 400:
-            raise ProviderException(
-                message=http.client.responses[response.status_code],
-                code=response.status_code,
-            )
-        try:
-            original_response = response.json()
-        except json.JSONDecodeError:
-            raise ProviderException("Internal server error", 500)
-
-        file_.close()
+        with open(file, "rb") as file_:
+            files = {
+                "file": file_,
+            }
+
+            data = {"target_lang": target_language, "source_lang": source_language}
+
+            try:
+                response = requests.post(
+                    f"{self.url}document", headers=self.header, data=data, files=files
+                )
+            except:
+                raise ProviderException(
+                    "Something went wrong when performing document translation!!", 500
+                )
+            if response.status_code >= 400:
+                raise ProviderException(
+                    message=http.client.responses[response.status_code],
+                    code=response.status_code,
+                )
+            try:
+                original_response = response.json()
+            except json.JSONDecodeError:
+                raise ProviderException("Internal server error", 500)
 
         if response.status_code != 200:
             raise ProviderException(
diff --git a/edenai_apis/apis/eagledoc/eagledoc_api.py b/edenai_apis/apis/eagledoc/eagledoc_api.py
index 979ea43d..aead701f 100644
--- a/edenai_apis/apis/eagledoc/eagledoc_api.py
+++ b/edenai_apis/apis/eagledoc/eagledoc_api.py
@@ -10,13 +10,16 @@
 from edenai_apis.loaders.loaders import ProviderDataEnum, load_provider
 from edenai_apis.utils.exception import ProviderException
 from edenai_apis.utils.types import ResponseType
-from edenai_apis.features.ocr.financial_parser.financial_parser_dataclass import FinancialParserDataClass
+from edenai_apis.features.ocr.financial_parser.financial_parser_dataclass import (
+    FinancialParserDataClass,
+)
 from edenai_apis.apis.eagledoc.eagledoc_ocr_normalizer import (
     eagledoc_invoice_parser,
     eagledoc_receipt_parser,
-    eagledoc_financial_parser
+    eagledoc_financial_parser,
 )
 
+
 class EagledocApi(ProviderInterface, OcrInterface):
     provider_name = "eagledoc"
 
@@ -37,9 +40,12 @@ def _make_post_request(self, file: BufferedReader, endpoint: str = ""):
         files = {
             "file": file,
         }
-        
+
         response = requests.post(
-            url=self.url + endpoint, headers=self.headers, files=files, params=self.params
+            url=self.url + endpoint,
+            headers=self.headers,
+            files=files,
+            params=self.params,
         )
 
         try:
@@ -54,15 +60,15 @@ def _make_post_request(self, file: BufferedReader, endpoint: str = ""):
 
         return original_response
 
-
     def ocr__financial_parser(
-            self, file: str, language: str, document_type: str = "", file_url: str = ""
-            ) -> ResponseType[FinancialParserDataClass]:
+        self, file: str, language: str, document_type: str = "", file_url: str = ""
+    ) -> ResponseType[FinancialParserDataClass]:
 
-        file_ = open(file, "rb")
-        original_response = self._make_post_request(file_, endpoint="/finance/v1/processing")
+        with open(file, "rb") as file_:
+            original_response = self._make_post_request(
+                file_, endpoint="/finance/v1/processing"
+            )
 
-        file_.close()
         standardize_response = eagledoc_financial_parser(original_response)
 
         return ResponseType[FinancialParserDataClass](
@@ -73,10 +79,11 @@ def ocr__financial_parser(
     def ocr__invoice_parser(
         self, file: str, language: str, file_url: str = ""
     ) -> ResponseType[InvoiceParserDataClass]:
-        file_ = open(file, "rb")
-        original_response = self._make_post_request(file_, endpoint="/invoice/v1/processing")
+        with open(file, "rb") as file_:
+            original_response = self._make_post_request(
+                file_, endpoint="/invoice/v1/processing"
+            )
 
-        file_.close()
         standardize_response = eagledoc_invoice_parser(original_response)
 
         return ResponseType[InvoiceParserDataClass](
@@ -87,10 +94,10 @@ def ocr__invoice_parser(
     def ocr__receipt_parser(
         self, file: str, language: str, file_url: str = ""
     ) -> ResponseType[ReceiptParserDataClass]:
-        file_ = open(file, "rb")
-        original_response = self._make_post_request(file_, endpoint="/receipt/v3/processing")
-
-        file_.close()
+        with open(file, "rb") as file_:
+            original_response = self._make_post_request(
+                file_, endpoint="/receipt/v3/processing"
+            )
 
         standardize_response = eagledoc_receipt_parser(original_response)
         return ResponseType[ReceiptParserDataClass](
diff --git a/edenai_apis/apis/facepp/facepp_api.py b/edenai_apis/apis/facepp/facepp_api.py
index a28feb68..bb8f8ce2 100644
--- a/edenai_apis/apis/facepp/facepp_api.py
+++ b/edenai_apis/apis/facepp/facepp_api.py
@@ -52,13 +52,14 @@ def _get_face_tokens(self, file: str, file_url: Optional[str] = None) -> List[st
                 data={**self.api_settings, "image_url": file_url},
             )
         else:
-            response = requests.post(
-                f"{self.base_url}/detect",
-                data=self.api_settings,
-                files={"image_file": open(file, "rb")},
-            )
+            with open(file, "rb") as f:
+                response = requests.post(
+                    f"{self.base_url}/detect",
+                    data=self.api_settings,
+                    files={"image_file": f},
+                )
         if not response.ok:
-            raise ProviderException(response.text, code = response.status_code)
+            raise ProviderException(response.text, code=response.status_code)
 
         original_response = response.json()
         return [face["face_token"] for face in original_response["faces"]]
@@ -69,7 +70,7 @@ def image__face_recognition__create_collection(
         payload = {**self.api_settings, "outer_id": collection_id}
         response = requests.post(f"{self.base_url}/faceset/create", data=payload)
         if not response.ok:
-            raise ProviderException(response.text, code = response.status_code)
+            raise ProviderException(response.text, code=response.status_code)
 
         return FaceRecognitionCreateCollectionDataClass(
             collection_id=response.json()["outer_id"]
@@ -82,7 +83,7 @@ def image__face_recognition__list_collections(
             f"{self.base_url}/faceset/getfacesets", data=self.api_settings
         )
         if not response.ok:
-            raise ProviderException(response.text, code = response.status_code)
+            raise ProviderException(response.text, code=response.status_code)
 
         original_response = response.json()
         collections = [faceset["outer_id"] for faceset in original_response["facesets"]]
@@ -100,7 +101,7 @@ def image__face_recognition__delete_collection(
 
         response = requests.post(f"{self.base_url}/faceset/delete", data=payload)
         if not response.ok:
-            raise ProviderException(response.text, code = response.status_code)
+            raise ProviderException(response.text, code=response.status_code)
 
         original_response = response.json()
         return ResponseType(
@@ -128,7 +129,7 @@ def image__face_recognition__add_face(
 
         response = requests.post(f"{self.base_url}/faceset/addface", data=payload)
         if not response.ok:
-            raise ProviderException(response.text, code = response.status_code)
+            raise ProviderException(response.text, code=response.status_code)
 
         original_response = response.json()
         return ResponseType(
@@ -145,7 +146,7 @@ def image__face_recognition__list_faces(
 
         response = requests.post(f"{self.base_url}/faceset/getdetail", data=payload)
         if not response.ok:
-            raise ProviderException(response.text, code = response.status_code)
+            raise ProviderException(response.text, code=response.status_code)
 
         original_response = response.json()
 
@@ -167,7 +168,7 @@ def image__face_recognition__delete_face(
 
         response = requests.post(f"{self.base_url}/faceset/removeface", data=payload)
         if not response.ok:
-            raise ProviderException(response.text, code = response.status_code)
+            raise ProviderException(response.text, code=response.status_code)
 
         original_response = response.json()
 
@@ -188,13 +189,14 @@ def image__face_recognition__recognize(
                 f"{self.base_url}/search", data={"image_url": file_url, **payload}
             )
         else:
-            response = requests.post(
-                f"{self.base_url}/search",
-                data=payload,
-                files={"image_file": open(file, "rb")},
-            )
+            with open(file, "rb") as f:
+                response = requests.post(
+                    f"{self.base_url}/search",
+                    data=payload,
+                    files={"image_file": f},
+                )
         if not response.ok:
-            raise ProviderException(response.text, code = response.status_code)
+            raise ProviderException(response.text, code=response.status_code)
 
         original_response = response.json()
         found_faces = original_response.get("results", [])
@@ -226,16 +228,17 @@ def image__face_compare(
             }
             response = requests.post(url, data=payload)
         else:
-            response = requests.post(
-                url=url,
-                data=self.api_settings,
-                files={
-                    "image_file1": open(file1, "rb"),
-                    "image_file2": open(file2, "rb"),
-                },
-            )
+            with open(file1, "rb") as f1, open(file2, "rb") as f2:
+                response = requests.post(
+                    url=url,
+                    data=self.api_settings,
+                    files={
+                        "image_file1": f1,
+                        "image_file2": f2,
+                    },
+                )
         if not response.ok:
-            raise ProviderException(response.text, code= response.status_code)
+            raise ProviderException(response.text, code=response.status_code)
 
         original_response = response.json()
         faces = []
diff --git a/edenai_apis/apis/google/google_image_api.py b/edenai_apis/apis/google/google_image_api.py
index 5edeb5fe..cccf2f5f 100644
--- a/edenai_apis/apis/google/google_image_api.py
+++ b/edenai_apis/apis/google/google_image_api.py
@@ -119,16 +119,15 @@ def image__explicit_content(
     def image__object_detection(
         self, file: str, model: str = None, file_url: str = ""
     ) -> ResponseType[ObjectDetectionDataClass]:
-        file_ = open(file, "rb")
-        image = vision.Image(content=file_.read())
+        with open(file, "rb") as file_:
+            image = vision.Image(content=file_.read())
 
-        payload = {"image": image}
-        response = handle_google_call(
-            self.clients["image"].object_localization, **payload
-        )
-        response = MessageToDict(response._pb)
+            payload = {"image": image}
+            response = handle_google_call(
+                self.clients["image"].object_localization, **payload
+            )
+            response = MessageToDict(response._pb)
 
-        file_.close()
         items = []
         for object_annotation in response.get("localizedObjectAnnotations", []):
             x_min, x_max = np.infty, -np.infty
diff --git a/edenai_apis/apis/google/google_ocr_api.py b/edenai_apis/apis/google/google_ocr_api.py
index c49cd11c..2f5c8fcb 100644
--- a/edenai_apis/apis/google/google_ocr_api.py
+++ b/edenai_apis/apis/google/google_ocr_api.py
@@ -138,18 +138,20 @@ def ocr__receipt_parser(
             receipt_parser_project_id, "eu", receipt_parser_process_id
         )
 
-        file_ = open(file, "rb")
-        raw_document = documentai.RawDocument(content=file_.read(), mime_type=mimetype)
+        with open(file, "rb") as file_:
+            raw_document = documentai.RawDocument(
+                content=file_.read(), mime_type=mimetype
+            )
 
-        payload_request = {"name": name, "raw_document": raw_document}
-        request = handle_google_call(documentai.ProcessRequest, **payload_request)
+            payload_request = {"name": name, "raw_document": raw_document}
+            request = handle_google_call(documentai.ProcessRequest, **payload_request)
 
-        payload_result = {"request": request}
-        result = handle_google_call(receipt_client.process_document, **payload_result)
-
-        document = result.document
+            payload_result = {"request": request}
+            result = handle_google_call(
+                receipt_client.process_document, **payload_result
+            )
 
-        file_.close()
+            document = result.document
 
         receipt_infos: InfosReceiptParserDataClass = InfosReceiptParserDataClass()
         receipt_taxe: Taxes = Taxes()
@@ -249,11 +251,11 @@ def ocr__invoice_parser(
             invoice_parser_project_id, "eu", invoice_parser_process_id
         )
 
-        file_ = open(file, "rb")
-
-        raw_document = documentai.RawDocument(content=file_.read(), mime_type=mimetype)
+        with open(file, "rb") as file_:
+            raw_document = documentai.RawDocument(
+                content=file_.read(), mime_type=mimetype
+            )
 
-        file_.close()
         payload_request = {"name": name, "raw_document": raw_document}
         request = handle_google_call(documentai.ProcessRequest, **payload_request)
 
@@ -565,20 +567,20 @@ def ocr__financial_parser(
         name = financial_parser_client.processor_path(
             financial_project_id, "eu", financial_parser_process_id
         )
-        file_ = open(file, "rb")
-        raw_document = documentai.RawDocument(content=file_.read(), mime_type=mimetype)
+        with open(file) as file_:
+            raw_document = documentai.RawDocument(
+                content=file_.read(), mime_type=mimetype
+            )
 
-        payload_request = {"name": name, "raw_document": raw_document}
-        request = handle_google_call(documentai.ProcessRequest, **payload_request)
+            payload_request = {"name": name, "raw_document": raw_document}
+            request = handle_google_call(documentai.ProcessRequest, **payload_request)
 
-        payload_result = {"request": request}
-        result = handle_google_call(
-            financial_parser_client.process_document, **payload_result
-        )
-        document = result.document
+            payload_result = {"request": request}
+            result = handle_google_call(
+                financial_parser_client.process_document, **payload_result
+            )
+            document = result.document
 
-        file_.close()
-        file_ = open(file, "rb")
         standardized_response = google_financial_parser(document)
 
         return ResponseType[FinancialParserDataClass](
diff --git a/edenai_apis/apis/google/google_translation_api.py b/edenai_apis/apis/google/google_translation_api.py
index de87dcbe..72ace3a3 100644
--- a/edenai_apis/apis/google/google_translation_api.py
+++ b/edenai_apis/apis/google/google_translation_api.py
@@ -34,12 +34,12 @@ def translation__automatic_translation(
         payload = {
             "parent": parent,
             "contents": [text],
-            "mime_type" : "text/plain",  # mime types: text/plain, text/html
+            "mime_type": "text/plain",  # mime types: text/plain, text/html
             "source_language_code": source_language,
-            "target_language_code": target_language
+            "target_language_code": target_language,
         }
         response = handle_google_call(client.translate_text, **payload)
-        
+
         # Analyze response
         # Getting the translated text
         data = response.translations
@@ -56,14 +56,16 @@ def translation__automatic_translation(
     def translation__language_detection(
         self, text: str
     ) -> ResponseType[LanguageDetectionDataClass]:
-        
+
         payload = {
             "parent": f"projects/{self.project_id}/locations/global",
             "content": text,
-            "mime_type": "text/plain"
+            "mime_type": "text/plain",
         }
-        response = handle_google_call(self.clients["translate"].detect_language, **payload)
-        
+        response = handle_google_call(
+            self.clients["translate"].detect_language, **payload
+        )
+
         items: Sequence[InfosLanguageDetectionDataClass] = []
         for language in response.languages:
             items.append(
@@ -93,28 +95,26 @@ def translation__document_translation(
         client = self.clients["translate"]
         parent = f"projects/{self.project_id}/locations/global"
 
-        file_ = open(file, "rb")
-
-        document_input_config = {
-            "content": file_.read(),
-            "mime_type": file_type,
-        }
+        with open(file, "rb") as file_:
+            document_input_config = {
+                "content": file_.read(),
+                "mime_type": file_type,
+            }
 
-        payload = {
-            "request": {
-                "parent": parent,
-                "target_language_code": target_language,
-                "source_language_code": source_language,
-                "document_input_config": document_input_config,
+            payload = {
+                "request": {
+                    "parent": parent,
+                    "target_language_code": target_language,
+                    "source_language_code": source_language,
+                    "document_input_config": document_input_config,
+                }
             }
-        }
-        original_response = handle_google_call(client.translate_document, **payload)
+            original_response = handle_google_call(client.translate_document, **payload)
 
-        file_bytes = original_response.document_translation.byte_stream_outputs[0]
-        file_.close()
+            file_bytes = original_response.document_translation.byte_stream_outputs[0]
 
         print(dir(original_response))
-        serialized_response = MessageToDict(original_response._pb) 
+        serialized_response = MessageToDict(original_response._pb)
 
         b64_file = base64.b64encode(file_bytes)
         resource_url = upload_file_bytes_to_s3(
diff --git a/edenai_apis/apis/hireability/hireability_api.py b/edenai_apis/apis/hireability/hireability_api.py
index 5558294e..8a15173f 100644
--- a/edenai_apis/apis/hireability/hireability_api.py
+++ b/edenai_apis/apis/hireability/hireability_api.py
@@ -40,21 +40,19 @@ def __init__(self, api_keys: Dict = {}):
     def ocr__resume_parser(
         self, file: str, file_url: str = ""
     ) -> ResponseType[ResumeParserDataClass]:
-        file_ = open(file, "rb")
-        files = {"document": file_}
-
-        # Generate Api output
-        response = requests.post(
-            self.url,
-            data={
-                "product_code": self.product_code,
-                "document_title": file,
-            },
-            files=files,
-        )
-        original_response = response.json()
-
-        file_.close()
+        with open(file, "rb") as file_:
+            files = {"document": file_}
+
+            # Generate Api output
+            response = requests.post(
+                self.url,
+                data={
+                    "product_code": self.product_code,
+                    "document_title": file,
+                },
+                files=files,
+            )
+            original_response = response.json()
 
         # Handle provider error
         if original_response["Results"][0]["HireAbilityJSONResults"][0].get(
diff --git a/edenai_apis/apis/ibm/ibm_audio_api.py b/edenai_apis/apis/ibm/ibm_audio_api.py
index 072e83c8..73fd72c7 100644
--- a/edenai_apis/apis/ibm/ibm_audio_api.py
+++ b/edenai_apis/apis/ibm/ibm_audio_api.py
@@ -82,27 +82,29 @@ def audio__speech_to_text_async__launch_job(
         audio_attributes: tuple,
         model: Optional[str] = None,
         file_url: str = "",
-        provider_params: Optional[dict] = None
+        provider_params: Optional[dict] = None,
     ) -> AsyncLaunchJobResponseType:
         provider_params = provider_params or {}
         export_format, channels, frame_rate = audio_attributes
 
         language_audio = language
 
-        file_ = open(file, "rb")
-        audio_config = {
-            "audio": file_,
-            "content_type": "audio/" + export_format,
-            "speaker_labels": True,
-            "profanity_filter": profanity_filter,
-        }
-        audio_config.update({"rate": int(frame_rate)})
-        if language_audio:
-            audio_config.update({"model": f"{language_audio}_Telephony"})
-            if language_audio == "ja-JP":
-                audio_config["model"] = f"{language_audio}_Multimedia"
-        audio_config.update(provider_params)
-        response = handle_ibm_call(self.clients["speech"].create_job, **audio_config)
+        with open(file, "rb") as file_:
+            audio_config = {
+                "audio": file_,
+                "content_type": "audio/" + export_format,
+                "speaker_labels": True,
+                "profanity_filter": profanity_filter,
+            }
+            audio_config.update({"rate": int(frame_rate)})
+            if language_audio:
+                audio_config.update({"model": f"{language_audio}_Telephony"})
+                if language_audio == "ja-JP":
+                    audio_config["model"] = f"{language_audio}_Multimedia"
+            audio_config.update(provider_params)
+            response = handle_ibm_call(
+                self.clients["speech"].create_job, **audio_config
+            )
         if response.status_code == 201:
             return AsyncLaunchJobResponseType(provider_job_id=response.result["id"])
         else:
diff --git a/edenai_apis/apis/klippa/klippa_api.py b/edenai_apis/apis/klippa/klippa_api.py
index 4946fc31..2019b1da 100644
--- a/edenai_apis/apis/klippa/klippa_api.py
+++ b/edenai_apis/apis/klippa/klippa_api.py
@@ -5,8 +5,12 @@
 import requests
 
 from edenai_apis.features import OcrInterface, ProviderInterface
-from edenai_apis.features.ocr.financial_parser.financial_parser_dataclass import FinancialParserDataClass
-from edenai_apis.features.ocr.identity_parser.identity_parser_dataclass import IdentityParserDataClass
+from edenai_apis.features.ocr.financial_parser.financial_parser_dataclass import (
+    FinancialParserDataClass,
+)
+from edenai_apis.features.ocr.identity_parser.identity_parser_dataclass import (
+    IdentityParserDataClass,
+)
 from edenai_apis.features.ocr.invoice_parser import InvoiceParserDataClass
 from edenai_apis.features.ocr.receipt_parser import ReceiptParserDataClass
 from edenai_apis.features.ocr.resume_parser import ResumeParserDataClass
@@ -18,9 +22,10 @@
     klippa_financial_parser,
     klippa_id_parser,
     klippa_receipt_parser,
-    klippa_resume_parser
+    klippa_resume_parser,
 )
 
+
 class KlippaApi(ProviderInterface, OcrInterface):
     provider_name = "klippa"
 
@@ -47,9 +52,7 @@ def _make_post_request(self, file: BufferedReader, endpoint: str = ""):
         try:
             original_response = response.json()
         except JSONDecodeError as exc:
-            raise ProviderException(
-                message="Internal Server Error", code=500
-            ) from exc
+            raise ProviderException(message="Internal Server Error", code=500) from exc
 
         if response.status_code != 200:
             raise ProviderException(message=response.json(), code=response.status_code)
@@ -59,10 +62,8 @@ def _make_post_request(self, file: BufferedReader, endpoint: str = ""):
     def ocr__invoice_parser(
         self, file: str, language: str, file_url: str = ""
     ) -> ResponseType[InvoiceParserDataClass]:
-        file_ = open(file, "rb")
-        original_response = self._make_post_request(file_)
-
-        file_.close()
+        with open(file, "rb") as file_:
+            original_response = self._make_post_request(file_)
         standardize_response = klippa_invoice_parser(original_response)
 
         return ResponseType[InvoiceParserDataClass](
@@ -73,10 +74,8 @@ def ocr__invoice_parser(
     def ocr__receipt_parser(
         self, file: str, language: str, file_url: str = ""
     ) -> ResponseType[ReceiptParserDataClass]:
-        file_ = open(file, "rb")
-        original_response = self._make_post_request(file_)
-
-        file_.close()
+        with open(file, "rb") as file_:
+            original_response = self._make_post_request(file_)
 
         standardize_response = klippa_receipt_parser(original_response)
         return ResponseType[ReceiptParserDataClass](
@@ -87,9 +86,8 @@ def ocr__receipt_parser(
     def ocr__identity_parser(
         self, file: str, file_url: str = ""
     ) -> ResponseType[IdentityParserDataClass]:
-        file_ = open(file, "rb")
-        original_response = self._make_post_request(file_, endpoint="/identity")
-        file_.close()
+        with open(file, "rb") as file_:
+            original_response = self._make_post_request(file_, endpoint="/identity")
 
         standardized_response = klippa_id_parser(original_response)
         return ResponseType[IdentityParserDataClass](
@@ -100,27 +98,24 @@ def ocr__identity_parser(
     def ocr__resume_parser(
         self, file: str, file_url: str = ""
     ) -> ResponseType[ResumeParserDataClass]:
-        file_ = open(file, "rb")
-        original_response = self._make_post_request(file_, endpoint="/resume")
-        file_.close()
-        
+        with open(file, "rb") as file_:
+            original_response = self._make_post_request(file_, endpoint="/resume")
+
         standardized_response = klippa_resume_parser(original_response)
         return ResponseType[ResumeParserDataClass](
             original_response=original_response,
             standardized_response=standardized_response,
         )
-    
+
     def ocr__financial_parser(
         self, file: str, language: str, document_type: str = "", file_url: str = ""
     ) -> ResponseType[FinancialParserDataClass]:
-        file_ = open(file, "rb")
-        original_response = self._make_post_request(file_)
-
-        file_.close()
+        with open(file, "rb") as file_:
+            original_response = self._make_post_request(file_)
 
         standardize_response = klippa_financial_parser(original_response)
 
         return ResponseType[FinancialParserDataClass](
-                    original_response=original_response,
-                    standardized_response=standardize_response,
-                )
+            original_response=original_response,
+            standardized_response=standardize_response,
+        )
diff --git a/edenai_apis/apis/microsoft/microsoft_image_api.py b/edenai_apis/apis/microsoft/microsoft_image_api.py
index c62446b0..8172c0aa 100644
--- a/edenai_apis/apis/microsoft/microsoft_image_api.py
+++ b/edenai_apis/apis/microsoft/microsoft_image_api.py
@@ -56,15 +56,14 @@ class MicrosoftImageApi(ImageInterface):
     def image__explicit_content(
         self, file: str, file_url: str = ""
     ) -> ResponseType[ExplicitContentDataClass]:
-        file_ = open(file, "rb")
-        # Getting response of API
-        response = requests.post(
-            f"{self.url['vision']}/analyze?visualFeatures=Adult",
-            headers=self.headers["vision"],
-            data=file_,
-        )
-        data = response.json()
-        file_.close()
+        with open(file, "rb") as file_:
+            # Getting response of API
+            response = requests.post(
+                f"{self.url['vision']}/analyze?visualFeatures=Adult",
+                headers=self.headers["vision"],
+                data=file_,
+            )
+            data = response.json()
 
         # error handling
         if response.status_code != 200:
@@ -110,14 +109,13 @@ def image__explicit_content(
     def image__object_detection(
         self, file: str, model: str = None, file_url: str = ""
     ) -> ResponseType[ObjectDetectionDataClass]:
-        file_ = open(file, "rb")
-        response = requests.post(
-            f"{self.url['vision']}/detect",
-            headers=self.headers["vision"],
-            data=file_,
-        )
-        data = response.json()
-        file_.close()
+        with open(file, "rb") as file_:
+            response = requests.post(
+                f"{self.url['vision']}/detect",
+                headers=self.headers["vision"],
+                data=file_,
+            )
+            data = response.json()
 
         if response.status_code != 200:
             error = data["error"]
@@ -162,28 +160,28 @@ def image__object_detection(
     def image__face_detection(
         self, file: str, file_url: str = ""
     ) -> ResponseType[FaceDetectionDataClass]:
-        file_ = open(file, "rb")
-        file_content = file_.read()
-        # Getting size of image
-        img_size = Img.open(file).size
-
-        # Create params for returning face attribute
-        params = {
-            "recognitionModel": "recognition_04",
-            "returnFaceId": "true",
-            "returnFaceLandmarks": "true",
-            "returnFaceAttributes": (
-                "age,gender,headPose,smile,facialHair,glasses,emotion,"
-                "hair,makeup,occlusion,accessories,blur,exposure,noise"
-            ),
-        }
-        # Getting response of API
-        request = requests.post(
-            f"{self.url['face']}/detect",
-            params=params,
-            headers=self.headers["face"],
-            data=file_content,
-        )
+        with open(file, "rb") as file_, Img.open(file) as img:
+            file_content = file_.read()
+            # Getting size of image
+            img_size = img.size
+
+            # Create params for returning face attribute
+            params = {
+                "recognitionModel": "recognition_04",
+                "returnFaceId": "true",
+                "returnFaceLandmarks": "true",
+                "returnFaceAttributes": (
+                    "age,gender,headPose,smile,facialHair,glasses,emotion,"
+                    "hair,makeup,occlusion,accessories,blur,exposure,noise"
+                ),
+            }
+            # Getting response of API
+            request = requests.post(
+                f"{self.url['face']}/detect",
+                params=params,
+                headers=self.headers["face"],
+                data=file_content,
+            )
         response = request.json()
 
         # handle error
@@ -206,14 +204,13 @@ def image__face_detection(
     def image__logo_detection(
         self, file: str, file_url: str = "", model: str = None
     ) -> ResponseType[LogoDetectionDataClass]:
-        file_ = open(file, "rb")
-        response = requests.post(
-            f"{self.url['vision']}/analyze?visualFeatures=Brands",
-            headers=self.headers["vision"],
-            data=file_,
-        )
-        data = response.json()
-        file_.close()
+        with open(file, "rb") as file_:
+            response = requests.post(
+                f"{self.url['vision']}/analyze?visualFeatures=Brands",
+                headers=self.headers["vision"],
+                data=file_,
+            )
+            data = response.json()
 
         if response.status_code != 200:
             # sometimes no "error" key in repsonse
@@ -364,9 +361,8 @@ def image__face_recognition__add_face(
     ) -> ResponseType[FaceRecognitionAddFaceDataClass]:
         url = f"{self.url['face']}facelists/{collection_id}/persistedFaces?detectionModel=detection_03"
         headers = self.headers["face"]
-        file_ = open(file, "rb")
-        response = requests.post(url=url, headers=headers, data=file_)
-        file_.close()
+        with open(file, "rb") as file_:
+            response = requests.post(url=url, headers=headers, data=file_)
         if response.status_code != 200:
             raise ProviderException(
                 response.json()["error"]["message"], code=response.status_code
diff --git a/edenai_apis/apis/microsoft/microsoft_ocr_api.py b/edenai_apis/apis/microsoft/microsoft_ocr_api.py
index 8db8fff4..0601e4e0 100644
--- a/edenai_apis/apis/microsoft/microsoft_ocr_api.py
+++ b/edenai_apis/apis/microsoft/microsoft_ocr_api.py
@@ -87,8 +87,9 @@ def ocr__ocr(
             raise ProviderException(response["error"]["message"], request.status_code)
 
         # Get width and hight
-        width, height = Img.open(file).size
 
+        with Img.open(file) as img:
+            width, height = img.size
         boxes: Sequence[Bounding_box] = []
         # Get region of text
         for region in response["regions"]:
@@ -116,31 +117,29 @@ def ocr__ocr(
     def ocr__invoice_parser(
         self, file: str, language: str, file_url: str = ""
     ) -> ResponseType[InvoiceParserDataClass]:
-        file_ = open(file, "rb")
-        try:
-            document_analysis_client = DocumentAnalysisClient(
-                endpoint=self.url["documentintelligence"],
-                credential=AzureKeyCredential(
-                    self.api_settings["documentintelligence"]["subscription_key"]
-                ),
-            )
-            poller = document_analysis_client.begin_analyze_document(
-                "prebuilt-invoice", file_
-            )
-            invoices = poller.result()
-        except AzureError as provider_call_exception:
-            raise ProviderException(str(provider_call_exception))
-
-        try:
-            if invoices is None or not hasattr(invoices, "to_dict"):
-                raise AttributeError
-            # AttributeError sometimes happens in the lib when calling to dict
-            # and a DocumentField has a None value
-            original_response = invoices.to_dict()
-        except AttributeError:
-            raise ProviderException("Provider return an empty response")
+        with open(file, "rb") as file_:
+            try:
+                document_analysis_client = DocumentAnalysisClient(
+                    endpoint=self.url["documentintelligence"],
+                    credential=AzureKeyCredential(
+                        self.api_settings["documentintelligence"]["subscription_key"]
+                    ),
+                )
+                poller = document_analysis_client.begin_analyze_document(
+                    "prebuilt-invoice", file_
+                )
+                invoices = poller.result()
+            except AzureError as provider_call_exception:
+                raise ProviderException(str(provider_call_exception))
 
-        file_.close()
+            try:
+                if invoices is None or not hasattr(invoices, "to_dict"):
+                    raise AttributeError
+                # AttributeError sometimes happens in the lib when calling to dict
+                # and a DocumentField has a None value
+                original_response = invoices.to_dict()
+            except AttributeError:
+                raise ProviderException("Provider return an empty response")
 
         return ResponseType[InvoiceParserDataClass](
             original_response=original_response,
@@ -150,25 +149,24 @@ def ocr__invoice_parser(
     def ocr__receipt_parser(
         self, file: str, language: str, file_url: str = ""
     ) -> ResponseType[ReceiptParserDataClass]:
-        file_ = open(file, "rb")
-        try:
-            document_analysis_client = DocumentAnalysisClient(
-                endpoint=self.url["documentintelligence"],
-                credential=AzureKeyCredential(
-                    self.api_settings["documentintelligence"]["subscription_key"]
-                ),
-            )
-            poller = document_analysis_client.begin_analyze_document(
-                "prebuilt-receipt", file_
-            )
-            form_pages = poller.result()
-        except AzureError as provider_call_exception:
-            raise ProviderException(str(provider_call_exception))
+        with open(file, "rb") as file_:
+            try:
+                document_analysis_client = DocumentAnalysisClient(
+                    endpoint=self.url["documentintelligence"],
+                    credential=AzureKeyCredential(
+                        self.api_settings["documentintelligence"]["subscription_key"]
+                    ),
+                )
+                poller = document_analysis_client.begin_analyze_document(
+                    "prebuilt-receipt", file_
+                )
+                form_pages = poller.result()
+            except AzureError as provider_call_exception:
+                raise ProviderException(str(provider_call_exception))
 
-        if form_pages is None or not hasattr(form_pages, "to_dict"):
-            raise ProviderException("Provider return an empty response")
-        original_response = form_pages.to_dict()
-        file_.close()
+            if form_pages is None or not hasattr(form_pages, "to_dict"):
+                raise ProviderException("Provider return an empty response")
+            original_response = form_pages.to_dict()
 
         # Normalize the response
         default_dict = defaultdict(lambda: None)
@@ -252,26 +250,24 @@ def ocr__receipt_parser(
     def ocr__identity_parser(
         self, file: str, file_url: str = ""
     ) -> ResponseType[IdentityParserDataClass]:
-        file_ = open(file, "rb")
-        try:
-            document_analysis_client = DocumentAnalysisClient(
-                endpoint=self.url["documentintelligence"],
-                credential=AzureKeyCredential(
-                    self.api_settings["documentintelligence"]["subscription_key"]
-                ),
-            )
-            poller = document_analysis_client.begin_analyze_document(
-                "prebuilt-idDocument", file_
-            )
-            response = poller.result()
-        except AzureError as provider_call_exception:
-            raise ProviderException(str(provider_call_exception))
-
-        if response is None or not hasattr(response, "to_dict"):
-            raise ProviderException("Provider return an empty response")
-        original_response = response.to_dict()
+        with open(file, "rb") as file_:
+            try:
+                document_analysis_client = DocumentAnalysisClient(
+                    endpoint=self.url["documentintelligence"],
+                    credential=AzureKeyCredential(
+                        self.api_settings["documentintelligence"]["subscription_key"]
+                    ),
+                )
+                poller = document_analysis_client.begin_analyze_document(
+                    "prebuilt-idDocument", file_
+                )
+                response = poller.result()
+            except AzureError as provider_call_exception:
+                raise ProviderException(str(provider_call_exception))
 
-        file_.close()
+            if response is None or not hasattr(response, "to_dict"):
+                raise ProviderException("Provider return an empty response")
+            original_response = response.to_dict()
 
         items = []
 
@@ -403,7 +399,7 @@ def ocr__ocr_tables_async__get_job_result(
         }
 
         url = (
-            self.url['documentintelligence']
+            self.url["documentintelligence"]
             + f"documentintelligence/documentModels/prebuilt-layout/"
             f"analyzeResults/{provider_job_id}?api-version=2024-02-29-preview"
         )
@@ -437,7 +433,9 @@ def ocr__ocr_tables_async__get_job_result(
                 provider_job_id=provider_job_id,
             )
 
-        return AsyncPendingResponseType[OcrTablesAsyncDataClass](provider_job_id=provider_job_id)
+        return AsyncPendingResponseType[OcrTablesAsyncDataClass](
+            provider_job_id=provider_job_id
+        )
 
     def ocr__ocr_async__launch_job(
         self, file: str, file_url: str = ""
@@ -476,7 +474,7 @@ def ocr__ocr_async__get_job_result(
         }
 
         url = (
-            self.url['documentintelligence']
+            self.url["documentintelligence"]
             + f"documentintelligence/documentModels/prebuilt-layout/"
             f"analyzeResults/{provider_job_id}?api-version=2024-02-29-preview"
         )
@@ -512,35 +510,34 @@ def ocr__ocr_async__get_job_result(
     def ocr__financial_parser(
         self, file: str, language: str, document_type: str, file_url: str = ""
     ) -> ResponseType[FinancialParserDataClass]:
-        file_ = open(file, "rb")
-        try:
-            document_analysis_client = DocumentAnalysisClient(
-                endpoint=self.url["documentintelligence"],
-                credential=AzureKeyCredential(
-                    self.api_settings["documentintelligence"]["subscription_key"]
-                ),
-            )
-            document_type_value = (
-                "prebuilt-receipt"
-                if document_type == FinancialParserType.RECEIPT.value
-                else "prebuilt-invoice"
-            )
-            poller = document_analysis_client.begin_analyze_document(
-                document_type_value, file_
-            )
-            form_pages = poller.result()
-        except AzureError as provider_call_exception:
-            raise ProviderException(str(provider_call_exception))
+        with open(file, "rb") as file_:
+            try:
+                document_analysis_client = DocumentAnalysisClient(
+                    endpoint=self.url["documentintelligence"],
+                    credential=AzureKeyCredential(
+                        self.api_settings["documentintelligence"]["subscription_key"]
+                    ),
+                )
+                document_type_value = (
+                    "prebuilt-receipt"
+                    if document_type == FinancialParserType.RECEIPT.value
+                    else "prebuilt-invoice"
+                )
+                poller = document_analysis_client.begin_analyze_document(
+                    document_type_value, file_
+                )
+                form_pages = poller.result()
+            except AzureError as provider_call_exception:
+                raise ProviderException(str(provider_call_exception))
 
-        try:
-            if form_pages is None or not hasattr(form_pages, "to_dict"):
-                raise AttributeError
-            # AttributeError sometimes happens in the lib when calling to dict
-            # and a DocumentField has a None value
-            original_response = form_pages.to_dict()
-        except AttributeError:
-            raise ProviderException("Provider return an empty response")
-        file_.close()
+            try:
+                if form_pages is None or not hasattr(form_pages, "to_dict"):
+                    raise AttributeError
+                # AttributeError sometimes happens in the lib when calling to dict
+                # and a DocumentField has a None value
+                original_response = form_pages.to_dict()
+            except AttributeError:
+                raise ProviderException("Provider return an empty response")
         standardized_response = microsoft_financial_parser_formatter(original_response)
         return ResponseType[FinancialParserDataClass](
             original_response=original_response,
diff --git a/edenai_apis/apis/mindee/mindee_api.py b/edenai_apis/apis/mindee/mindee_api.py
index f204044b..d4ba3538 100644
--- a/edenai_apis/apis/mindee/mindee_api.py
+++ b/edenai_apis/apis/mindee/mindee_api.py
@@ -101,16 +101,14 @@ def _get_api_attributes(
     def ocr__receipt_parser(
         self, file: str, language: str, file_url: str = ""
     ) -> ResponseType[ReceiptParserDataClass]:
-        file_ = open(file, "rb")
-        args = self._get_api_attributes(file_)
-        response = requests.post(
-            self.url_receipt,
-            headers=args["headers"],
-            files=args["files"],
-        )
-        original_response = response.json()
-
-        file_.close()
+        with open(file, "rb") as file_:
+            args = self._get_api_attributes(file_)
+            response = requests.post(
+                self.url_receipt,
+                headers=args["headers"],
+                files=args["files"],
+            )
+            original_response = response.json()
 
         if "document" not in original_response:
             raise ProviderException(
@@ -199,12 +197,10 @@ def ocr__invoice_parser(
         headers = {
             "Authorization": self.api_key,
         }
-        file_ = open(file, "rb")
-        files = {"document": file_}
-        response = requests.post(self.url, headers=headers, files=files)
-        original_response = response.json()
-
-        file_.close()
+        with open(file, "rb") as file_:
+            files = {"document": file_}
+            response = requests.post(self.url, headers=headers, files=files)
+            original_response = response.json()
 
         if "document" not in original_response:
             raise ProviderException(
@@ -356,14 +352,12 @@ def ocr__invoice_parser(
     def ocr__identity_parser(
         self, file: str, file_url: str = ""
     ) -> ResponseType[IdentityParserDataClass]:
-        file_ = open(file, "rb")
-        args = self._get_api_attributes(file_)
-
-        response = requests.post(
-            url=self.url_identity, files=args["files"], headers=args["headers"]
-        )
+        with open(file, "rb") as file_:
+            args = self._get_api_attributes(file_)
 
-        file_.close()
+            response = requests.post(
+                url=self.url_identity, files=args["files"], headers=args["headers"]
+            )
 
         original_response = response.json()
         if response.status_code != 201:
@@ -459,28 +453,27 @@ def ocr__bank_check_parsing(
         file: str,
         file_url: str = "",
     ) -> ResponseType[BankCheckParsingDataClass]:
-        file_ = open(file, "rb")
-        headers = {
-            "Authorization": self.api_key,
-        }
-        files = {"document": file_}
-
-        try:
-            response = requests.post(self.url_bank_check, headers=headers, files=files)
-        except:
-            raise ProviderException(
-                "Something went wrong when calling this feature", code=500
-            )
-        original_response = response.json()
-        if response.status_code >= 400 or "document" not in original_response:
-            api_response = original_response.get("api_request", {}) or {}
-            error = api_response.get("error", {}) or {}
-            error_message = (
-                error.get("message", "")
-                or "A provider error occurred while calling this feature"
-            )
-            raise ProviderException(error_message, code=response.status_code)
-        file_.close()
+        with open(file, "rb") as file_:
+            headers = {
+                "Authorization": self.api_key,
+            }
+            files = {"document": file_}
+
+            try:
+                response = requests.post(self.url_bank_check, headers=headers, files=files)
+            except:
+                raise ProviderException(
+                    "Something went wrong when calling this feature", code=500
+                )
+            original_response = response.json()
+            if response.status_code >= 400 or "document" not in original_response:
+                api_response = original_response.get("api_request", {}) or {}
+                error = api_response.get("error", {}) or {}
+                error_message = (
+                    error.get("message", "")
+                    or "A provider error occurred while calling this feature"
+                )
+                raise ProviderException(error_message, code=response.status_code)
         bank_check_data = original_response["document"]["inference"]["prediction"]
         default_dict = defaultdict(lambda: None)
 
@@ -534,14 +527,12 @@ def ocr__financial_parser(
         headers = {
             "Authorization": self.api_key,
         }
-        file_ = open(file, "rb")
-        files = {"document": file_}
-        response = requests.post(
-            self.url_financial, headers=headers, files=files
-        )
-        original_response = response.json()
-
-        file_.close()
+        with open(file, "rb") as file_:
+            files = {"document": file_}
+            response = requests.post(
+                self.url_financial, headers=headers, files=files
+            )
+            original_response = response.json()
 
         if "document" not in original_response:
             raise ProviderException(
diff --git a/edenai_apis/apis/neuralspace/neuralspace_api.py b/edenai_apis/apis/neuralspace/neuralspace_api.py
index 8a67c58f..d8fd7e8d 100644
--- a/edenai_apis/apis/neuralspace/neuralspace_api.py
+++ b/edenai_apis/apis/neuralspace/neuralspace_api.py
@@ -72,7 +72,6 @@ def text__named_entity_recognition(
                     original_response.get("message"), code=response.status_code
                 )
 
-
         data = original_response.get("data") or {}
 
         items: List[InfosNamedEntityRecognitionDataClass] = []
@@ -181,12 +180,10 @@ def audio__speech_to_text_async__launch_job(
         url_file_transcribe = f"{self.url}transcription/v1/file/transcribe"
         # first, upload file
         headers = {"Authorization": f"{self.api_key}"}
-        file_ = open(file, "rb")
-        files = {"files": file_}
-
-        response = requests.post(url=url_file_upload, headers=headers, files=files)
+        with open(file, "rb") as file_:
+            files = {"files": file_}
+            response = requests.post(url=url_file_upload, headers=headers, files=files)
 
-        file_.close()
         if response.status_code != 200:
             raise ProviderException(
                 "Failed to upload file for transcription", response.status_code
diff --git a/edenai_apis/apis/nyckel/nyckel_api.py b/edenai_apis/apis/nyckel/nyckel_api.py
index 88a375d2..02438e0f 100644
--- a/edenai_apis/apis/nyckel/nyckel_api.py
+++ b/edenai_apis/apis/nyckel/nyckel_api.py
@@ -345,6 +345,8 @@ def image__automl_classification__upload_data_async__launch_job(
             post_parameters["data"] = {"annotation.labelName": label}
 
         response = self._session.post(**post_parameters)
+        if file_ is not None:
+            file_.close()
         if response.status_code >= 400:
             self._raise_provider_exception(url, post_parameters, response)
         try:
diff --git a/edenai_apis/apis/oneai/oneai_api.py b/edenai_apis/apis/oneai/oneai_api.py
index b803428a..d52601d8 100644
--- a/edenai_apis/apis/oneai/oneai_api.py
+++ b/edenai_apis/apis/oneai/oneai_api.py
@@ -278,12 +278,12 @@ def audio__speech_to_text_async__launch_job(
             **provider_params
         }
 
-        file_ = open(file, "rb")
-        response = requests.post(
-            url=f"{self.url}/async/file?pipeline={json.dumps(data)}",
-            headers=self.header,
-            data=file_.read(),
-        )
+        with open(file, "rb") as file_:
+            response = requests.post(
+                url=f"{self.url}/async/file?pipeline={json.dumps(data)}",
+                headers=self.header,
+                data=file_.read(),
+            )
         original_response = response.json()
 
         if response.status_code != 200:
diff --git a/edenai_apis/apis/openai/openai_audio_api.py b/edenai_apis/apis/openai/openai_audio_api.py
index 3e3d8ed4..69835e94 100644
--- a/edenai_apis/apis/openai/openai_audio_api.py
+++ b/edenai_apis/apis/openai/openai_audio_api.py
@@ -44,14 +44,14 @@ def audio__speech_to_text_async__launch_job(
             "OpenAI-Organization": self.org_key,
         }
         url = "https://api.openai.com/v1/audio/transcriptions"
-        file_ = open(file, "rb")
-        files = {"file": file_}
-        payload = {"model": "whisper-1", "language": language, **provider_params}
-        response = requests.post(url, data=payload, files=files, headers=headers)
-        if response.status_code != 200:
-            raise ProviderException(response.text, response.status_code)
+        with open(file, "rb") as file_:
+            files = {"file": file_}
+            payload = {"model": "whisper-1", "language": language, **provider_params}
+            response = requests.post(url, data=payload, files=files, headers=headers)
+            if response.status_code != 200:
+                raise ProviderException(response.text, response.status_code)
 
-        job_id = str(uuid.uuid4())
+            job_id = str(uuid.uuid4())
         try:
             original_response = response.json()
         except requests.JSONDecodeError as exp:
diff --git a/edenai_apis/apis/openai/openai_doc_parsing_api.py b/edenai_apis/apis/openai/openai_doc_parsing_api.py
index 09f53613..302d774b 100644
--- a/edenai_apis/apis/openai/openai_doc_parsing_api.py
+++ b/edenai_apis/apis/openai/openai_doc_parsing_api.py
@@ -23,6 +23,8 @@ def extract_text_from_pdf(pdf_path):
     for page_num in range(len(doc)):
         page = doc.load_page(page_num)
         text += page.get_text()
+    if doc:
+        doc.close()
     return text
 
 
diff --git a/edenai_apis/apis/openai/openai_image_api.py b/edenai_apis/apis/openai/openai_image_api.py
index e7b7fabd..5bec2a5e 100644
--- a/edenai_apis/apis/openai/openai_image_api.py
+++ b/edenai_apis/apis/openai/openai_image_api.py
@@ -152,13 +152,14 @@ def image__variation(
         file_url: str = "",
     ) -> ResponseType[VariationDataClass]:
         try:
-            response = self.client.images.generate(
-                image=open(file, "rb"),
-                n=num_images,
-                model=model,
-                size=resolution,
-                response_format="b64_json",
-            )
+            with open(file, "rb") as file_:
+                response = self.client.images.generate(
+                    image=file_,
+                    n=num_images,
+                    model=model,
+                    size=resolution,
+                    response_format="b64_json",
+                )
         except APIError as error:
             raise ProviderException(message=error.user_message, code=error.code)
 
diff --git a/edenai_apis/apis/picpurify/picpurify_api.py b/edenai_apis/apis/picpurify/picpurify_api.py
index 7e008644..6634d9f1 100644
--- a/edenai_apis/apis/picpurify/picpurify_api.py
+++ b/edenai_apis/apis/picpurify/picpurify_api.py
@@ -66,16 +66,15 @@ def image__face_detection(
             "API_KEY": self.key,
             "task": "face_gender_age_detection",
         }
-        file_ = open(file, "rb")
-        files = {"image": file_}
-        response = requests.post(self.url, files=files, data=payload)
-        self._raise_on_error(response)
-        original_response = response.json()
-        file_.close()
+        with open(file, "rb") as file_:
+            files = {"image": file_}
+            response = requests.post(self.url, files=files, data=payload)
+            self._raise_on_error(response)
+            original_response = response.json()
 
         # Std response
-        img_size = Img.open(file).size
-        width, height = img_size
+        with Img.open(file) as img:
+            width, height = img.size
         face_detection = extract(
             original_response,
             ["face_detection", "results"],
@@ -138,12 +137,11 @@ def image__explicit_content(
             "task": "suggestive_nudity_moderation,gore_moderation,"
             + "weapon_moderation,drug_moderation,hate_sign_moderation",
         }
-        file_ = open(file, "rb")
-        files = {"image": file_}
-        response = requests.post(self.url, files=files, data=payload)
-        self._raise_on_error(response)
-        original_response = response.json()
-        file_.close()
+        with open(file, "rb") as file_:
+            files = {"image": file_}
+            response = requests.post(self.url, files=files, data=payload)
+            self._raise_on_error(response)
+            original_response = response.json()
 
         # get moderation label keys from categegories found in image
         # (eg: 'drug_moderation', 'gore_moderation' etc.)
diff --git a/edenai_apis/apis/privateai/privateai_api.py b/edenai_apis/apis/privateai/privateai_api.py
index 1d7dd7e8..f7176f88 100644
--- a/edenai_apis/apis/privateai/privateai_api.py
+++ b/edenai_apis/apis/privateai/privateai_api.py
@@ -51,12 +51,11 @@ def ocr__anonymization_async__launch_job(
         self, file: str, file_url: str = ""
     ) -> AsyncLaunchJobResponseType:
         data_job_id = {}
-        file_ = open(file, "rb")
-        file_data = base64.b64encode(file_.read())
-        file_data = file_data.decode("ascii")
-        mimetype = mimetypes.guess_type(file)[0]
-        extension = mimetypes.guess_extension(mimetype)
-        file_.close()
+        with open(file, "rb") as file_:
+            file_data = base64.b64encode(file_.read())
+            file_data = file_data.decode("ascii")
+            mimetype = mimetypes.guess_type(file)[0]
+            extension = mimetypes.guess_extension(mimetype)
         data = {
             "file": {
                 "data": file_data,  # base64 converted file
diff --git a/edenai_apis/apis/readyredact/readyredact_api.py b/edenai_apis/apis/readyredact/readyredact_api.py
index 8cd91fce..8e8dde23 100644
--- a/edenai_apis/apis/readyredact/readyredact_api.py
+++ b/edenai_apis/apis/readyredact/readyredact_api.py
@@ -31,20 +31,20 @@ def ocr__anonymization_async__launch_job(
         self, file: str, file_url: str = ""
     ) -> AsyncLaunchJobResponseType:
 
-        file_ = open(file, "rb")
-        files = [
-            ('file[]', (file, file_, 'application/pdf'))
-        ]
-        payload = {
-            "email": self.email
-        }
-        headers = {
-            'Accept': 'application/json'
-        }
-        params = {
-            "api_key": self.api_key
-        }
-        response = requests.post(url=self.url_put_file, params=params, data=payload, files=files, headers=headers)
+        with open(file, "rb") as file_:
+            files = [
+                ('file[]', (file, file_, 'application/pdf'))
+            ]
+            payload = {
+                "email": self.email
+            }
+            headers = {
+                'Accept': 'application/json'
+            }
+            params = {
+                "api_key": self.api_key
+            }
+            response = requests.post(url=self.url_put_file, params=params, data=payload, files=files, headers=headers)
         if response.status_code != 200:
             raise ProviderException(response.text, code=response.status_code)
         try:
diff --git a/edenai_apis/apis/rossum/rossum_api.py b/edenai_apis/apis/rossum/rossum_api.py
index 364b3d40..c9151e52 100644
--- a/edenai_apis/apis/rossum/rossum_api.py
+++ b/edenai_apis/apis/rossum/rossum_api.py
@@ -235,9 +235,11 @@ def _parse_response_for_specific_page(
         for idx, category_information in enumerate(page["content"]):
             current_category = RossumApi.CategoryType.as_list()[idx]
             data_as_dict = {
-                entry["schema_id"]: entry["value"]
-                if entry["category"] == "datapoint"
-                else entry["children"]
+                entry["schema_id"]: (
+                    entry["value"]
+                    if entry["category"] == "datapoint"
+                    else entry["children"]
+                )
                 for entry in category_information["children"]
             }
             if current_category == RossumApi.CategoryType.LINE_ITEMS.value:
@@ -322,12 +324,16 @@ def _invoice_standardization(
             for tax in response_parsed["vat_and_amount"]["tax_details"]:
                 taxes.append(
                     TaxesInvoice(
-                        value=float(tax["tax_detail_tax"])
-                        if tax["tax_detail_tax"]
-                        else None,
-                        rate=float(tax["tax_detail_rate"])
-                        if tax["tax_detail_rate"]
-                        else None,
+                        value=(
+                            float(tax["tax_detail_tax"])
+                            if tax["tax_detail_tax"]
+                            else None
+                        ),
+                        rate=(
+                            float(tax["tax_detail_rate"])
+                            if tax["tax_detail_rate"]
+                            else None
+                        ),
                     )
                 )
 
@@ -346,16 +352,20 @@ def _invoice_standardization(
             for item in response_parsed["line_items"]:
                 item_lines.append(
                     ItemLinesInvoice(
-                        unit_price=float(item["item_amount_base"])
-                        if item["item_amount_base"]
-                        else None,
-                        amount=float(item["item_amount"])
-                        if item["item_amount"]
-                        else None,
+                        unit_price=(
+                            float(item["item_amount_base"])
+                            if item["item_amount_base"]
+                            else None
+                        ),
+                        amount=(
+                            float(item["item_amount"]) if item["item_amount"] else None
+                        ),
                         description=item["item_description"],
-                        quantity=float(item["item_quantity"])
-                        if item["item_quantity"]
-                        else None,
+                        quantity=(
+                            float(item["item_quantity"])
+                            if item["item_quantity"]
+                            else None
+                        ),
                     )
                 )
 
@@ -385,16 +395,17 @@ def _invoice_standardization(
     def ocr__invoice_parser(
         self, file: str, language: str, file_url: str = ""
     ) -> ResponseType[InvoiceParserDataClass]:
-        file_ = open(file, "rb")
-        _, annotation_endpoint = self._upload(file_)
-        id, status = self._get_status_and_id(annotation_endpoint)
-        while status != "to_review":
-            sleep(1)
+        with open(file, "rb") as file_:
+            _, annotation_endpoint = self._upload(file_)
             id, status = self._get_status_and_id(annotation_endpoint)
-            if status == "failed_import":
-                raise ProviderException("Invalid file, please check the file format.")
+            while status != "to_review":
+                sleep(1)
+                id, status = self._get_status_and_id(annotation_endpoint)
+                if status == "failed_import":
+                    raise ProviderException(
+                        "Invalid file, please check the file format."
+                    )
 
-        file_.close()
         original_response = self._download_reviewing_data(id)
         standardized_response = self._invoice_standardization(original_response)
 
diff --git a/edenai_apis/apis/senseloaf/client.py b/edenai_apis/apis/senseloaf/client.py
index 0f70a234..96f94fd1 100644
--- a/edenai_apis/apis/senseloaf/client.py
+++ b/edenai_apis/apis/senseloaf/client.py
@@ -161,23 +161,24 @@ def __login(self, email, password):
 
     def __parse_resume_from_file(self, file: str) -> ResponseData:
         url = f"{self.BASE_URL}/api/v2/parse-resume"
-        files = [
-            (
-                "files",
-                (file.split("/")[-1], open(file, "rb"), mimetypes.guess_type(file)[0]),
+        with open(file, "rb") as file_:
+            files = [
+                (
+                    "files",
+                    (file.split("/")[-1], file_, mimetypes.guess_type(file)[0]),
+                )
+            ]
+            headers = {"Authorization": f"Bearer {self.__api_key}"}
+            response = self.__request(
+                method=HTTPMethod.POST,
+                url=url,
+                data=None,
+                headers=headers,
+                json_field=None,
+                files=files,
+                params=None,
+                return_type="json",
             )
-        ]
-        headers = {"Authorization": f"Bearer {self.__api_key}"}
-        response = self.__request(
-            method=HTTPMethod.POST,
-            url=url,
-            data=None,
-            headers=headers,
-            json_field=None,
-            files=files,
-            params=None,
-            return_type="json",
-        )
         if response.response_code != "200":
             raise ProviderException(
                 message=response.response, code=response.response_code
diff --git a/edenai_apis/apis/sentisight/sentisight_api.py b/edenai_apis/apis/sentisight/sentisight_api.py
index 83494571..84887940 100644
--- a/edenai_apis/apis/sentisight/sentisight_api.py
+++ b/edenai_apis/apis/sentisight/sentisight_api.py
@@ -61,21 +61,21 @@ def ocr__ocr(
         if not language:
             raise LanguageException("Language not provided")
 
-        file_ = open(file, "rb")
-        response = requests.post(
-            url=add_query_param_in_url(url, {"lang": get_formatted_language(language)}),
-            headers={
-                "accept": "*/*",
-                "X-Auth-token": self.key,
-                "Content-Type": "application/octet-stream",
-            },
-            data=file_,
-        )
-        file_.close()
+        with open(file, "rb") as file_:
+            response = requests.post(
+                url=add_query_param_in_url(url, {"lang": get_formatted_language(language)}),
+                headers={
+                    "accept": "*/*",
+                    "X-Auth-token": self.key,
+                    "Content-Type": "application/octet-stream",
+                },
+                data=file_,
+            )
         if response.status_code != 200:
             raise ProviderException(response.text, code=response.status_code)
         response = response.json()
-        width, height = Img.open(file).size
+        with Img.open(file) as img:
+            width, height = img.size
         # response["width"], response["height"] = Img.open(file).size
 
         bounding_boxes: Sequence[Bounding_box] = []
@@ -109,23 +109,22 @@ def ocr__ocr(
     def image__object_detection(
         self, file: str, file_url: str = "", model: Optional[str] = None
     ) -> ResponseType[ObjectDetectionDataClass]:
-        file_ = open(file, "rb")
-        response = requests.post(
-            self.base_url + SentisightPreTrainModel.OBJECT_DETECTION.value,
-            headers={
-                "accept": "*/*",
-                "X-Auth-token": self.key,
-                "Content-Type": "application/octet-stream",
-            },
-            data=file_,
-        )
-        file_.close()
+        with open(file, "rb") as file_:
+            response = requests.post(
+                self.base_url + SentisightPreTrainModel.OBJECT_DETECTION.value,
+                headers={
+                    "accept": "*/*",
+                    "X-Auth-token": self.key,
+                    "Content-Type": "application/octet-stream",
+                },
+                data=file_,
+            )
         if response.status_code != 200:
             raise ProviderException(response.text, code=response.status_code)
 
-        img = Img.open(file)
-        width = img.width
-        height = img.height
+        with Img.open(file) as img:
+            width = img.width
+            height = img.height
 
         original_response = response.json()
         objects: Sequence[ObjectItem] = []
@@ -150,17 +149,16 @@ def image__object_detection(
     def image__explicit_content(
         self, file: str, file_url: str = ""
     ) -> ResponseType[ExplicitContentDataClass]:
-        file_ = open(file, "rb")
-        response = requests.post(
-            self.base_url + SentisightPreTrainModel.NSFW_CLASSIFICATION.value,
-            headers={
-                "accept": "*/*",
-                "X-Auth-token": self.key,
-                "Content-Type": "application/octet-stream",
-            },
-            data=file_,
-        )
-        file_.close()
+        with open(file, "rb") as file_:
+            response = requests.post(
+                self.base_url + SentisightPreTrainModel.NSFW_CLASSIFICATION.value,
+                headers={
+                    "accept": "*/*",
+                    "X-Auth-token": self.key,
+                    "Content-Type": "application/octet-stream",
+                },
+                data=file_,
+            )
         if response.status_code != 200:
             raise ProviderException(response.text, code=response.status_code)
 
@@ -228,18 +226,16 @@ def image__search__upload_image(
             + f"{project_id}/{image_name}?preprocess=true"
         )
         # Build the request
-        file_ = open(file, "rb")
-        response = requests.post(
-            upload_project_url,
-            headers={
-                "accept": "*/*",
-                "X-Auth-token": self.key,
-                "Content-Type": "application/octet-stream",
-            },
-            data=file_,
-        )
-
-        file_.close()
+        with open(file, "rb") as file_:
+            response = requests.post(
+                upload_project_url,
+                headers={
+                    "accept": "*/*",
+                    "X-Auth-token": self.key,
+                    "Content-Type": "application/octet-stream",
+                },
+                data=file_,
+            )
 
         if response.status_code != 200:
             handle_error_image_search(response)
@@ -316,18 +312,17 @@ def image__search__launch_similarity(
         )
         if not file:
             raise ValueError("file is required.")
-        file_ = open(file, "rb")
-        response = requests.post(
-            search_project_url,
-            headers={
-                "accept": "*/*",
-                "X-Auth-token": self.key,
-                "Content-Type": "application/octet-stream",
-            },
-            data=file_,
-        )
+        with open(file, "rb") as file_:
+            response = requests.post(
+                search_project_url,
+                headers={
+                    "accept": "*/*",
+                    "X-Auth-token": self.key,
+                    "Content-Type": "application/octet-stream",
+                },
+                data=file_,
+            )
 
-        file_.close()
         # Handle the error
         if response.status_code != 200:
             handle_error_image_search(response)
diff --git a/edenai_apis/apis/skybiometry/skybiometry_api.py b/edenai_apis/apis/skybiometry/skybiometry_api.py
index 249e46e7..050d11ce 100644
--- a/edenai_apis/apis/skybiometry/skybiometry_api.py
+++ b/edenai_apis/apis/skybiometry/skybiometry_api.py
@@ -37,17 +37,16 @@ def __init__(self, api_keys: Dict = {}) -> None:
     def image__face_detection(
         self, file: str, file_url: str = ""
     ) -> ResponseType[FaceDetectionDataClass]:
-        file_ = open(file, "rb")
-        files = {"file": file_}
+        with open(file, "rb") as file_:
+            files = {"file": file_}
 
-        endpoint = f"{self.base_url}faces/detect.json"
-        query_params = (
-            f"api_key={self.api_key}&api_secret={self.api_secret}&attributes=all"
-        )
-        response = requests.post(f"{endpoint}?{query_params}", files=files)
+            endpoint = f"{self.base_url}faces/detect.json"
+            query_params = (
+                f"api_key={self.api_key}&api_secret={self.api_secret}&attributes=all"
+            )
+            response = requests.post(f"{endpoint}?{query_params}", files=files)
 
-        original_response = response.json()
-        file_.close()
+            original_response = response.json()
         if response.status_code != 200:
             raise ProviderException(
                 message=original_response["error_message"], code=response.status_code
@@ -109,40 +108,60 @@ def image__face_detection(
                     age=face["attributes"].get("age_est", {}).get("value"),
                     gender=face["attributes"].get("gender", {}).get("value"),
                     facial_hair=FaceFacialHair(
-                        moustache=1.0
-                        if face["attributes"].get("mustache", {}).get("value") == "true"
-                        else 0.0,
-                        beard=1.0
-                        if face["attributes"].get("beard", {}).get("value") == "true"
-                        else 0.0,
+                        moustache=(
+                            1.0
+                            if face["attributes"].get("mustache", {}).get("value")
+                            == "true"
+                            else 0.0
+                        ),
+                        beard=(
+                            1.0
+                            if face["attributes"].get("beard", {}).get("value")
+                            == "true"
+                            else 0.0
+                        ),
                         sideburns=None,
                     ),
                     accessories=FaceAccessories(
-                        sunglasses=1.0
-                        if face["attributes"].get("dark_glasses", {}).get("value")
-                        == "true"
-                        else 0.0,
-                        eyeglasses=1.0
-                        if face["attributes"].get("glasses", {}).get("value") == "true"
-                        else 0.0,
-                        headwear=1.0
-                        if face["attributes"].get("hat", {}).get("value") == "true"
-                        else 0.0,
+                        sunglasses=(
+                            1.0
+                            if face["attributes"].get("dark_glasses", {}).get("value")
+                            == "true"
+                            else 0.0
+                        ),
+                        eyeglasses=(
+                            1.0
+                            if face["attributes"].get("glasses", {}).get("value")
+                            == "true"
+                            else 0.0
+                        ),
+                        headwear=(
+                            1.0
+                            if face["attributes"].get("hat", {}).get("value") == "true"
+                            else 0.0
+                        ),
                         reading_glasses=None,
                         swimming_goggles=None,
                         face_mask=None,
                     ),
                     features=FaceFeatures(
-                        eyes_open=1.0
-                        if face["attributes"].get("eyes", {}).get("value") == "open"
-                        else 0.0,
-                        smile=1.0
-                        if face["attributes"].get("smiling", {}).get("value") == "true"
-                        else 0.0,
-                        mouth_open=1.0
-                        if face["attributes"].get("lips", {}).get("value", "sealed")
-                        != "sealed"
-                        else 0.0,
+                        eyes_open=(
+                            1.0
+                            if face["attributes"].get("eyes", {}).get("value") == "open"
+                            else 0.0
+                        ),
+                        smile=(
+                            1.0
+                            if face["attributes"].get("smiling", {}).get("value")
+                            == "true"
+                            else 0.0
+                        ),
+                        mouth_open=(
+                            1.0
+                            if face["attributes"].get("lips", {}).get("value", "sealed")
+                            != "sealed"
+                            else 0.0
+                        ),
                     ),
                     poses=FacePoses.default(),
                     quality=FaceQuality.default(),
diff --git a/edenai_apis/apis/speechmatics/speechmatics_api.py b/edenai_apis/apis/speechmatics/speechmatics_api.py
index d9934cb3..4159397a 100644
--- a/edenai_apis/apis/speechmatics/speechmatics_api.py
+++ b/edenai_apis/apis/speechmatics/speechmatics_api.py
@@ -50,28 +50,28 @@ def audio__speech_to_text_async__launch_job(
         provider_params: Optional[dict] = None,
     ) -> AsyncLaunchJobResponseType:
         provider_params = provider_params or {}
-        file_ = open(file, "rb")
-        config = {
-            "language": language,
-            "diarization": "speaker",
-            "operating_point": model,
-        }
-        if vocabulary:
-            config["additional_vocab"] = [{"content": word} for word in vocabulary]
+        with open(file, "rb") as file_:
+            config = {
+                "language": language,
+                "diarization": "speaker",
+                "operating_point": model,
+            }
+            if vocabulary:
+                config["additional_vocab"] = [{"content": word} for word in vocabulary]
 
-        payload = {
-            "config": json.dumps(
-                {"type": "transcription", "transcription_config": config}
-            ),
-            **provider_params,
-        }
-        # Send request
-        response = requests.post(
-            url=self.base_url,
-            headers=self.headers,
-            data=payload,
-            files={"data_file": file_},
-        )
+            payload = {
+                "config": json.dumps(
+                    {"type": "transcription", "transcription_config": config}
+                ),
+                **provider_params,
+            }
+            # Send request
+            response = requests.post(
+                url=self.base_url,
+                headers=self.headers,
+                data=payload,
+                files={"data_file": file_},
+            )
         if response.status_code != 201:
             raise ProviderException(response.content, response.status_code)
 
diff --git a/edenai_apis/apis/stabilityai/stabilityai_api.py b/edenai_apis/apis/stabilityai/stabilityai_api.py
index 3ca3b212..2d233d87 100644
--- a/edenai_apis/apis/stabilityai/stabilityai_api.py
+++ b/edenai_apis/apis/stabilityai/stabilityai_api.py
@@ -133,19 +133,19 @@ def image__variation(
         url = f"https://api.stability.ai/v1/generation/{model}/image-to-image"
         del self.headers["Content-Type"]
         prompt = prompt or ""
-        img = open(file, "rb")
+        with open(file, "rb") as img:
 
-        if not prompt:
-            prompt = "Generate a variation of this image and maintain the style"
+            if not prompt:
+                prompt = "Generate a variation of this image and maintain the style"
 
-        data = {
-            "image_strength": 1 - temperature,
-            "text_prompts[0][text]": prompt,
-            "samples": num_images,
-        }
-        files = {"init_image": img}
+            data = {
+                "image_strength": 1 - temperature,
+                "text_prompts[0][text]": prompt,
+                "samples": num_images,
+            }
+            files = {"init_image": img}
 
-        response = requests.post(url, headers=self.headers, data=data, files=files)
+            response = requests.post(url, headers=self.headers, data=data, files=files)
 
         if response.status_code != 200:
             raise ProviderException(message=response.text, code=response.status_code)
diff --git a/edenai_apis/apis/symbl/symbl_api.py b/edenai_apis/apis/symbl/symbl_api.py
index 8b3a3963..f401456a 100644
--- a/edenai_apis/apis/symbl/symbl_api.py
+++ b/edenai_apis/apis/symbl/symbl_api.py
@@ -93,13 +93,13 @@ def audio__speech_to_text_async__launch_job(
             params.update({"customVocabulary": vocabulary})
 
         params.update(provider_params)
-        file_ = open(file, "rb")
-        response = requests.post(
-            url="https://api.symbl.ai/v1/process/audio",
-            headers=headers,
-            data=file_,
-            params=params,
-        )
+        with open(file, "rb") as file_:
+            response = requests.post(
+                url="https://api.symbl.ai/v1/process/audio",
+                headers=headers,
+                data=file_,
+                params=params,
+            )
 
         if response.status_code != 201:
             raise ProviderException(
diff --git a/edenai_apis/apis/tabscanner/tabscanner_api.py b/edenai_apis/apis/tabscanner/tabscanner_api.py
index f2c9ae6c..2a5c7f7b 100644
--- a/edenai_apis/apis/tabscanner/tabscanner_api.py
+++ b/edenai_apis/apis/tabscanner/tabscanner_api.py
@@ -24,8 +24,8 @@
     FinancialParserObjectDataClass,
     FinancialLineItem,
     FinancialDocumentMetadata,
-    FinancialBankInformation
-    )
+    FinancialBankInformation,
+)
 from edenai_apis.features.ocr.receipt_parser.receipt_parser_dataclass import BarCode
 from edenai_apis.loaders.data_loader import ProviderDataEnum
 from edenai_apis.loaders.loaders import load_provider
@@ -53,7 +53,9 @@ def _process(self, file: BufferedReader, document_type: str) -> str:
         )
         response_json = response.json()
         if response_json.get("success") == False:
-            raise ProviderException(response_json.get("message"), code = response.status_code)
+            raise ProviderException(
+                response_json.get("message"), code=response.status_code
+            )
         return response_json["token"]
 
     def _get_response(self, token: str, retry=0) -> Any:
@@ -68,14 +70,13 @@ def _get_response(self, token: str, retry=0) -> Any:
     def ocr__receipt_parser(
         self, file: str, language: str, file_url: str = ""
     ) -> ResponseType[ReceiptParserDataClass]:
-        file_ = open(file, "rb")
-        token = self._process(file_, "receipt")
-        sleep(1)
-        original_response, status_code = self._get_response(token)
-        file_.close()
+        with open(file, "rb") as file_:
+            token = self._process(file_, "receipt")
+            sleep(1)
+            original_response, status_code = self._get_response(token)
 
         if "result" not in original_response:
-            raise ProviderException(original_response["message"], code = status_code)
+            raise ProviderException(original_response["message"], code=status_code)
 
         receipt = original_response.get("result")
 
@@ -112,12 +113,16 @@ def ocr__receipt_parser(
         list_items: Sequence[ItemLines] = [
             ItemLines(
                 description=json_element["descClean"],
-                amount=float(json_element["lineTotal"])
-                if json_element["lineTotal"] and json_element["lineTotal"] != ""
-                else None,
-                unit_price=convert_string_to_number(json_element["unit"], float)
-                if json_element["unit"] and json_element["unit"] != ""
-                else None,
+                amount=(
+                    float(json_element["lineTotal"])
+                    if json_element["lineTotal"] and json_element["lineTotal"] != ""
+                    else None
+                ),
+                unit_price=(
+                    convert_string_to_number(json_element["unit"], float)
+                    if json_element["unit"] and json_element["unit"] != ""
+                    else None
+                ),
                 quantity=json_element["qty"],
             )
             for json_element in receipt["lineItems"]
@@ -150,16 +155,15 @@ def ocr__receipt_parser(
         return result
 
     def ocr__financial_parser(
-            self, file: str, language: str, document_type: str = "", file_url: str = ""
-            ) -> ResponseType[FinancialParserDataClass]:
-        file_ = open(file, "rb")
-        token = self._process(file_, document_type)
-        sleep(1)
-        original_response, status_code = self._get_response(token)
-        file_.close()
+        self, file: str, language: str, document_type: str = "", file_url: str = ""
+    ) -> ResponseType[FinancialParserDataClass]:
+        with open(file, "rb") as file_:
+            token = self._process(file_, document_type)
+            sleep(1)
+            original_response, status_code = self._get_response(token)
 
         if "result" not in original_response:
-            raise ProviderException(original_response["message"], code = status_code)
+            raise ProviderException(original_response["message"], code=status_code)
 
         financial_document = original_response.get("result")
 
@@ -185,15 +189,14 @@ def ocr__financial_parser(
             amount_change=financial_document.get("change"),
             discount=financial_document.get("discount"),
             payment_method=financial_document.get("paymentMethod"),
-            subtotal = financial_document.get("subTotal"),
-            barcodes = [
-            FinancialBarcode(type=code_type, value=code_value)
-            for code_value, code_type in financial_document.get("barcodes", [])
-        ]
+            subtotal=financial_document.get("subTotal"),
+            barcodes=[
+                FinancialBarcode(type=code_type, value=code_value)
+                for code_value, code_type in financial_document.get("barcodes", [])
+            ],
         )
         financial_document_information = FinancialDocumentInformation(
-            date = financial_document.get("date")
-
+            date=financial_document.get("date")
         )
 
         local = FinancialLocalInformation(currecy=financial_document.get("currency"))
@@ -201,11 +204,13 @@ def ocr__financial_parser(
         list_items = [
             FinancialLineItem(
                 description=json_element.get("descClean"),
-                amount_line=convert_string_to_number(json_element.get("lineTotal"), float),
+                amount_line=convert_string_to_number(
+                    json_element.get("lineTotal"), float
+                ),
                 unit_price=convert_string_to_number(json_element.get("unit"), float),
                 quantity=json_element["qty"],
                 product_code=json_element.get("productCode"),
-                discount_amount=json_element.get("discount")
+                discount_amount=json_element.get("discount"),
             )
             for json_element in financial_document["lineItems"]
         ]
@@ -218,15 +223,15 @@ def ocr__financial_parser(
                     payment_information=payment_information,
                     financial_document_information=financial_document_information,
                     local=local,
-                    bank = FinancialBankInformation(),
+                    bank=FinancialBankInformation(),
                     item_lines=list_items,
                     document_metadata=FinancialDocumentMetadata(
                         document_type=financial_document.get("documentType")
-                    )
+                    ),
                 )
             ]
         )
         return ResponseType[FinancialParserDataClass](
-                    original_response=original_response,
-                    standardized_response=standardized_response,
-                )
\ No newline at end of file
+            original_response=original_response,
+            standardized_response=standardized_response,
+        )
diff --git a/edenai_apis/apis/twelvelabs/twelvelabs_api.py b/edenai_apis/apis/twelvelabs/twelvelabs_api.py
index 6f85213f..b1835319 100644
--- a/edenai_apis/apis/twelvelabs/twelvelabs_api.py
+++ b/edenai_apis/apis/twelvelabs/twelvelabs_api.py
@@ -5,7 +5,7 @@
 from edenai_apis.utils.types import (
     AsyncLaunchJobResponseType,
     AsyncBaseResponseType,
-    AsyncResponseType
+    AsyncResponseType,
 )
 
 
@@ -92,7 +92,8 @@ def video__logo_detection_async__launch_job(
         response = requests.post(
             task_url, headers=self.headers, data=video_data_config, files=file_param
         )
-
+        if file_stream is not None:
+            file_stream.close()
 
         if response.status_code != 201:
             raise ProviderException(message=response.text, code=response.status_code)
@@ -109,7 +110,7 @@ def video__logo_detection_async__launch_job(
         response = response.json()
 
         video_id = response.get("video_id")
- 
+
         provider_job_id = index_id + "_" + video_id + "_" + task_id
 
         return AsyncLaunchJobResponseType(provider_job_id=provider_job_id)
@@ -117,7 +118,7 @@ def video__logo_detection_async__launch_job(
     def video__logo_detection_async__get_job_result(
         self, provider_job_id: str
     ) -> AsyncBaseResponseType[LogoDetectionAsyncDataClass]:
-        
+
         index_id, video_id, task_id = provider_job_id.split("_")
 
         task_url = f"{self.base_url}/indexes/{index_id}/videos/{video_id}/logo"
@@ -136,7 +137,9 @@ def video__logo_detection_async__get_job_result(
         if original_response.get("data") is None:
             response = requests.get(status_task_url, headers=self.headers)
             if response.status_code != 200:
-                raise ProviderException(message=response.text, code=response.status_code)
+                raise ProviderException(
+                    message=response.text, code=response.status_code
+                )
 
             task_status = response.json().get("status")
 
@@ -148,7 +151,6 @@ def video__logo_detection_async__get_job_result(
 
         url = f"https://api.twelvelabs.io/v1.1/indexes/{index_id}"
 
-
         response = requests.delete(url, headers=self.headers)
 
         if response.status_code != 204:
@@ -162,9 +164,9 @@ def video__logo_detection_async__get_job_result(
         )
 
     def video__text_detection_async__launch_job(
-            self, file: str, file_url: str = "", language: str = "en"
+        self, file: str, file_url: str = "", language: str = "en"
     ) -> AsyncLaunchJobResponseType:
-        
+
         index_url = f"{self.base_url}/indexes"
         task_url = f"{self.base_url}/tasks"
 
@@ -199,13 +201,13 @@ def video__text_detection_async__launch_job(
             "language": language,
             "disable_video_stream": "false",
         }
-        
+
         # Create video task
         response = requests.post(
             task_url, headers=self.headers, data=video_data_config, files=file_param
         )
-
-
+        if file_stream is not None:
+            file_stream.close()
         if response.status_code != 201:
             raise ProviderException(message=response.text, code=response.status_code)
 
@@ -221,14 +223,13 @@ def video__text_detection_async__launch_job(
         response = response.json()
 
         video_id = response.get("video_id")
- 
+
         provider_job_id = index_id + "_" + video_id + "_" + task_id
 
         return AsyncLaunchJobResponseType(provider_job_id=provider_job_id)
-    
 
     def video__text_detection_async__get_job_result(
-            self, provider_job_id: str
+        self, provider_job_id: str
     ) -> AsyncBaseResponseType[TextDetectionAsyncDataClass]:
         index_id, video_id, task_id = provider_job_id.split("_")
 
@@ -247,10 +248,12 @@ def video__text_detection_async__get_job_result(
 
         if original_response.get("data") is None:
 
-            #check task status
+            # check task status
             response = requests.get(status_task_url, headers=self.headers)
             if response.status_code != 200:
-                raise ProviderException(message=response.text, code=response.status_code)
+                raise ProviderException(
+                    message=response.text, code=response.status_code
+                )
 
             task_status = response.json().get("status")
 
@@ -262,7 +265,6 @@ def video__text_detection_async__get_job_result(
 
         url = f"https://api.twelvelabs.io/v1.1/indexes/{index_id}"
 
-
         response = requests.delete(url, headers=self.headers)
 
         if response.status_code != 204:
diff --git a/edenai_apis/apis/voci/voci_api.py b/edenai_apis/apis/voci/voci_api.py
index 832382b7..c9a8bd80 100644
--- a/edenai_apis/apis/voci/voci_api.py
+++ b/edenai_apis/apis/voci/voci_api.py
@@ -68,17 +68,17 @@ def audio__speech_to_text_async__launch_job(
         #     })
 
         data_config.update(provider_params)
-        file_ = open(file, "rb")
-        response = requests.post(
-            url="https://vcloud.vocitec.com/transcribe",
-            data=data_config,
-            files=[("file", file_)],
-        )
+        with open(file, "rb") as file_:
+            response = requests.post(
+                url="https://vcloud.vocitec.com/transcribe",
+                data=data_config,
+                files=[("file", file_)],
+            )
         if response.status_code != 200:
             raise ProviderException(
                 f"Call to Voci failed.\nResponse Status: {response.status_code}.\n"
                 + f"Response Content: {response.content}",
-                code = response.status_code
+                code=response.status_code,
             )
         else:
             original_response = response.json()
@@ -100,7 +100,7 @@ def audio__speech_to_text_async__get_job_result(
                 raise ProviderException(
                     f"Call to Voci failed.\nResponse Status: {response.status_code}.\n"
                     + f"Response Content: {response.text}",
-                    code = response.status_code
+                    code=response.status_code,
                 )
 
             original_response = response_text.json()
@@ -145,6 +145,6 @@ def audio__speech_to_text_async__get_job_result(
             ):
                 raise AsyncJobException(
                     reason=AsyncJobExceptionReason.DEPRECATED_JOB_ID,
-                    code = response.status_code
+                    code=response.status_code,
                 )
             raise ProviderException(response.text)