A few helper for the mega API

megautils.py

import os
import time

def _sleep():
    time.sleep(1.0)

class MegaNode(object):
    """docstring for MegaNode"""
    def __init__(self, mega, id, parent, datainfo):
        super(MegaNode, self).__init__()
        self.datainfo = datainfo
        self.id = id
        self.parent = parent
        if isinstance(datainfo["a"], dict):
            self.name = datainfo["a"]["n"]
        elif isinstance(datainfo["a"], str):
            self.name = "NONAME(a:{0})".format(datainfo["a"])
        else:
            print "name?:",datainfo
            self.name = "NONAME"
        self.isDir = False
        self.mega = mega

    def dumptree(self, indent=0):
        return self.__str__(indent)

    def __str__(self, indent=0):
        return u"{0}{1}({2}, name='{3}')".format(
            " "*indent,
            self.__class__.__name__,
            self.id,
            self.name)

    def __repr__(self, indent=0):
        return self.__str__(indent)

    def move(self, dest):
        _sleep()
        self.mega.move(self.id, dest.id)

    def delete(self):
        _sleep()
        self.mega.delete(self.id)

    def get_link(self):
        _sleep()
        return self.mega.get_upload_link(self.id)

class MegaFile(MegaNode):
    """docstring for MegaFile"""
    def __init__(self, mega, id, parent, datainfo):
        super(MegaFile, self).__init__(mega, id, parent, datainfo)


class MegaDir(MegaNode):
    """docstring for MegaDir"""
    def __init__(self, mega, id, parent, datainfo):
        super(MegaDir, self).__init__(mega, id, parent, datainfo)
        self.directorys = []
        self.files = []
        self.isDir = True

    def _processchilds(self, datalist):
        todelete = []
        for nodekey in datalist.keys():
            #try:
                node = datalist[nodekey]
                # Is parent of Node?
                if node["p"] == self.id:
                    todelete.append(nodekey)
                    # Is File?
                    if node["t"] == 0:
                        self.files.append(MegaFile(self.mega, nodekey, self, node))
                    else:
                        self.directorys.append(MegaDir(self.mega, nodekey, self, node))
            # except Exception, ex:
            #     print "Exception in %s,%s: %s"%(self.name, nodekey, str(ex))

        for key in todelete:
            del datalist[key]

        for d in self.directorys: d._processchilds(datalist)

    def get(self, path):
        #path = path.split("/")
        #print path
        if len(path) == 1:
            for d in self.directorys:
                if d.name == path[0]:
                    return d
            for f in self.files:
                if f.name == path[0]:
                    return f
            return None
        else:
            for d in self.directorys:
                if d.name == path[0]:
                    return d.get(path[1:]) #"/".join(path[1:]))
            return None

    def mkdir(self, name):
        m = self.mega

        for dr in self.directorys:
            if dr.name == name:
                return dr
        _sleep()
        data = m.create_folder(name, self.id)["f"][0]
        #print data
        data["a"] = dict(a=data["a"], n=name)
        d = MegaDir(self.mega, data["h"], self, data)

        self.directorys.append(d)

        return d

    def makepath(self, path):
        lastDir = self
        lastPath = len(path)
        needmake = False

        for n in range(len(path)):
            nextDir = lastDir.get([path[n],])
            if nextDir is not None:
                lastDir = nextDir
            else:
                lastPath = n
                needmake = True
                break

        if needmake:
            for n in range(lastPath, len(path)):
                #print path[n], lastPath
                lastDir = lastDir.mkdir(path[n])
                #lastDir = m.create_folder(path[n], lastDir)

        return lastDir

    def upload(self, filename, dest_filename=None):
        _sleep()

        dest_filename = dest_filename or os.path.basename(filename)
        data = self.mega.upload(filename, self.id, dest_filename)["f"][0]

        data["a"] = dict(a=data["a"], n=dest_filename)
        d = MegaFile(self.mega, data["h"], self, data)

        self.files.append(d)

        return d

    def merge(self, otherdir):

        for d in otherdir.directorys:
            dd = self.get([d.name,])
            if dd is None:
                d.move(self)
            else:
                dd.merge(d)

        for f in otherdir.directorys:
            f.move(self)

        #otherdir.delete()


    def __str__(self, indent=0):
        nextindent = indent+1
        retdata = u"{0}MegaDir({1}, name='{2}')".format(
            u" "*indent, self.id, self.name)

        return retdata

    def dumptree(self, indent=0):
        nextindent = indent+1
        retdata = u"{0}MegaDir({1}, name='{2}'".format(
            u" "*indent, self.id, self.name)

        if len(self.directorys) > 0:
            retdata += u",\n{0}dirs=[\n{0}{1}]".format(
                u" "*indent,
                u",\n".join([x.dumptree(nextindent) for x in self.directorys])
                )

        if len(self.files) > 0:
            retdata += u",\n{0}files=[\n{0}{1}]".format(
                u" "*indent,
                u",\n".join([x.dumptree(nextindent) for x in self.files])
                )

        retdata += ")"

        return retdata


def get_megaroot(mega):
    _sleep()
    datalist = mega.get_files()
    for key in datalist.keys():
        if datalist[key]["t"] == 2:
            root = MegaDir(mega, key, None, datalist[key])
            root._processchilds(datalist)
            return root