Update gofilecli.py

.github/workflows/release.yml

@@ -41,20 +41,18 @@ jobs:
       - name: Install Dependencies
         run: |
           pip install -r requirements.txt
+          pip install nuitka
 
       - name: Build Executable with Nuitka
-        uses: Nuitka/Nuitka-Action@main
+        run: |
-        with:
+          python -m nuitka --onefile --assume-yes-for-downloads --output-dir=dist gofilecli.py --include-data-files=./assets/sounds/Blow_edited.wav=assets/sounds/Blow_edited.wav
-          nuitka-version: main
-          script-name: gofilecli.py
-          onefile: true
 
       - name: Upload Artifact[win-x64]
         uses: actions/upload-artifact@v3.1.3
         with:
           name: GoFileCLI_win-x64
           path: |
-            build/gofilecli.exe
+            dist/gofilecli.exe
   
   build-linux-x64:
     runs-on: ubuntu-latest
@@ -74,24 +72,23 @@ jobs:
       
       - name: Install Dependencies
         run: |
+          sudo apt-get install -y libasound2-dev
           pip install -r requirements.txt
+          pip install nuitka
 
       - name: Build Executable with Nuitka
-        uses: Nuitka/Nuitka-Action@main
+        run: |
-        with:
+          python -m nuitka --onefile --assume-yes-for-downloads --output-dir=dist gofilecli.py --include-data-files=./assets/sounds/Blow_edited.wav=assets/sounds/Blow_edited.wav
-          nuitka-version: main
-          script-name: gofilecli.py
-          onefile: true
         
       - name: Rename Executable
-        run: mv build/gofilecli.bin build/gofilecli
+        run: mv dist/gofilecli.bin dist/gofilecli
 
       - name: Upload Artifact[linux-x64]
         uses: actions/upload-artifact@v3.1.3
         with:
           name: GoFileCLI_linux-x64
           path: |
-            build/gofilecli
+            dist/gofilecli
     
   build-macos:
     runs-on: macos-latest
@@ -116,8 +113,8 @@ jobs:
 
       - name: Build Executable with Nuitka
         run: |
-          python -m nuitka --onefile --assume-yes-for-downloads --output-dir=dist --macos-target-arch=arm64 gofilecli.py
+          python -m nuitka --onefile --assume-yes-for-downloads --output-dir=dist --macos-target-arch=arm64 gofilecli.py --include-data-files=./assets/sounds/Blow_edited.wav=assets/sounds/Blow_edited.wav
-          python -m nuitka --onefile --assume-yes-for-downloads --output-dir=dist_x86_64 --macos-target-arch=x86_64 gofilecli.py
+          python -m nuitka --onefile --assume-yes-for-downloads --output-dir=dist_x86_64 --macos-target-arch=x86_64 gofilecli.py --include-data-files=./assets/sounds/Blow_edited.wav=assets/sounds/Blow_edited.wav
       
       - name: Rename Executable
         run: |

.gitignore

@@ -136,3 +136,4 @@ encrypt.py
 assets/sounds/Blow.aiff
 assets/sounds/Blow.mp3
 assets/sounds/Blow.wav
+/VP8SWj

README.md

@@ -53,6 +53,7 @@ gofilecli -d https://gofile.io/d/XXXXX # to download a folder
 ```
 
 # To do :
+- KeyboardInterrupt + Lost connexion
 - error-rateLimit
 - env via CLI
 - finish README.md

gofilecli.py

@@ -6,17 +6,69 @@ import argparse
 import os
 import logging
 import sys
-from dotenv import load_dotenv, set_key
 import platform
 import subprocess
 import sys
 import simpleaudio as sa
+from tqdm import tqdm
+import json
+from dotenv import load_dotenv
+
+# Suppress ALSA warnings
+os.environ['SDL_AUDIODRIVER'] = 'dummy'
+os.environ['AUDIODEV'] = 'null'
 
 
-def play_sound():
+def reqst(url, method ,headers=None, data=None, files=None, params=None, json=None, logger=None):
-    wave_obj = sa.WaveObject.from_wave_file("assets/sounds/Blow_edited.wav")
+    try:
-    play_obj = wave_obj.play()
+        if method == "get":
-    play_obj.wait_done()
+            response = requests.get(url, headers=headers, data=data, params=params, json=json)
+        elif method == "post":
+            response = requests.post(url, headers=headers, data=data, files=files, params=params, json=json)
+        elif method == "put":
+            response = requests.put(url, headers=headers, data=data, files=files, params=params, json=json)
+        elif method == "delete":
+            response = requests.delete(url, headers=headers, data=data, files=files, params=params, json=json)
+        logger.debug(f"Request to {url} with method {method} returned status code {response.status_code}")
+        json_response = response.json()  # If response content is not JSON, this will raise a ValueError
+        return json_response
+    except requests.exceptions.HTTPError as http_err:
+        logger.debug(f"Response: {response.text}")
+        logger.error(f"HTTP error occurred: {http_err}")  # Handles HTTP errors (e.g., 404, 500)
+        sys.exit()
+    except requests.exceptions.ConnectionError as conn_err:
+        logger.debug(f"Response: {response.text}")
+        logger.error(f"Connection error occurred: {conn_err}")  # Handles network-related errors
+        sys.exit()
+    except requests.exceptions.Timeout as timeout_err:
+        logger.debug(f"Response: {response.text}")
+        logger.error(f"Timeout error occurred: {timeout_err}")  # Handles request timeouts
+        sys.exit()
+    except requests.exceptions.RequestException as req_err:
+        logger.debug(f"Response: {response.text}")
+        logger.error(f"An error occurred: {req_err}")  # Catches any other requests-related errors
+        sys.exit()
+    except ValueError as json_err:
+        logger.debug(f"Response: {response.text}")
+        logger.error(f"JSON decode error: {json_err}")  # Handles issues with JSON decoding
+        sys.exit()
+
+
+def load_file(file_name: str) -> str:
+    """
+    Get the correct path to a file, regardless of development or compiled mode.
+    """
+    return os.path.join(os.path.dirname(__file__), file_name)
+
+
+def play_sound(logger):
+    try:
+        sound_path = load_file("assets/sounds/Blow_edited.wav")
+        wave_obj = sa.WaveObject.from_wave_file(sound_path)
+        play_obj = wave_obj.play()
+        play_obj.wait_done()
+    except Exception as e:
+        logger.debug(f"An error occurred while playing sound: {e}")
 
 
 def set_env_var_unix(name, value, shell="bash"):
@@ -99,7 +151,8 @@ def check_folderPath(path):
 
 def getservers(logger):
     servers = []
-    response = requests.get("https://api.gofile.io/servers").json()
+    # response = requests.get("https://api.gofile.io/servers").json()
+    response = reqst("https://api.gofile.io/servers", logger=logger, method="get")
     if response["status"] == "ok":
         for server in response["data"]["servers"]:
             servers.append(server["name"])
@@ -110,22 +163,65 @@ def getservers(logger):
         return None
     
 
+def ping_server(url, logger, num_requests=4, delay=0.1):
+    response_times = []
+    for _ in range(num_requests):
+        try:
+            start_time = time.time()
+            response = requests.head(url)
+            response_time = time.time() - start_time
+            if response.status_code == 200:
+                response_times.append(response_time)
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error: {e}")
+        time.sleep(delay)
+    if response_times:
+        avg_response = sum(response_times) / len(response_times)
+        return avg_response
+    else:
+        return float('inf')
+    
+
+def test_servers(servers, logger):
+    best_server = None
+    best_time = float('inf')
+    for server in servers:
+        logger.debug(f"Pinging {server}...")
+        url = f"https://{server}.gofile.io"
+        avg_time = ping_server(url, logger)
+        logger.debug(f"Average response time for {server}: {avg_time:.2f} ms")
+        if avg_time < best_time:
+            best_time = avg_time
+            best_server = server
+    if best_server:
+        logger.debug(f"\nThe best server is {best_server} with an average response time of {best_time:.2f} ms.")
+    else:
+        logger.error("All pings failed.")
+    return best_server
+
+
 def get_stats(logger):
     headers = {'authorization': f'Bearer {TOKEN}',}
-    data = requests.get(f'https://api.gofile.io/accounts/{ACCOUNT_ID}', headers=headers).json()
+    # data = requests.get(f'https://api.gofile.io/accounts/{ACCOUNT_ID}', headers=headers).json()
-    stats = data["data"]["statsCurrent"]
+    data = reqst(f'https://api.gofile.io/accounts/{ACCOUNT_ID}', headers=headers, logger=logger, method="get")
-    logger.info("Account stats:")
+    if data["status"] == "ok":
-    logger.info(f"Total files: {stats['fileCount']}")
+        stats = data["data"]["statsCurrent"]
-    logger.info(f"Total folders: {stats['folderCount']}")
+        logger.info("Account stats:")
-    size = file_size(num_bytes=stats['storage'])
+        logger.info(f"Total files: {stats['fileCount']}")
-    logger.info(f"Total size: {size}")
+        logger.info(f"Total folders: {stats['folderCount']}")
-    traffic = file_size(num_bytes=stats['trafficWebDownloaded'])
+        size = file_size(num_bytes=stats['storage'])
-    logger.info(f"Total traffic: {traffic}")
+        logger.info(f"Total size: {size}")
+        traffic = file_size(num_bytes=stats['trafficWebDownloaded'])
+        logger.info(f"Total traffic: {traffic}")
+    else:
+        logger.error(f"{data}")
+        return None
 
 
 def get_rootfolder(logger):
     headers = {'authorization': f'Bearer {TOKEN}',}
-    data = requests.get(f'https://api.gofile.io/accounts/{ACCOUNT_ID}', headers=headers).json()
+    # data = requests.get(f'https://api.gofile.io/accounts/{ACCOUNT_ID}', headers=headers).json()
+    data = reqst(f'https://api.gofile.io/accounts/{ACCOUNT_ID}', headers=headers, logger=logger, method="get")
     root_folder = data.get("data", {}).get("rootFolder", {})
     if root_folder:
         return root_folder
@@ -137,7 +233,8 @@ def get_rootfolder(logger):
 def get_code(folderId, logger):
     headers = {'authorization': f'Bearer {TOKEN}',}
     params = (('wt', '4fd6sg89d7s6'),('cache', 'false'),)
-    data = requests.get(f'https://api.gofile.io/contents/{folderId}', headers=headers, params=params).json()
+    # data = requests.get(f'https://api.gofile.io/contents/{folderId}', headers=headers, params=params).json()
+    data = reqst(f'https://api.gofile.io/contents/{folderId}', headers=headers, params=params, logger=logger, method="get")
     code = data.get("data", {}).get("code", {})
     if code:
         return code
@@ -149,7 +246,8 @@ def get_code(folderId, logger):
 def get_children(id, logger):
     headers = {'authorization': f'Bearer {TOKEN}',}
     params = (('wt', '4fd6sg89d7s6'),('cache', 'false'),)
-    data = requests.get(f'https://api.gofile.io/contents/{id}', headers=headers, params=params).json()
+    # data = requests.get(f'https://api.gofile.io/contents/{id}', headers=headers, params=params).json()
+    data = reqst(f'https://api.gofile.io/contents/{id}', headers=headers, params=params, logger=logger, method="get")
     children = data.get("data", {}).get("children", {})
     if children:
         return children
@@ -169,11 +267,12 @@ def createfolder(parentFolderId, folderName, logger):
         data = {"parentFolderId": parentFolderId, "folderName": folderName}
     else:
         data = {"parentFolderId": parentFolderId}
-    response = requests.post("https://api.gofile.io/contents/createFolder", headers=headers, json=data).json()
+    # response = requests.post("https://api.gofile.io/contents/createFolder", headers=headers, json=data).json()
+    response = reqst("https://api.gofile.io/contents/createFolder", headers=headers, json=data, logger=logger, method="post")
     if response["status"] == "ok":
         name = response["data"]["name"]
         code = response["data"]["code"]
-        folderId = response["data"]["folderId"]
+        folderId = response["data"]["id"]
         logger.debug(f"""Folder {name} created with code {code} and folderId {folderId}""")
         return folderId
     else:
@@ -181,15 +280,57 @@ def createfolder(parentFolderId, folderName, logger):
         return None
 
 
+def read_in_chunks(file_object, CHUNK_SIZE):
+    while True:
+        data = file_object.read(CHUNK_SIZE)
+        if not data:
+            break
+        yield data
+
+
 def uploadfile(serverName, folderId, filePath, logger):
-    headers = {"Authorization": f"Bearer {TOKEN}"}
+    # reference : https://api.video/blog/tutorials/upload-a-big-video-file-using-python/
-    files = {
-        'file': (filePath, open(filePath, 'rb')),
-        'folderId': (None, folderId),
-    }
     start_time = time.time()
-    response = requests.post(f"https://{serverName}.gofile.io/contents/uploadfile", headers=headers, files=files).json()
+    # CHUNK_SIZE = 6000000
+    # content_size = os.stat(filePath).st_size
+    # f = open(filePath, "rb")
+    # index = 0
+    # offset = 0
+    # headers = {"Authorization": f"Bearer {TOKEN}", 'content-type': 'multipart/form-data',}
+    # with tqdm(total=content_size, unit='B', unit_scale=True, desc='Uploading', leave=False) as progress_bar:
+    #     for chunk in read_in_chunks(f, CHUNK_SIZE):
+    #         offset = index + len(chunk)
+    #         headers['Content-Range'] = 'bytes %s-%s/%s' % (index, offset - 1, content_size)
+    #         index = offset
+    #         try:
+    #             # file = {"file": chunk, 'folderId': (None, folderId)}
+    #             # response = requests.post(f"https://{serverName}.gofile.io/contents/uploadfile", files=file, headers=headers)
+    #             # files = {"file": chunk}
+    #             # data = {"folderId": folderId}
+    #             files = {"file": chunk,}
+    #             response = requests.post(f"https://{serverName}.gofile.io/contents/uploadfile",files=files,headers=headers)
+    #             logger.debug("r: %s, Content-Range: %s" % (response, headers['Content-Range']))
+    #             progress_bar.update(len(chunk))
+    #         except Exception as e:
+    #             logger.error(f"Error: {e}")
+    # logger.debug(f"{response.text}")
+    # response = response.json()
+    command = [
+        "curl",
+        "-X", "POST",
+        f"https://{serverName}.gofile.io/contents/uploadfile",
+        "-H", f"Authorization: Bearer {TOKEN}",
+        "-F", f"file=@{filePath}",
+        "-F", f"folderId={folderId}",
+    ]
+    response = subprocess.run(command, capture_output=True, text=True)
+    try:
+        response_json = json.loads(response.stdout)
+    except json.JSONDecodeError:
+        logger.error("Failed to parse response as JSON.")
+        return None
     speed, elapsed_time = calculate_upload_speed(filePath, start_time)
+    response = response_json
     if response["status"] == "ok":
         logger.debug(response)
         name = response["data"]["name"]
@@ -202,10 +343,11 @@ def uploadfile(serverName, folderId, filePath, logger):
         return None
 
 
-def actionFolder(folderId, attributeValue):
+def actionFolder(folderId, attributeValue, logger):
     headers = {"Content-Type": "application/json", "Authorization": f"Bearer {TOKEN}"}
     data = {"attribute": "public", "attributeValue": attributeValue}
-    response = requests.put(f"https://api.gofile.io/contents/{folderId}/update", headers=headers, json=data).json()
+    # response = requests.put(f"https://api.gofile.io/contents/{folderId}/update", headers=headers, json=data).json()
+    response = reqst(f"https://api.gofile.io/contents/{folderId}/update", headers=headers, json=data, logger=logger, method="put")
     if response["status"] == "ok":
         return True
     else:
@@ -227,10 +369,18 @@ def upload(filePath, folderPath, folderName, parentFolderId, private, logger):
         else:
             logger.error("File not found")
             sys.exit()
-
+    
+    # Getting servers
     servers = getservers(logger)
     if servers:
-        serverName = random.choice(servers)
+        if len(servers) > 1: # If there are multiple servers, check the size of the files
+            if max([os.path.getsize(file) for file in files]) > 100 * 1024 * 1024:  # 100 MB in bytes
+                logger.debug("One of the file have a size > 100 MB. Fetching best server...")
+                serverName = test_servers(servers, logger)
+            else:
+                serverName = random.choice(servers)
+        else:
+            serverName = servers[0]
         logger.debug(f"Selected server: {serverName}")
 
         if folderName and parentFolderId:
@@ -247,30 +397,33 @@ def upload(filePath, folderPath, folderName, parentFolderId, private, logger):
             parentFolderId = parentFolderId
             logger.debug(f"FolderId: {parentFolderId}")
         else:
-            parentFolderId = None
+            # parentFolderId = PRIVATE_PARENT_ID
+            logger.info(f"Creating folder: {folderName} for PRIVATE_PARENT_ID: {PRIVATE_PARENT_ID}")
+            folderId = createfolder(PRIVATE_PARENT_ID, None, logger)
+            parentFolderId = folderId
             logger.debug(f"FolderId: {parentFolderId}")
 
         for file in files:
             if parentFolderId:
                 logger.info(f"Uploading file: '{file}' ({file_size(file)}) to: '{parentFolderId}' on: '{serverName}'")
             else:
-                logger.info(f"Uploading file: {file} ({file_size(file)}) on: {serverName}")
+                logger.info(f"Uploading file: '{file}' ({file_size(file)}) on: '{serverName}'")
             downloadPage, parentFolderId, speed, elapsed_time = uploadfile(serverName, parentFolderId, file, logger)
             logger.info(f"File uploaded to: {downloadPage} in {elapsed_time} at {speed}")
 
         if not private:
-            action = actionFolder(parentFolderId, "true")
+            action = actionFolder(parentFolderId, "true", logger)
             if action:
                 logger.info("Folder made public")
             else:
                 logger.error(f"{action}")
         else:
-            action = actionFolder(parentFolderId, "false")
+            action = actionFolder(parentFolderId, "false", logger)
             if action:
                 logger.info("Folder made private")
             else:
                 logger.error(f"{action}")
-        play_sound()
+        play_sound(logger)
     else:
         time.sleep(10)
         sys.exit()
@@ -279,9 +432,15 @@ def upload(filePath, folderPath, folderName, parentFolderId, private, logger):
 def downloadFile(downloadUrl, path, logger):
     start_time = time.time()
     headers = {"Authorization": f"Bearer {TOKEN}"}
-    response = requests.get(downloadUrl, headers=headers)
+    response = requests.get(downloadUrl, headers=headers, stream=True)
-    with open(path, "wb") as f:
+    # response = reqst(downloadUrl, headers=headers, logger=logger, method="get")
-        f.write(response.content)
+    total_size = int(response.headers.get('content-length', 0))
+    
+    with open(path, "wb") as f, tqdm(total=total_size, unit='B', unit_scale=True, desc='Downloading', leave=False) as progress_bar:
+        for chunk in response.iter_content(1024):
+            if chunk:
+                f.write(chunk)
+                progress_bar.update(len(chunk))
     logger.debug(f"File downloaded: {path}")
     speed, elapsed_time = calculate_upload_speed(path, start_time)
     return speed, elapsed_time
@@ -326,7 +485,7 @@ def download(folderId, folderPath, force, logger):
             speed, elapsed_time = downloadFile(downloadUrl, path, logger)
             logger.info(f"File download to: {path} in {elapsed_time} at {speed}")
         nbdone += 1
-    play_sound()
+    play_sound(logger)
 
 
 def opt():
@@ -359,6 +518,7 @@ def init():
     logger = logging.getLogger(__name__)
 
     load_dotenv()
+
     global TOKEN
     global PRIVATE_PARENT_ID
     global ACCOUNT_ID
@@ -424,4 +584,8 @@ def init():
 
 
 if __name__ == "__main__":
-    init()
+    try:
+        init()
+    except KeyboardInterrupt:
+        print("\nExiting...")
+        sys.exit()

requirements.txt

@@ -1,3 +1,5 @@
 cryptography==39.0.1
 python-dotenv==1.0.1
 Requests==2.32.3
+simpleaudio==1.0.4
+tqdm==4.65.0

scripts/build.sh

@@ -10,7 +10,8 @@ tag=$1
 
 source ~/miniconda3/etc/profile.d/conda.sh
 conda activate 310
-python -m nuitka --onefile --assume-yes-for-downloads --output-dir=dist --static-libpython=no gofilecli.py 
+pip install -r requirements.txt
+python -m nuitka --onefile --assume-yes-for-downloads --output-dir=dist --static-libpython=no gofilecli.py --include-data-files=./assets/sounds/Blow_edited.wav=assets/sounds/Blow_edited.wav
 mv dist/gofilecli.bin ./gofilecli
 
 mkdir -p GoFileCLI_linux-arm64