Update gopload.py

gopload.py

@@ -4,8 +4,42 @@ import time
 import argparse
 import os
 from dotenv import load_dotenv
-from tqdm import tqdm
+import logging
-from requests_toolbelt.multipart.encoder import MultipartEncoder, MultipartEncoderMonitor
+
+
+def format_file_size(file):
+    file_size_bytes = os.path.getsize(file)
+    size_in_mb = file_size_bytes / (1024 * 1024)
+    size_in_gb = file_size_bytes / (1024 * 1024 * 1024)
+    if size_in_gb >= 1:
+        return size_in_gb, "GB"
+    else:
+        return size_in_mb, "MB"
+
+
+def file_size(file):
+    size, unit = format_file_size(file)
+    return f"{size:.2f} {unit}"
+    
+
+def calculate_upload_speed(file, start_time):
+    elapsed_time_seconds = time.time() - start_time
+    file_size, size_unit = format_file_size(file)
+    if size_unit == "GB":
+        average_speed = file_size / elapsed_time_seconds  # GB/s
+        speed_unit = "GB/s"
+    else:
+        average_speed = file_size / elapsed_time_seconds  # MB/s
+        speed_unit = "MB/s"
+
+    if elapsed_time_seconds >= 60:
+        minutes = int(elapsed_time_seconds // 60)
+        seconds = int(elapsed_time_seconds % 60)
+        elapsed_time = f"{minutes}m {seconds}s"
+    else:
+        elapsed_time = f"{elapsed_time_seconds:.2f}s"
+    
+    return f"{average_speed:.2f} {speed_unit}", elapsed_time
 
 
 def get_file_paths(folderPath):
@@ -37,72 +71,43 @@ def createfolder(parentFolderId, folderName, logger):
         data = {"parentFolderId": parentFolderId, "folderName": folderName}
     else:
         data = {"parentFolderId": parentFolderId}
-    response = requests.post(
+    response = requests.post("https://api.gofile.io/contents/createFolder", headers=headers, json=data).json()
-        "https://api.gofile.io/contents/createFolder", headers=headers, json=data
-    ).json()
     if response["status"] == "ok":
         name = response["data"]["name"]
         code = response["data"]["code"]
         folderId = response["data"]["folderId"]
-        logger.debug(
+        logger.debug(f"""Folder {name} created with code {code} and folderId {folderId}""")
-            f"""Folder {name} created with code {code} and folderId {folderId}"""
-        )
         return folderId
     else:
         logger.error(f"{response}")
         return None
 
 
-# def uploadfile(serverName, folderId, filePath, logger):
-#     headers = {"Authorization": f"Bearer {TOKEN}"}
-#     files = {
-#         'file': (filePath, open(filePath, 'rb')),
-#         'folderId': (None, folderId),
-#     }
-#     response = requests.post(f"https://{serverName}.gofile.io/contents/uploadfile", headers=headers, files=files).json()
-#     if response["status"] == "ok":
-#         logger.debug(response)
-#         name = response["data"]["name"]
-#         downloadPage = response["data"]["downloadPage"]
-#         parentFolderId = response["data"]["parentFolder"]
-#         logger.debug(f"""File {name} uploaded to {downloadPage}""")
-#         return downloadPage, parentFolderId
-#     else:
-#         logger.error(f"{response}")
-#         return None
-    
 def uploadfile(serverName, folderId, filePath, logger):
-    # file_size = os.path.getsize(filePath)
+    start_time = time.time()
-    with open(filePath, "rb") as fd:
-        encoder = MultipartEncoder(
-            fields={
-                'file': (filePath, fd, 'application/octet-stream'),
-                'folderId': folderId,
-            }
-        )
-        with tqdm(desc="Uploading", total=encoder.len, unit="B", unit_scale=True, unit_divisor=1024) as t:
-            monitor = MultipartEncoderMonitor(encoder, lambda monitor: t.update(monitor.bytes_read))
     headers = {"Authorization": f"Bearer {TOKEN}"}
-            response = requests.post(f"https://{serverName}.gofile.io/contents/uploadfile", headers=headers, data=monitor).json()
+    files = {
-            response.raise_for_status()
+        'file': (filePath, open(filePath, 'rb')),
-
+        'folderId': (None, folderId),
+    }
+    response = requests.post(f"https://{serverName}.gofile.io/contents/uploadfile", headers=headers, files=files).json()
+    speed, elapsed_time = calculate_upload_speed(filePath, start_time)
     if response["status"] == "ok":
         logger.debug(response)
         name = response["data"]["name"]
         downloadPage = response["data"]["downloadPage"]
         parentFolderId = response["data"]["parentFolder"]
         logger.debug(f"""File {name} uploaded to {downloadPage}""")
-        return downloadPage, parentFolderId
+        return downloadPage, parentFolderId, speed, elapsed_time
     else:
         logger.error(f"{response}")
         return None
 
+
 def actionFolder(folderId, attributeValue):
     headers = {"Content-Type": "application/json", "Authorization": f"Bearer {TOKEN}"}
     data = {"attribute": "public", "attributeValue": attributeValue}
-    response = requests.put(
+    response = requests.put(f"https://api.gofile.io/contents/{folderId}/update", headers=headers, json=data).json()
-        f"https://api.gofile.io/contents/{folderId}/update", headers=headers, json=data
-    ).json()
     if response["status"] == "ok":
         return True
     else:
@@ -136,9 +141,7 @@ def main(filePath, folderPath, folderName, parentFolderId, private, logger):
             logger.debug(f"FolderId: {folderId}")
             parentFolderId = folderId
         elif folderName:
-            logger.info(
+            logger.info(f"Creating folder: {folderName} for PRIVATE_PARENT_ID: {PRIVATE_PARENT_ID}")
-                f"Creating folder: {folderName} for PRIVATE_PARENT_ID: {PRIVATE_PARENT_ID}"
-            )
             folderId = createfolder(PRIVATE_PARENT_ID, folderName, logger)
             logger.debug(f"FolderId: {folderId}")
             parentFolderId = folderId
@@ -151,15 +154,11 @@ def main(filePath, folderPath, folderName, parentFolderId, private, logger):
 
         for file in files:
             if parentFolderId:
-                logger.info(
+                logger.info(f"Uploading file: '{file}' ({file_size(file)}) to: '{parentFolderId}' on: '{serverName}'")
-                    f"Uploading file: '{file}' to: '{parentFolderId}' on: '{serverName}'"
-                )
             else:
-                logger.info(f"Uploading file: {file} on: {serverName}")
+                logger.info(f"Uploading file: {file} ({file_size(file)}) on: {serverName}")
-            downloadPage, parentFolderId = uploadfile(
+            downloadPage, parentFolderId, speed, elapsed_time = uploadfile(serverName, parentFolderId, file, logger)
-                serverName, parentFolderId, file, logger
+            logger.info(f"File uploaded to: {downloadPage} in {elapsed_time} at {speed}")
-            )
-            logger.info(f"Download page: {downloadPage}")
 
         if not private:
             action = actionFolder(parentFolderId, "true")
@@ -180,41 +179,16 @@ def main(filePath, folderPath, folderName, parentFolderId, private, logger):
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Upload a file to GoFile.")
-    parser.add_argument(
+    parser.add_argument("--file", "-i", type=str, help="Path to the file to be uploaded")
-        "--file", "-i", type=str, help="Path to the file to be uploaded"
+    parser.add_argument("--folder", "-f", type=str, help="Path to the folder to be uploaded")
-    )
+    parser.add_argument("--name", "-n", type=str, help="Name of the folder on the server")
-    parser.add_argument(
+    parser.add_argument("--parent", "-p", type=str, help="Folder id to upload the file to")
-        "--folder", "-f", type=str, help="Path to the folder to be uploaded"
+    parser.add_argument("--private","-pr",action="store_true",help="Upload to private folder default=False",)
-    )
+    parser.add_argument("--log-level",type=str,choices=["DEBUG", "ERROR", "INFO", "OFF", "WARN"],default="INFO",help="Set log level [default: INFO]",)
-    parser.add_argument(
-        "--name", "-n", type=str, help="Name of the folder on the server"
-    )
-    parser.add_argument(
-        "--parent", "-p", type=str, help="Folder id to upload the file to"
-    )
-    parser.add_argument(
-        "--private",
-        "-pr",
-        action="store_true",
-        help="Upload to private folder default=False",
-    )
-    parser.add_argument(
-        "--log-level",
-        type=str,
-        choices=["DEBUG", "ERROR", "INFO", "OFF", "WARN"],
-        default="INFO",
-        help="Set log level [default: INFO]",
-    )
     args = parser.parse_args()
 
-    import logging
-
     log_format = "%(asctime)s %(levelname)s: %(message)s"
-    logging.basicConfig(
+    logging.basicConfig(level=getattr(logging, args.log_level.upper()),format=log_format,datefmt="%H:%M:%S",)
-        level=getattr(logging, args.log_level.upper()),
-        format=log_format,
-        datefmt="%H:%M:%S",
-    )
     logger = logging.getLogger(__name__)
 
     load_dotenv()
@@ -224,9 +198,7 @@ if __name__ == "__main__":
         logger.error("Error: TOKEN not found, create a .env file with TOKEN")
         exit(1)
     if not PRIVATE_PARENT_ID:
-        logger.error(
+        logger.error("Error: PRIVATE_PARENT_ID not found, create a .env file with PRIVATE_PARENT_ID")
-            "Error: PRIVATE_PARENT_ID not found, create a .env file with PRIVATE_PARENT_ID"
-        )
         exit(1)
 
     if args.name and not args.parent: