mirror of
https://github.com/NohamR/GoFileCLI.git
synced 2025-05-24 00:49:00 +00:00
246 lines
8.4 KiB
Python
246 lines
8.4 KiB
Python
import requests
|
|
import random
|
|
import time
|
|
import argparse
|
|
import os
|
|
from dotenv import load_dotenv
|
|
from tqdm import tqdm
|
|
from requests_toolbelt.multipart.encoder import MultipartEncoder, MultipartEncoderMonitor
|
|
|
|
|
|
def get_file_paths(folderPath):
|
|
filePaths = []
|
|
for root, directories, files in os.walk(folderPath):
|
|
for file in files:
|
|
if ".DS_Store" not in file:
|
|
file_path = os.path.join(root, file)
|
|
filePaths.append(file_path)
|
|
return filePaths
|
|
|
|
|
|
def getservers(logger):
|
|
servers = []
|
|
response = requests.get("https://api.gofile.io/servers").json()
|
|
if response["status"] == "ok":
|
|
for server in response["data"]["servers"]:
|
|
servers.append(server["name"])
|
|
logger.debug(f"{response}")
|
|
return servers
|
|
else:
|
|
logger.error(f"{response}")
|
|
return None
|
|
|
|
|
|
def createfolder(parentFolderId, folderName, logger):
|
|
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {TOKEN}"}
|
|
if folderName:
|
|
data = {"parentFolderId": parentFolderId, "folderName": folderName}
|
|
else:
|
|
data = {"parentFolderId": parentFolderId}
|
|
response = requests.post(
|
|
"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(
|
|
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)
|
|
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()
|
|
response.raise_for_status()
|
|
|
|
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 actionFolder(folderId, attributeValue):
|
|
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()
|
|
if response["status"] == "ok":
|
|
return True
|
|
else:
|
|
return response
|
|
|
|
|
|
def main(filePath, folderPath, folderName, parentFolderId, private, logger):
|
|
files = []
|
|
logger.info("Starting upload")
|
|
logger.debug("File: %s", filePath)
|
|
if folderPath:
|
|
files = get_file_paths(folderPath)
|
|
if not files:
|
|
logger.error("No files found in folder")
|
|
exit(1)
|
|
else:
|
|
if os.path.exists(filePath):
|
|
files = [filePath]
|
|
else:
|
|
logger.error("File not found")
|
|
exit(1)
|
|
|
|
servers = getservers(logger)
|
|
if servers:
|
|
serverName = random.choice(servers)
|
|
logger.debug(f"Selected server: {serverName}")
|
|
|
|
if folderName and parentFolderId:
|
|
logger.info(f"Creating folder: {folderName} for: {parentFolderId}")
|
|
folderId = createfolder(parentFolderId, folderName, logger)
|
|
logger.debug(f"FolderId: {folderId}")
|
|
parentFolderId = folderId
|
|
elif folderName:
|
|
logger.info(
|
|
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
|
|
elif parentFolderId and not folderName:
|
|
parentFolderId = parentFolderId
|
|
logger.debug(f"FolderId: {parentFolderId}")
|
|
else:
|
|
parentFolderId = None
|
|
logger.debug(f"FolderId: {parentFolderId}")
|
|
|
|
for file in files:
|
|
if parentFolderId:
|
|
logger.info(
|
|
f"Uploading file: '{file}' to: '{parentFolderId}' on: '{serverName}'"
|
|
)
|
|
else:
|
|
logger.info(f"Uploading file: {file} on: {serverName}")
|
|
downloadPage, parentFolderId = uploadfile(
|
|
serverName, parentFolderId, file, logger
|
|
)
|
|
logger.info(f"Download page: {downloadPage}")
|
|
|
|
if not private:
|
|
action = actionFolder(parentFolderId, "true")
|
|
if action:
|
|
logger.info("Folder made public")
|
|
else:
|
|
logger.error(f"{action}")
|
|
else:
|
|
action = actionFolder(parentFolderId, "false")
|
|
if action:
|
|
logger.info("Folder made private")
|
|
else:
|
|
logger.error(f"{action}")
|
|
else:
|
|
time.spleed(10)
|
|
exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(description="Upload a file to GoFile.")
|
|
parser.add_argument(
|
|
"--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(
|
|
"--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(
|
|
level=getattr(logging, args.log_level.upper()),
|
|
format=log_format,
|
|
datefmt="%H:%M:%S",
|
|
)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
load_dotenv()
|
|
TOKEN = os.getenv("TOKEN")
|
|
PRIVATE_PARENT_ID = os.getenv("PRIVATE_PARENT_ID")
|
|
if not TOKEN:
|
|
logger.error("Error: TOKEN not found, create a .env file with TOKEN")
|
|
exit(1)
|
|
if not PRIVATE_PARENT_ID:
|
|
logger.error(
|
|
"Error: PRIVATE_PARENT_ID not found, create a .env file with PRIVATE_PARENT_ID"
|
|
)
|
|
exit(1)
|
|
|
|
if args.name and not args.parent:
|
|
logger.warning("Parent folder id not specified, PRIVATE_PARENT_ID will be used")
|
|
|
|
if args.file:
|
|
if args.folder:
|
|
logger.error("Both file and folder specified")
|
|
exit(1)
|
|
else:
|
|
main(args.file, args.folder, args.name, args.parent, args.private, logger)
|
|
else:
|
|
if args.folder:
|
|
main(args.file, args.folder, args.name, args.parent, args.private, logger)
|
|
else:
|
|
logger.error("No file or folder specified")
|
|
exit(1) |