Как использовать Python скачать файл от мега

Question

Как я могу скачать файл с мега, я пытался исправить mega.py (потому что он для python2, 3 не работает), но он все еще не работает, может кто-то сказать мне, как исправитьэто или есть другой способ скачать?

Следующие коды являются репозиторием feom mega.py, и я исправляю его ошибку, но все равно не могу работать, он сообщит

Traceback (most recent call last):
  File "mega.py", line 90, in <module>
    Mega().from_ephemeral()
  File "mega.py", line 18, in from_ephemeral
    inst.login_ephemeral()
  File "mega.py", line 51, in login_ephemeral
    self._login_common(res, random_password_key)
  File "mega.py", line 55, in _login_common
    raise MegaIncorrectPasswordExcetion("Incorrect e-mail and/or password.")
exceptions.MegaIncorrectPasswordExcetion: Incorrect e-mail and/or password.

mega.py

import json
import random
import base64
import requests

from crypto import encrypt_key
from utitls import a32_to_str, a32_to_base64, base64urlencode, base64_to_a32
from exceptions import MegaRequestException, MegaIncorrectPasswordExcetion

class Mega:
    def __init__(self):
        self.seqno = random.randint(0, 0xFFFFFFFF)
        self.sid = None

    @classmethod
    def from_ephemeral(cls):
        inst = cls()
        inst.login_ephemeral()
        return inst

    def api_req(self, data):
        print(data)
        params = {'id': self.seqno}
        self.seqno += 1
        if self.sid:
            params.update({'sid': self.sid})
        data = json.dumps([data])
        req = requests.post(
            'https://g.api.mega.co.nz/cs', params=params, data=data)
        json_data = req.json()
        if isinstance(json_data, int):
            raise MegaRequestException(json_data)
        return json_data[0]

    def login_ephemeral(self):
        random_master_key = [random.randint(0, 0xFFFFFFFF)] * 4
        random_password_key = [random.randint(0, 0xFFFFFFFF)] * 4
        random_session_self_challenge = [random.randint(0, 0xFFFFFFFF)] * 4
        user_handle = self.api_req({
            'a':
            'up',
            'k':
            base64.encodebytes(a32_to_base64(encrypt_key(random_master_key, random_password_key))).decode('ascii').replace('\n', ''),
            'ts':
            base64.encodebytes(base64urlencode(
                a32_to_str(random_session_self_challenge) + a32_to_str(
                    encrypt_key(random_session_self_challenge,
                                random_master_key)))).decode('ascii').replace('\n', '')
        })
        res = self.api_req({'a': 'us', 'user': user_handle})
        self._login_common(res, random_password_key)

    def _login_common(self, res, password):
        if res in (-2, -9):
            raise MegaIncorrectPasswordExcetion("Incorrect e-mail and/or password.")

        enc_master_key = base64_to_a32(res['k'])
        self.master_key = decrypt_key(enc_master_key, password)
        if 'tsid' in res:
            tsid = base64urldecode(res['tsid'])
            key_encrypted = a32_to_str(
                encrypt_key(str_to_a32(tsid[:16]), self.master_key))
            if key_encrypted == tsid[-16:]:
                self.sid = res['tsid']
        elif 'csid' in res:
            enc_rsa_priv_key = base64_to_a32(res['privk'])
            rsa_priv_key = decrypt_key(enc_rsa_priv_key, self.master_key)

            privk = a32_to_str(rsa_priv_key)
            self.rsa_priv_key = [0, 0, 0, 0]

            for i in xrange(4):
                l = ((ord(privk[0]) * 256 + ord(privk[1]) + 7) / 8) + 2
                self.rsa_priv_key[i] = mpi2int(privk[:l])
                privk = privk[l:]

            enc_sid = mpi2int(base64urldecode(res['csid']))
            decrypter = RSA.construct(
                (self.rsa_priv_key[0] * self.rsa_priv_key[1],
                 0,
                 self.rsa_priv_key[2],
                 self.rsa_priv_key[0],
                 self.rsa_priv_key[1]))
            sid = '%x' % decrypter.key._decrypt(enc_sid)
            sid = binascii.unhexlify('0' + sid if len(sid) % 2 else sid)
            self.sid = base64urlencode(sid[:43])


if __name__ == '__main__':
    Mega().from_ephemeral()

crypto.py

import struct
from Crypto.Cipher import AES

def a32_to_str(a):
    return struct.pack('>%dI' % len(a), *a)

def encrypt_key(a, key):
    return sum(
        (aes_cbc_encrypt_a32(a[i:i+4], key)
            for i in range(0, len(a), 4)), ())

def aes_cbc_encrypt(data, key):
    encryptor = AES.new(key, AES.MODE_CBC, b'\0' * 16)
    return encryptor.encrypt(data)

def str_to_a32(b):
    if len(b) % 4:  # Add padding, we need a string with a length multiple of 4
        b += '\0' * (4 - len(b) % 4)
    return struct.unpack('>%dI' % (len(b) / 4), b)

def aes_cbc_encrypt_a32(data, key):
    return str_to_a32(aes_cbc_encrypt(a32_to_str(data), a32_to_str(key)))

utitles.py

import base64
import struct

def base64urlencode(data):
    data = base64.b64encode(data)
    for search, replace in (('+', '-'), ('/', '_'), ('=', '')):
        data = data.replace(search, replace)
    return data

def a32_to_str(a):
    return struct.pack('>%dI' % len(a), *a)

def base64urlencode(data):
    data = base64.b64encode(data)
    for search, replace in (('+', '-'), ('/', '_'), ('=', '')):
        data = data.replace(bytes(search, encoding='utf8'), bytes(replace, encoding='utf8'))
    return data

def a32_to_base64(a):
    return base64urlencode(a32_to_str(a))


def base64_to_a32(s):
    return str_to_a32(base64urldecode(s))

exceptions.py

# -*- coding: utf-8 -*-


class MegaException(Exception):
    pass

class MegaIncorrectPasswordExcetion(MegaException):
    """
    A incorrect password or email was given.
    """

class MegaRequestException(MegaException):
    """
    There was an error in the request.
    """
    pass