def uploadToMega():
mega = Mega()
m = mega.login(MEGA_EMAIL, MEGA_PASSWORD)
r = requests.get(FILE_URL_CSV, stream=True)
print('Pass request')
now = datetime.now()
dt_string = now.strftime("%d-%m-%Y_%H-%M-%S.csv")
name_folder = dt_string[0:10]
folder_path = f'/CSV/{name_folder}'
with open(dt_string, "wb") as csv:
for chunk in r.iter_content(chunk_size=1024):
if chunk:
csv.write(chunk)
print('Pass create CSV')
folder = m.find(folder_path)
if folder == None:
m.create_folder(folder_path)
print('Create folder not existing!')
folder = m.find(folder_path)
m.upload(dt_string, folder[0])
print('Upload File success!')
else:
print('No need to create the folder Again!')
m.upload(dt_string, folder[0])
print('Upload file finish!')
print('Pass uploading file')
os.remove(dt_string)
print('Pass clean file')
def mega(folder_name):
mega_ = Mega()
mega_.login(email=os.environ['EMAIL'], password=os.environ['PASS'])
created_nodes = mega_.create_folder(folder_name)
yield mega_
node_id = next(iter(created_nodes.values()))
mega_.destroy(node_id)
def login(self,args,kwargs) :
"""login to mega"""
if 'email' in kwargs :
self._email = kwargs['email']
self.save_config()
elif len(args) > 0 :
self._email = args[0]
self.save_config()
if self._email is None :
self.errorexit(_('need email to login'))
sys.stdout.write('Login : [%s]\n' % (self._email,))
password = getpass.getpass()
if len(password) == 0 :
self.errorexit(_('need a password to login'))
self._api = Mega()
try :
self._api.login(self._email,password)
except Exception :
self.errorexit(_('login failled'))
self._sid = self._api.sid
self._master_key = self._api.master_key
self.save_config()
self.status('login success')
def get_api(self) :
if (self._api is None) :
if (self._sid != '') :
self._api = Mega()
self._api.sid = self._sid
self._api.master_key = self._master_key
self._api.sequence_num = self._sequence_num
self._api.users_keys = {}
elif self._login is not None and self._password is not None :
self._api = Mega()
try :
self._api.login(self._login, self._password)
except Exception :
self.errorexit(_('login failled'))
return self._api
def download_exoplanet_data(self):
# os.system("git clone https://github.com/jeroenmeulenaar/python3-mega.git")
# os.system(os.environ['HOME']+"/anaconda3/envs/tf_gpu/bin/pip install -r python3-mega/requirements.txt")
import subprocess
pip = os.environ['HOME'] + '/anaconda3/envs/tf_env/bin/pip'
git = 'git+https://github.com/jeroenmeulenaar/python3-mega.git'
command = pip + ' install ' + git
prog = subprocess.Popen(command,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out, err = prog.communicate()
from mega import Mega
mega = Mega()
m = Mega.from_ephemeral()
print("Downaling File...")
# Download normalized data
m.download_from_url(
'https://mega.nz/#!O6A3wS4a!vTsMQZxl3VnbPbbksfJ0243oWDxv5z1g1zy4XIow4HQ'
)
# os.system('mv exoplanet_spectral_database_normalized.joblib.save '+os.environ['HOME']+'/.vaelstmpredictor/data')
spec_file_name = 'exoplanet_spectral_folded_database_normalized.joblib.save'
os.rename(spec_file_name, self.default_train_file + spec_file_name)
def test():
#user details
email = '*****@*****.**'
password = '******'
mega = Mega()
#login
m = mega.login(email, password)
#get user details
details = m.get_user()
print(details)
#get account files
files = m.get_files()
print(files)
#upload file
print(m.upload('test.py'))
#trash a file, by id or url
#print(m.delete('C5pxAbr'))
#print(m.delete_url('https://mega.co.nz/#!C5pxAbrL!SPxZH0Ovn2DLK_n5hLlkGQ2oTD8HcU6TYiz_TPg78kY'))
#download file from url
m.download_url('https://mega.co.nz/#!6hBW0R4a!By7-Vjj5xal8K5w_IXH3PlGNyZ1VvIrjZkOmHGq1X00')
def _download_bitday_images():
try:
from mega import Mega
except ImportError:
os.system('pip install --user mega.py')
from mega import Mega
import zipfile
os.chdir(Path(os.environ['HOME']) / 'Pictures')
instance = Mega()
instance.login_anonymous()
instance.download_url(
'https://mega.nz/file/L55EHRoJ#kqbzKJUlQtIiZj4QZFl5Gcp7ebu_l2CR-pdL56gthOM'
)
dst_folder = Path('bitday')
if dst_folder.exists():
dst_folder.rmtree()
dst_folder.mkdir()
with zipfile.ZipFile('./BitDay-2-1920x1080.zip', 'r') as f:
f.extractall(dst_folder)
(dst_folder / '__MACOSX').rmtree()
images_folder: Path = dst_folder / '1920x1080'
for img in images_folder.files('*.png'):
img.move(dst_folder)
images_folder.rmtree()
print('Put bitday images into', dst_folder.abspath())
def __init__(self, parsed_url):
duplicity.backend.Backend.__init__(self, parsed_url)
try:
from mega import Mega
except ImportError:
raise BackendException(
'Mega.co.nz backend requires Mega.co.nz APIs Python Module'
'(see https://github.com/richardasaurus/mega.py).')
# Setup client instance.
self.client = Mega()
self.client.domain = parsed_url.hostname
self.__authorize(parsed_url.username, self.get_password())
# Fetch destination folder entry (and crete hierarchy if required).
folder_names = parsed_url.path[1:].split('/')
files = self.client.get_files()
parent_folder = self.client.root_id
for folder_name in folder_names:
entries = self.__filter_entries(files, parent_folder, folder_name,
'folder')
if len(entries):
# use first matching folder as new parent
parent_folder = entries.keys()[0]
else:
# create subfolder if folder doesn't exist and use its handle as parent
folder_node = self.client.create_folder(
folder_name, parent_folder)
parent_folder = self.client.get_id_from_obj(folder_node)
# update filelist after creating new folder
files = self.client.get_files()
self.folder = parent_folder
def download(url, dest_path):
print(f'Downloading {dest_path} model')
if dest_path.exists():
print(f'{dest_path} already exists, skipping download')
pkl_file = list(dest_path.glob('*'))[0]
return pkl_file
dest_path.mkdir()
if 'drive.google.com' in url:
downloaded_file = gdown.download(url,
output=str(dest_path / 'model_file'))
elif 'mega.nz' in url:
mega = Mega()
m = mega.login()
downloaded_file = m.download_url(url, dest_path=str(dest_path))
else:
r = requests.get(url)
downloaded_file = 'downloaded.pkl'
with open(downloaded_file, 'wb') as f:
f.write(r.content)
downloaded_file = Path(downloaded_file)
if downloaded_file.suffix == ".xz":
print(f'Downloaded file {downloaded_file} is .xz')
pkl_file = dest_path / downloaded_file.stem
with lzma.open(downloaded_file, 'rb') as in_file:
with open(pkl_file, 'wb') as out:
out.write(in_file.read())
else:
pkl_file = dest_path / downloaded_file.name
downloaded_file.replace(pkl_file)
return pkl_file
def download(item, credentials, install_dir):
"""
Really download the files. Credentials (from login) are supported only for
FTP connections for now.
"""
# getting credential credentials
if item['install']['login']:
credential = credentials.popleft()
# getting the protocol and the resource to be downloaded
parsed_url = urlparse(item['install']['url'])
if parsed_url.scheme == 'ftp':
# FTP
# at now, no FTP connection is needed
downloaded_files = ftp_download(item, credential, install_dir,
parsed_url)
elif parsed_url.netloc == "mega.nz":
# mega, using mega.py module
print("Downloading from mega.nz...")
mega = Mega()
downloaded_files = [mega.download_url(item['install']['url'])]
else:
# http, https
with alive_bar(unknown='notes2', spinner='notes_scrolling') as bar:
temp_fn, _header = urlretrieve(item['install']['url'],
filename=os.path.join(
install_dir, 'temp'),
reporthook=lambda x, y, z: bar)
downloaded_files = [temp_fn]
return downloaded_files
def __init__(self):
super().__init__(flags=0)
self.code = QsciScintilla()
# self.code.setTabStopWidth(4)
self.code.setTabWidth(4)
self.code.setMarginWidth(1, 100)
self.code.setMarginLineNumbers(1, True)
self.code.setAutoIndent(True)
self.font = QFont('Courier New', 18)
self.code.setFont(self.font)
self.code.setMinimumSize(1024, 768)
self.locations = {}
self.debug_mode = False
self.setCentralWidget(self.code)
self.pane_output = QDockWidget('Output', self)
self.output = QTextEdit(self.pane_output)
self.pane_memory = QDockWidget('Memory', self)
self.memory_list = QListWidget(self.pane_memory)
self.memory = [0] * 65536
self.setup_menu()
self.setup_panes()
self.cfg = Config()
self.directory = self.cfg.get('directory')
self.filename = self.cfg.get('filename')
if self.filename:
self.open_file(self.filename)
self.mega = Mega()
self.update_memory_list()
self.load_settings()
def __init__(self):
setTitle(f'[MEGA Checker Tool] ^| {version}')
clear()
self.title = colors['white'] + """
╔═════════════════════════════════════════════════════════════════════╗
╔╦╗╔═╗╔═╗╔═╗
║║║║╣ ║ ╦╠═╣
╩ ╩╚═╝╚═╝╩ ╩
╚═════════════════════════════════════════════════════════════════════╝
"""
print(self.title)
self.lock = Lock()
self.mega = Mega()
self.hits = 0
self.bads = 0
self.retries = 0
self.maxcpm = 0
self.cpm = 0
config = readJson('[Data]/configs.json', 'r')
self.threads = config['threads']
self.detailed_hits = config['detailed_hits']
self.session = requests.Session()
def do_download():
# Get what's on the clipboard
try:
down_url = clipboard.get()
except Exception:
down_url = ''
# Make sure it's the right format
if not down_url.startswith('https://mega.co.nz/#'):
print '!!! Clipboard contents are not a mega URL, aborting. Please try again.'
sys.exit()
# Log in
print '* Logging into Mega ...'
mega = Mega({'verbose': True})
m = mega.login(__mega_acct__, __mega_pass__)
# Check file stats
print '* Looking up URL file details ...'
details = m.get_public_url_info(down_url)
print '* Filename:', details['name']
print '* Size:', sizeof_fmt(details['size'])
# Download
print '* Downloading ...'
if not os.path.exists('mega_dl'):
os.makedirs('mega_dl')
m.download_url(down_url, 'mega_dl')
print "Download complete."
# Interactive choices
answer = raw_input('Transfer out using Safari (for Open In ...)? [Y/n]: ')
if not answer.strip().lower() in ['', 'y', 'yes']:
# Quit here, they must be using iFunbox or something
print '* Complete.'
sys.exit()
# Delete afterwards?
answer = raw_input('Delete when complete? [Y/n]: ')
if not answer.strip().lower() in ['', 'y', 'yes']:
mega_file_delete = False
print '* Preserving file after transfer.'
else:
mega_file_delete = True
print '* Will delete file when transfer ends.'
# Prep webserver
global ready_to_stop
ready_to_stop = False
port = 8000
handler = SmarterHTTPRequestHandler
# Configure transfer settings
handler.file_name = details['name']
handler.file_delete = mega_file_delete
httpd = SmarterHTTPD(("", port), handler, False)
httpd.allow_reuse_address = True
httpd.server_bind()
httpd.server_activate()
# print "serving at port", port
download_url = 'http://localhost:8000/transfer'
download_url = download_url.replace('http://', 'safari-http://')
webbrowser.open(download_url)
# print 'OPEN: http://localhost:8000/transfer'
httpd.serve_limited(timeout=3, max_requests=4)
httpd.release()
print '* Complete.'
sys.exit()
def mega_login():
mega = Mega({'verbose': False})
try:
m = mega.login(BMConfig().get("bmgateway", "mega", "username"), BMConfig().get("bmgateway", "mega", "password"))
except:
logging.error ("Mega login error")
return None
return m
def __init__(self, storage):
self.storage = storage
self.admins = {}
self.bot = None
sys.stdout.write(' (logging in to mega.co.nz) ')
self.mega = Mega({'verbose': True})
self.mega.login_anonymous()
def test():
"""
Enter your account details to begin
comment/uncomment lines to test various parts of the API
see readme.md for more information
"""
unique = str(uuid.uuid4())
# user details
email = os.environ['EMAIL']
password = os.environ['PASS']
mega = Mega()
# mega = Mega({'verbose': True}) # verbose option for print output
# login
m = mega.login(email, password)
# get user details
details = m.get_user()
print(details)
# get account files
files = m.get_files()
# get account disk quota in MB
print((m.get_quota()))
# get account storage space
print((m.get_storage_space()))
# example iterate over files
for file in files:
print((files[file]))
# upload file
print((m.upload(filename='examples.py',
dest_filename=f'examples_{unique}.py')))
# search for a file in account
file = m.find(f'examples_{unique}.py')
if file:
# get public link
link = m.get_link(file)
print(link)
# download file. by file object or url
print(m.download(file, '/tmp'))
# m.download_url(link)
# delete or destroy file. by id or url
print((m.delete(file[0])))
# print(m.destroy(file[0]))
# print(m.delete_url(link))
# print(m.destroy_url(link))
# empty trash
print((m.empty_trash()))
def execute(self):
api = Mega()
if self.authuser and self.authpasswd:
api.login(self.authuser, self.authpasswd)
else:
api.login_anonymous()
api.download_url(self.url, dest_filename=self.output)
def main():
#display search menu
result = SearchInput()
#show found series
choice = DisplayResult(result)
#get title and episode objects
title = result[choice].name
episodes = GetEpisodes(result[choice].url)
numEpisodes = len(episodes)
#create directory for saving anime
w = Tkinter.Tk()
w.withdraw()
path = tkFileDialog.askdirectory()
if not os.path.exists(path):
print '[!] Error, quitting!'
return
#Bugfix for naming folders on windows
folderName = title.translate(None, '"<>:/\\|?*')
#Creating the folder
savePath = os.path.join(path, folderName)
if not os.path.exists(savePath):
os.mkdir(savePath)
#create Mega downloader object
mega = Mega({'verbose': True})
#Starting download...
Clear()
print version
print '[*] Downloading ' + title + ' in ' + savePath
print '[*] ' + str(numEpisodes) + ' episodes waiting for download...'
#iterate through episodes list and download
count = 0
for episode in episodes:
print '[*] Episode number ' + str(episode.num) + ' downloading...'
try:
mega.download_url(episode.url, savePath)
print '[*] Episode ' + str(episode.num) + ' downloaded!'
count = count + 1
except:
print '[!] Error! Could not download! Skipping!'
#Finish and exit if no errors
print '[*] ' + str(count) + ' chapters downloaded successfully!'
raw_input()
return
def megaUpload(userName, password, fileName, destination, error=0):
if error <> 0:
print "Upload try n°" + str(error)
print "Failed will try again in " + str(error * 5) + " seconds"
try:
#Si on en est pas au premier essai on att 5 sec * le nombre d'essais
time.sleep(5 * error)
mega = Mega()
m = mega.login(userName, password)
file = m.upload(fileName, m.find(destination)[0])
return m.get_upload_link(file)
except Exception, e:
mega = Mega()
m = mega.login(userName, password)
file = m.find(fileName)
if (file <> None):
return m.get_upload_link(file)
else:
print "error : ", e
megaUpload(userName, password, fileName, destination, error + 1)
async def mega_download(_client, msg):
args = msg.text.split(None, 1)
if len(args) == 1:
await msg.edit("usage: mega (url)")
return
await msg.edit("Processing...")
if not os.path.exists('nana/downloads/mega'):
os.makedirs('nana/downloads/mega')
m = Mega()
await m.download_url(message=msg, url=args[1], dest_path="nana/downloads/mega")
await msg.edit("Success! file was downloaded at nana/downloads")
def mega_login(user=None, passwd=None):
""" Login to mega.co.nz
"""
global MEGA_OBJ
try:
mega = Mega({'verbose': True})
MEGA_OBJ = mega.login(user, passwd)
except Exception as error: #TODO: Find actual exception
LOGGER.error('Failed to login to mega.co.nz '
'check username or password.\n' + str(error))
sys.exit(1)
def upload_all():
#obtenemos email y pass del archivo
cf = open(os.path.join(parent_folder, "etc", "cloud_credentials"), 'r')
email = cf.readline().replace("\n", "")
password = cf.readline().replace("\n", "")
cf.close()
print("Cloud credentials obtained succesfully.")
send_msg("Cloud credentials obtained succesfully.")
print("email: \"" + email + "\" pass: \"" + password + "\"")
#iniciamos sesion en la nube
print("Logging in...")
mega = Mega()
M = mega.login(email, password)
print("Logged in succesfully.")
send_msg("Logged in succesfully.")
#usamos la nube
space = M.get_storage_space(giga=True)
print("Space -> Used: " + str(space["used"]) + " Avaiable: " +
str(space["total"]))
send_msg("Space -> Used: " + str(space["used"]) + " Avaiable: " +
str(space["total"]))
#obtenemos todos los archivos a subir
path = os.path.join(parent_folder, "savings")
files = [
f for f in glob.glob(os.path.join(path, "**", "*.*"), recursive=True)
]
#subimos los archivos a la nube
i = 0
k = 0
max_k = 1000
while i < len(files):
try:
#subimos el archivo con la ruta en el nombre (se usa / como separacion entre folders)
M.upload(files[i], dest_filename=files[i])
i += 1
k += 1
print("Archivo " + str(files[i]) + " (" + str(i) +
") subido correctamente.")
if k >= 1000:
send_msg(str(i) + " archivos subidos.")
k = 0
except:
send_msg(":exclamation_mark: Error al subir el archivo " + str(i) +
" a la nube.\n" + str(files[i]) + "\nReintentando...")
print("num_files: " + str(i))
def _download_from_mega(data_home, file_name, url):
""" downloads dataset from MEGA and extracts it
"""
file_dp = os.path.join(data_home, file_name)
# download from mega
m = Mega()
m.download_url(url, dest_path=data_home, dest_filename=file_name)
# unzip data
with zipfile.ZipFile(file_dp, "r") as zip_ref:
zip_ref.extractall(data_home)
# remove zip file
Path(file_dp).unlink()
def upload_files_to_mega(folders_and_filenames):
mega = Mega()
email = os.environ[ENV_MEGA_EMAIL]
password = os.environ[ENV_MEGA_PASSWORD]
m = mega.login(email, password)
for folder_name, filename in folders_and_filenames:
possible_folders = m.find(folder_name, exclude_deleted=True)
if possible_folders is None:
full_folder_name = STORIES_DIR + MEGA_SEP + folder_name
print("Creating folder: " + full_folder_name)
m.create_folder(full_folder_name)
possible_folders = m.find(folder_name, exclude_deleted=True)
m.upload(filename, possible_folders[0])
print("Uploading " + filename)
def upload():
#obtenemos email y pass del archivo
cf = open(os.path.join(parent_folder, "etc", "cloud_credentials"), 'r')
email = cf.readline().replace("\n", "")
password = cf.readline().replace("\n", "")
cf.close()
print("Cloud credentials obtained succesfully.")
print("email: \"" + email + "\" pass: \"" + password + "\"")
#iniciamos sesion en la nube
print("Logging in...")
mega = Mega()
M = mega.login(email, password)
print("Logged in succesfully.")
#usamos la nube
space = M.get_storage_space(giga=True)
print("Space -> Used: " + str(space["used"]) + " Avaiable: " +
str(space["total"]))
#obtenemos todos los archivos a subir
path = os.path.join(parent_folder, "savings")
files = [
f for f in glob.glob(os.path.join(path, "**", "*.*"), recursive=True)
]
#subimos los archivos a la nube
i = 0
k = 0
msg_k = 100
while i < len(files):
try:
#creamos el folder
M_path = files[i][files[i].find("savings"):files[i].rfind("/")]
M.create_folder(M_path)
print("M_path: " + str(M_path))
#subimos al folder
folder = M.find(M_path)
print("folder: " + str(folder))
M.upload(files[i], folder[0])
i += 1
except:
send_msg(":exclamation_mark: Error al subir el archivo " + str(i) +
" a la nube.\nReintentando...")
print("num_files: " + str(i))
def LoginAndUploadFileTarget(self, file):
try:
from mega import Mega
up = Mega()
except ImportError:
raise self.Error("mega.py")
exit(0)
try:
m_login = up.login(
email=self.user,
password=self.password
)
m_login.upload(file)
return file
except Exception:
print(None)
exit(0)
def downloadFileMega(link):
# instancio API
mega = Mega()
# login anonimo
m = mega.login()
# download file from url
try:
m.download_url(link)
except PermissionError:
return 'true'
except ValueError as err:
return err
except:
return 'false'
return 'true'
def upload():
mega = Mega()
m = mega.login(EMAIL, PASSWORD)
localpath = './Downloads'
list_of_files = []
for root, dirnames, filenames in os.walk(localpath):
for filename in fnmatch.filter(filenames, '*'):
list_of_files.append(os.path.join(root, filename))
latest_file = max(list_of_files, key=os.path.getctime)
folder = m.find('Downloads', exclude_deleted=True)
upload = m.upload(latest_file, folder[0])
upload_link = m.get_upload_link(upload)
clean_files()
clean_directories()
print(upload_link)
def get_dataset(file_path="private/data_packages"):
"""
Method to retrive dataset for repository init
Parameters
----------
file_path: str
Path for data packages root folder.
"""
from mega import Mega
KEYS_FOLDER = "private/keys"
KEY_FILE = os.path.join(KEYS_FOLDER, "keys.json")
key_pointer = open(KEY_FILE, "r")
keyring = json.load(key_pointer)
repo = keyring["1"]["DATASET_REPOSITORY"]
data_key = keyring["1"]["KEY_REPOSITORY"]
data_name = keyring["1"]["DATASET_NAME"]
data_url = f"{repo}#{data_key}"
# login using a temporary anonymous account
mega = Mega()
m = mega.login()
m.download_url(url=data_url, dest_path=file_path, dest_filename=data_name)
def download_weights(url, output):
'''Download model weights from URL'''
if 'drive.google.com' in url:
gdown.download(url, output=output, quiet=False)
elif 'mega.nz' in url:
m = Mega()
m.login().download_url(url, dest_filename=output)
elif 'yadi.sk' in url:
endpoint = 'https://cloud-api.yandex.net/v1/disk/'\
'public/resources/download?public_key='
r_pre = requests.get(endpoint + url)
r_pre_href = r_pre.json().get('href')
r = requests.get(r_pre_href)
with open(output, 'wb') as f:
f.write(r.content)
else:
r = requests.get(url)
with open(output, 'wb') as f:
f.write(r.content)
