def get_client(*info):
''' returns a mediafireapi.client object
@email as first parameter
@password as second parameter
if no params are passed, then get_client
pulls the account information from the user's
saved credentials with the user file'''
# Create Mediafire client
try:
client = MediaFireClient()
except requests.exceptions.RequestException:
logger.die('Network error, please check network status and try again')
if (len(info) == 2):
try:
client.login(email=info[0],
password=info[1],
app_id=APP_ID,
api_key=API_KEY)
except requests.exceptions.RequestException:
logger.die('Network error, please check network status and try again')
else:
try:
auth = user.get_auth()
client.login(email=auth[0],
password=auth[1],
app_id=APP_ID,
api_key=API_KEY)
except requests.exceptions.RequestException:
logger.die('Network error, please check network status and try again')
return client
def upload(filename,foldername):
imagepath = '/home/xamforcrpf/imgdir/'
imagepath+=filename+'.jpg'
print(imagepath)
print(filename)
client = MediaFireClient()
client.login( email='*****@*****.**',
password='******',
app_id='42511')
result = client.upload_file(imagepath, f"mf:/{foldername}/")
fileinfo = client.api.file_get_info(result.quickkey)
hashcode = fileinfo['file_info']['hash']
hashcode = hashcode[:4]
link = fileinfo['file_info']['links']['normal_download']
link = link.rstrip('/file')
link = link.replace('/file','/convkey/'+hashcode)
for i in range(1,len(link)+1):
print(link[-i])
if link[-i] == '/':
point = -i
break
elif link[-i] == '.':
ext = -i
link = link[:point]+'6g'+link[ext:]
return link
def __init__(self,
api=MediaFireApi(),
email=properties.email,
password=properties.password,
app_id=properties.app_id):
self.__api = api
self.session = api.user_get_session_token(email=email,
password=password,
app_id=app_id)
self.__api.session = self.session
self.uploader = MediaFireUploader(self.__api)
self.client = MediaFireClient()
self.client.login(email=email, password=password, app_id=app_id)
self.ROOT = ROOT
def test_upload_target_parent_folder_does_not_exist(self):
source = '/tmp/k.txt'
dest_uri = 'mf:/c/k.txt'
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
raise ResourceNotFoundError(uri)
elif uri == 'mf:/c':
raise ResourceNotFoundError(uri)
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
with self.assertRaises(ResourceNotFoundError):
client._prepare_upload_info(source, dest_uri)
def test_upload_target_parent_folder_does_not_exist(self):
source = '/tmp/k.txt'
dest_uri = 'mf:/c/k.txt'
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
raise ResourceNotFoundError(uri)
elif uri == 'mf:/c':
raise ResourceNotFoundError(uri)
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
with self.assertRaises(ResourceNotFoundError):
client._prepare_upload_info(source, dest_uri)
def test_upload_fh_to_folder(self):
source = io.BytesIO(b"blah")
dest_uri = 'mf:/g/'
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
return Folder({
'folderkey': 'i' * 13,
'name': 'g'
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
with self.assertRaises(ValueError):
client._prepare_upload_info(source, dest_uri)
def test_upload_fh_to_folder(self):
source = io.BytesIO(b"blah")
dest_uri = 'mf:/g/'
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
return Folder({
'folderkey': 'i' * 13,
'name': 'g'
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
with self.assertRaises(ValueError):
client._prepare_upload_info(source, dest_uri)
def test_upload_target_file_parent_folder_is_file(self):
source = '/tmp/m.txt'
dest_uri = 'mf:/e/m.txt'
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
raise ResourceNotFoundError(uri)
elif uri == 'mf:/e':
return File({
'quickkey': 'f' * 15,
'name': 'e'
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
with self.assertRaises(NotAFolderError):
client._prepare_upload_info(source, dest_uri)
def test_upload_target_file_parent_folder_is_file(self):
source = '/tmp/m.txt'
dest_uri = 'mf:/e/m.txt'
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
raise ResourceNotFoundError(uri)
elif uri == 'mf:/e':
return File({
'quickkey': 'f' * 15,
'filename': 'e'
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
with self.assertRaises(NotAFolderError):
client._prepare_upload_info(source, dest_uri)
def test_existing_file_overwrite(self):
source = "/tmp/f.txt"
dest_uri = "mf:/a/f.txt"
folder_key = 'a' * 13
quick_key = 'b' * 15
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
return File({
'parent_folderkey': folder_key,
'quickkey': quick_key,
'name': 'f.txt'
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
result_folder_key, result_name = client._prepare_upload_info(source,
dest_uri)
self.assertEqual(result_name, 'f.txt')
self.assertEqual(result_folder_key, folder_key)
def test_existing_file_overwrite(self):
source = "/tmp/f.txt"
dest_uri = "mf:/a/f.txt"
folder_key = 'a' * 13
quick_key = 'b' * 15
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
return File({
'parent_folderkey': folder_key,
'quickkey': quick_key,
'filename': 'f.txt'
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
result_folder_key, result_name = client._prepare_upload_info(source,
dest_uri)
self.assertEqual(result_name, 'f.txt')
self.assertEqual(result_folder_key, folder_key)
def upgrade_mediafire(version):
""" Upgrade to the given version. The upgrades
will be downloaded from mediafire.
The version can be higher or lower than the current one.
This allows to downgrade (in case of a failed upgrade)
"""
codename = configuration.get("Globals", "codename")
filename = "{}-{}.zip".format(codename, version)
dest = os.path.join(get_data_dir(), filename)
mainlog.info("Downloading a new version {} into {} proxyport={}".format(
filename, dest, configuration.get("Proxy", "proxy_port")))
client = MediaFireClient()
client.login(email=configuration.get("MediaFire", "email"),
password=configuration.get("MediaFire", "password"),
app_id=configuration.get("MediaFire", "appid"),
api_key=configuration.get("MediaFire", "sessionkey"))
client.download_file("mf:/" + filename, dest)
configuration.set("DownloadSite", "current_version", str(version))
configuration.set("DownloadSite", "client_path", dest)
configuration.save()
return
def get_client(*info):
''' returns a mediafireapi.client object
@email as first parameter
@password as second parameter
if no params are passed, then get_client
pulls the account information from the user's
saved credentials with the user file'''
# Create Mediafire client
try:
client = MediaFireClient()
except requests.exceptions.RequestException:
logger.die('Network error, please check network status and try again')
if (len(info) == 2):
try:
client.login(email=info[0],
password=info[1],
app_id=APP_ID,
api_key=API_KEY)
except requests.exceptions.RequestException:
logger.die(
'Network error, please check network status and try again')
else:
try:
auth = user.get_auth()
client.login(email=auth[0],
password=auth[1],
app_id=APP_ID,
api_key=API_KEY)
except requests.exceptions.RequestException:
logger.die(
'Network error, please check network status and try again')
return client
def test_upload_to_folder(self):
source = '/tmp/j.txt'
dest_uri = 'mf:/b/'
folder_key = 'c' * 13
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
return Folder({
'folderkey': folder_key,
'name': 'a'
})
elif uri == 'mf:/b/j.txt':
raise ResourceNotFoundError()
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
result_folder_key, result_name = client._prepare_upload_info(source,
dest_uri)
self.assertEqual(result_name, 'j.txt')
self.assertEqual(result_folder_key, folder_key)
def uploadass(filename):
imagepath = '/home/xamforcrpf/imgdir/'
imagepath+=filename
print(imagepath)
print(filename)
client = MediaFireClient()
client.login( email='*****@*****.**',
password='******',
app_id='42511')
print('login')
link = ''
for i in range(10):
try:
print('doing upload')
result = client.upload_file(imagepath, f"mf:/")
fileinfo = client.api.file_get_info(result.quickkey)
link = fileinfo['file_info']['links']['normal_download']
break
except:
print('retrying')
return link
def test_upload_to_folder(self):
source = '/tmp/j.txt'
dest_uri = 'mf:/b/'
folder_key = 'c' * 13
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
return Folder({
'folderkey': folder_key,
'name': 'a'
})
elif uri == 'mf:/b/j.txt':
raise ResourceNotFoundError()
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
result_folder_key, result_name = client._prepare_upload_info(source,
dest_uri)
self.assertEqual(result_name, 'j.txt')
self.assertEqual(result_folder_key, folder_key)
def test_upload_fh_existing_overwrite(self):
source = io.BytesIO(b"blah")
dest_uri = 'mf:/f/m.txt'
quick_key = 'j' * 15
folder_key = 'h' * 13
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
return File({
'quickkey': quick_key,
'filename': 'm.txt',
'parent_folderkey': folder_key
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
result_folder_key, result_name = client._prepare_upload_info(source,
dest_uri)
self.assertEqual(result_name, 'm.txt')
self.assertEqual(result_folder_key, folder_key)
def test_upload_fh_existing_overwrite(self):
source = io.BytesIO(b"blah")
dest_uri = 'mf:/f/m.txt'
quick_key = 'j' * 15
folder_key = 'h' * 13
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
return File({
'quickkey': quick_key,
'name': 'm.txt',
'parent_folderkey': folder_key
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
result_folder_key, result_name = client._prepare_upload_info(source,
dest_uri)
self.assertEqual(result_name, 'm.txt')
self.assertEqual(result_folder_key, folder_key)
def test_upload_target_file_doest_not_exist(self):
source = '/tmp/l.txt'
dest_uri = 'mf:/d/l.txt'
folder_key = 'e' * 13
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
raise ResourceNotFoundError(uri)
elif uri == 'mf:/d':
return Folder({
'folderkey': folder_key,
'name': 'd'
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
result_folder_key, result_name = client._prepare_upload_info(source,
dest_uri)
self.assertEqual(result_name, 'l.txt')
self.assertEqual(result_folder_key, folder_key)
def test_upload_to_folder_target_name_is_folder(self):
source = '/tmp/j.txt'
dest_uri = 'mf:/b/'
folder_key = 'd' * 13
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
return Folder({
'folderkey': folder_key,
'name': 'b'
})
elif uri == 'mf:/b/j.txt':
return Folder({
'folderkey': 'e' * 13,
'name': 'j.txt'
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
with self.assertRaises(ValueError):
client._prepare_upload_info(source, dest_uri)
def test_upload_to_folder_target_name_is_folder(self):
source = '/tmp/j.txt'
dest_uri = 'mf:/b/'
folder_key = 'd' * 13
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
return Folder({
'folderkey': folder_key,
'name': 'b'
})
elif uri == 'mf:/b/j.txt':
return Folder({
'folderkey': 'e' * 13,
'name': 'j.txt'
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
with self.assertRaises(ValueError):
client._prepare_upload_info(source, dest_uri)
def test_upload_target_file_doest_not_exist(self):
source = '/tmp/l.txt'
dest_uri = 'mf:/d/l.txt'
folder_key = 'e' * 13
def mock_get_resource_by_uri(uri):
if uri == dest_uri:
raise ResourceNotFoundError(uri)
elif uri == 'mf:/d':
return Folder({
'folderkey': folder_key,
'name': 'd'
})
client = MediaFireClient()
client.get_resource_by_uri = mock_get_resource_by_uri
result_folder_key, result_name = client._prepare_upload_info(source,
dest_uri)
self.assertEqual(result_name, 'l.txt')
self.assertEqual(result_folder_key, folder_key)
class MediaFireResourceLookupTests(unittest.TestCase):
"""Tests for get_resource_by_uri"""
def setUp(self):
# we can operate w/o login
self.client = MediaFireClient(_api=DummyMediaFireApi)
def test_resource_by_uri_root(self):
"""Test that get_resource_by_uri works on root"""
result = self.client.get_resource_by_uri('mf:/')
self.assertEqual(result["folderkey"], "blah")
def test_folder_by_uri(self):
"""Test that multilevel folder is resolved"""
result = self.client.get_resource_by_uri('mf:///a/b')
self.assertEqual(result["folderkey"], "b" * 13)
def test_intermediate_file_raises_error(self):
"""Test that a file in the middle throws NotAFolderError"""
with self.assertRaises(NotAFolderError):
self.client.get_resource_by_uri('mf:///hi.txt/b')
def test_file_by_uri(self):
"""Test that multilevel file is resolved"""
result = self.client.get_resource_by_uri('mf:///a/b/hi.txt')
self.assertEqual(result["quickkey"], "i" * 15)
def test_missing_folder_raises_error(self):
"""Test that folder is reported missing if it is"""
with self.assertRaises(ResourceNotFoundError):
self.client.get_resource_by_uri('mf:///a/b/c/hi.txt')
def test_uri_key(self):
"""Test that key resolution works"""
result = self.client.get_resource_by_uri('mf:' + 'a' * 13)
self.assertEqual(result["folderkey"], "a" * 13)
def test_trailing_slash(self):
"""Test that URI with trailing slash works"""
result = self.client.get_resource_by_uri('mf:' + 'a' * 13 + '/')
self.assertEqual(result["folderkey"], "a" * 13)
#!/usr/bin/env python3
from mediafire.client import (MediaFireClient, File, Folder)
client = MediaFireClient()
client.login(app_id='45211')
client.download_file("mf:/i547ewwpknmh41l","thing")
class MediaFireConnection:
def __init__(self,
api=MediaFireApi(),
email=properties.email,
password=properties.password,
app_id=properties.app_id):
self.__api = api
self.session = api.user_get_session_token(email=email,
password=password,
app_id=app_id)
self.__api.session = self.session
self.uploader = MediaFireUploader(self.__api)
self.client = MediaFireClient()
self.client.login(email=email, password=password, app_id=app_id)
self.ROOT = ROOT
def get_info(self):
res = self.__api.system_get_info()
return res
def get_user_info(self):
res = self.__api.user_get_info()
return res
def get_file_info(self, uploadresult):
return self.__api.file_get_info(uploadresult.quickkey)['result']
def upload_file(self, source_path, source_filename, target_path,
target_filename):
result = None
while not result:
try:
result = self.client.upload_file(
os.path.join(source_path, source_filename),
target_path + "/" + target_filename)
except IsADirectoryError:
result = None # Todo: idk why we need this...
except ResourceNotFoundError:
logging.info("%s path not found, lets create it." %
target_path)
self.client.create_folder(target_path, recursive=True)
result = self.client.get_resource_by_key(result.quickkey)
return result
def do_ls(self, client, args):
"""List directory"""
for item in client.get_folder_contents_iter(args.uri):
# privacy flag
if item['privacy'] == 'public':
item['pf'] = '@'
else:
item['pf'] = '-'
if isinstance(item, Folder):
# type flag
item['tf'] = 'd'
item['key'] = item['folderkey']
item['size'] = ''
else:
item['tf'] = '-'
item['key'] = item['quickkey']
item['name'] = item['filename']
print("{tf}{pf} {key:>15} {size:>10} {created} {name}".format(
**item))
return True
def to_mongo(self, db, folder_pair):
path = folder_pair['mf']
ftp_root = folder_pair['ftp']
coll_name = folder_pair['name']
logging.info("Processing path: %s" % path)
try:
for item in self.client.get_folder_contents_iter(path):
if type(item) is File:
mf_path = (path + item['filename'])
ftp_path = (ftp_root + item['filename'])
logging.debug("Checking in Mongo for %s ==> %s" %
(mf_path, ftp_path))
existing = db.find_by_ftp_path(ftp_path,
coll_name=coll_name)
if existing:
logging.debug("updating Mongo")
item['path'] = path
item["mf_root"] = folder_pair['mf']
db.update_item(existing,
properties={"mf": item},
coll_name=coll_name)
else:
logging.debug("inserting into Mongo")
item['path'] = path
db.insert_one({"mf": item}, coll_name=coll_name)
elif type(item) is Folder:
self.to_mongo(
db, {
"mf": path + item['name'] + '/',
"ftp": folder_pair['ftp'] + item['name'] + '/',
"name": coll_name
})
except ResourceNotFoundError as rne:
logging.error("Resource NOT Found: %s", exc_info=rne)
return
except Exception as e:
logging.error("Error: %s", exc_info=e)
def main(): # pylint: disable=too-many-statements
"""Main entry point"""
parser = argparse.ArgumentParser(prog='mediafire-cli', description=__doc__)
parser.add_argument('--debug',
dest='debug',
action='store_true',
default=False,
help='Enable debug output')
parser.add_argument('--email',
dest='email',
required=False,
default=os.environ.get('MEDIAFIRE_EMAIL', None))
parser.add_argument('--password',
dest='password',
required=False,
default=os.environ.get('MEDIAFIRE_PASSWORD', None))
actions = parser.add_subparsers(title='Actions', dest='action')
# http://bugs.python.org/issue9253#msg186387
actions.required = True
# ls
subparser = actions.add_parser('ls', help=do_ls.__doc__)
subparser.add_argument('uri',
nargs='?',
help='MediaFire URI',
default='mf:///')
# file-upload
subparser = actions.add_parser('file-upload', help=do_file_upload.__doc__)
subparser.add_argument('paths', nargs='+', help='Path[s] to upload')
subparser.add_argument('dest_uri', help='Destination MediaFire URI')
# file-download
subparser = actions.add_parser('file-download',
help=do_file_download.__doc__)
subparser.add_argument('uris',
nargs='+',
help='MediaFire File URI[s] to download')
subparser.add_argument('dest_path', help='Destination path')
# file-show
subparser = actions.add_parser('file-show', help=do_file_show.__doc__)
subparser.add_argument('uris',
nargs='+',
help='MediaFire File URI[s] to print out')
# folder-download
subparser = actions.add_parser('folder-download',
help=do_folder_download.__doc__)
subparser.add_argument('uri',
nargs='?',
help='MediaFire URI',
default='mf:///')
subparser.add_argument('dest_path', help='Destination path')
# folder-create
subparser = actions.add_parser('folder-create',
help=do_folder_create.__doc__)
subparser.add_argument('uris',
nargs='+',
help='MediaFire folder path URI[s]')
# resource-delete
subparser = actions.add_parser('resource-delete',
help=do_resource_delete.__doc__)
subparser.add_argument('uris', nargs='+', help='MediaFire resource URI[s]')
subparser.add_argument('--purge',
help="Purge, don't send to trash",
dest="purge",
action="store_true",
default=False)
# file-update-metadata
subparser = actions.add_parser('file-update-metadata',
help=do_file_update_metadata.__doc__)
subparser.add_argument('uri', help='MediaFire file URI')
subparser.add_argument('--filename',
help='Set file name',
default=None,
dest='filename')
subparser.add_argument('--privacy',
help='Set file privacy',
choices=['public', 'private'],
default=None,
dest='privacy')
subparser.add_argument('--description',
help='Set file description',
dest='description',
default=None)
subparser.add_argument('--mtime',
help="Set file modification time",
dest='mtime',
default=None)
# folder-update-metadata
subparser = actions.add_parser('folder-update-metadata',
help=do_folder_update_metadata.__doc__)
subparser.add_argument('uri', help='MediaFire folder URI')
subparser.add_argument('--foldername',
help='Set folder name',
default=None,
dest='foldername')
subparser.add_argument('--privacy',
help='Set folder privacy',
choices=['public', 'private'],
default=None,
dest='privacy')
subparser.add_argument('--recursive',
help='Set privacy recursively',
action='store_true',
default=None,
dest='recursive')
subparser.add_argument('--description',
help='Set folder description',
dest='description',
default=None)
subparser.add_argument('--mtime',
help='Set folder mtime',
default=None,
dest='mtime')
# debug-get-resource
subparser = actions.add_parser('debug-get-resource',
help=do_debug_get_resource.__doc__)
subparser.add_argument('uri',
help='MediaFire resource URI',
default='mediafire:/',
nargs='?')
args = parser.parse_args()
if args.debug:
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logging.getLogger("mediafire.client").setLevel(logging.DEBUG)
client = MediaFireClient()
if args.email and args.password:
client.login(args.email, args.password, app_id=APP_ID)
router = {
"file-upload": do_file_upload,
"file-download": do_file_download,
"file-show": do_file_show,
"ls": do_ls,
'folder-download': do_folder_download,
"folder-create": do_folder_create,
"resource-delete": do_resource_delete,
"file-update-metadata": do_file_update_metadata,
"folder-update-metadata": do_folder_update_metadata,
"debug-get-resource": do_debug_get_resource
}
if args.action in router:
result = router[args.action](client, args)
if not result:
sys.exit(1)
else:
print('Unsupported action: {}'.format(args.action))
sys.exit(1)
def __get_client(self, user, password):
client = MediaFireClient()
client.login(email=user, password=password, app_id='42511')
return client
def setUp(self):
# we can operate w/o login
self.client = MediaFireClient(_api=DummyMediaFireApi)
import shlex
import shutil
import subprocess
import time
from django.conf import settings
from celery import group, chord, chain
from celery.decorators import task
from PIL import Image
import requests
from mediafire.client import MediaFireClient, File, Folder
from .utils import url2filename, extract_images_url
from .models import Manga, Volume, Chapter
client = MediaFireClient()
client.login(email=settings.MEDIAFIRE_EMAIL,
password=settings.MEDIAFIRE_PASSWORD,
app_id='42511')
UPLOAD_FOLDER = settings.MEDIAFIRE_FOLDER
# https://stackoverflow.com/questions/31784484/how-to-parallelized-file-downloads
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s')
def download(chapter_id, index, path, url):
filename = url2filename(url, chapter_id, index)
logging.debug('downloading %s', filename)
r = requests.get(url, stream=True)
if r.status_code == 200:
with open(os.path.join(path, filename), 'wb') as f:
def createfolder(foldername):
client = MediaFireClient()
client.login( email='*****@*****.**',
password='******',
app_id='42511')
client.create_folder('/'+foldername)
def main(argv):
vnumber = "0.3"
print('mfcmd.py v' + vnumber, file=sys.stderr)
account = ''
passphrase = ''
filepath = ''
filepathbase = ''
filesize = ''
localhash = ''
uldir = ''
try:
opts, args = getopt.getopt(argv,"e:p:u:h:f:",["email=","password="******"upload-folder=","hash=","file="])
except getopt.GetoptError:
print('Error!', file=sys.stderr)
return
for opt, arg in opts:
if opt in ("-e", "--email"):
account = arg
elif opt in ("-p", "--password"):
passphrase = arg
elif opt in ("-u", "--upload-folder"):
uldir = arg
elif opt in ("-s", "--size"):
filesize = arg
elif opt in ("-h", "--hash"):
localhash = arg
elif opt in ("-f", "--file"):
filepath = arg
if account == '':
print('Error:credentials')
return
else:
print('Email: ' + account, file=sys.stderr)
if passphrase == '':
print('Error:credentials')
return
else:
print('Password: '******'':
print('Error:filepath')
return
else:
if os.path.exists(filepath):
if os.path.isfile(filepath):
print('Filepath: ' + filepath, file=sys.stderr)
filepathbase = os.path.basename(filepath)
print('Filename: ' + filepathbase, file=sys.stderr)
else:
print('Error:noregularfile')
return
else:
print('Error:nofile')
return
if uldir == '':
uldir = 'mfcmd'
print('Upload folder: ' + uldir, file=sys.stderr)
if localhash == '':
print('No SHA-256 specified: calculating...', file=sys.stderr)
sha256_hash = hashlib.sha256()
with open(filepath,"rb") as f:
for byte_block in iter(lambda: f.read(4096),b""):
sha256_hash.update(byte_block)
localhash = sha256_hash.hexdigest()
print('Checksum: ' + localhash, file=sys.stderr)
api = MediaFireApi()
try:
session = api.user_get_session_token(
email=account,
password=passphrase,
app_id='42511')
print('MediaFire API: connected', file=sys.stderr)
api.session = session
except:
print('Error:login')
try:
userinfo = api.user_get_info()
print("Account holder: " + userinfo['user_info']['display_name'], file=sys.stderr)
maxstore = userinfo['user_info']['storage_limit']
usedstore = userinfo['user_info']['used_storage_size']
freestore = int(maxstore)-int(usedstore)
freestore_str = str(freestore)
print("Maximum storage: " + maxstore, file=sys.stderr)
print("Used storage: " + usedstore, file=sys.stderr)
print("Free storage: " + freestore_str, file=sys.stderr)
localsize = os.path.getsize(filepath)
localsize_str = str(localsize)
print("Local file size: " + localsize_str, file=sys.stderr)
if freestore <= localsize:
print("Error: available space will not suffice!", file=sys.stderr)
print("Error:space")
return
else:
print("Available filespace will suffice", file=sys.stderr)
except:
print('Error getting or parsing user info', file=sys.stderr)
client = MediaFireClient()
try:
client.login(email=account,
password=passphrase,
app_id='42511')
print('MediaFire Client: logged in', file=sys.stderr)
except:
print('Error:login')
return
try:
client.get_resource_by_path("/" + uldir + "/")
print('Detected upload folder ./' + uldir, file=sys.stderr)
except:
print('Error: upload folder ./' + uldir, 'does not exist!', file=sys.stderr)
try:
client.create_folder("mf:/" + uldir)
except:
print('Could not create upload folder: defaulting to root', file=sys.stderr)
uldir = ''
try:
if uldir == '':
fileinfo = client.get_resource_by_path("/" + filepathbase)
remotehash = fileinfo['hash']
if localhash == remotehash:
print('Same file already exists: no upload necessary!', file=sys.stderr)
try:
dlurl = fileinfo['links']['normal_download']
dlurl = dlurl.replace('http://www.', 'https://')
print(dlurl)
except:
print('Error:link')
return
else:
print('Error: filename already exists in upload folder', file=sys.stderr)
posixtime = int(time.time())
posixtext = str(posixtime)
uldir = posixtext
print('Creating root subfolder: /' + uldir, file=sys.stderr)
try:
client.create_folder("mf:/" + uldir)
except:
print('Error:folder')
return
else:
fileinfo = client.get_resource_by_path("/" + uldir + "/" + filepathbase)
remotehash = fileinfo['hash']
if localhash == remotehash:
print('Same file already exists: no upload necessary!', file=sys.stderr)
try:
dlurl = fileinfo['links']['normal_download']
dlurl = dlurl.replace('http://www.', 'https://')
print(dlurl)
except:
print('Error:link')
return
else:
print('Error: filename already exists in upload folder', file=sys.stderr)
posixtime = int(time.time())
posixtext = str(posixtime)
uldir = uldir + '/' + posixtext
print('Creating subfolder: ./' + uldir, file=sys.stderr)
try:
client.create_folder("mf:/" + uldir)
except:
print('Could not create upload folder: defaulting to root', file=sys.stderr)
uldir = ''
except:
print('File does not exist in upload folder', file=sys.stderr)
try:
if uldir == '':
client.upload_file(filepath, "mf:/")
else:
client.upload_file(filepath, "mf:/" + uldir + "/")
except:
print('Error: upload function', file=sys.stderr)
try:
if uldir == '':
fileinfo = client.get_resource_by_path("/" + filepathbase)
else:
fileinfo = client.get_resource_by_path("/" + uldir + "/" + filepathbase)
dlurl = fileinfo['links']['normal_download']
dlurl = dlurl.replace('http://www.', 'https://')
print(dlurl)
except:
print('Error:upload')
return
def main():
"""Main entry point"""
parser = argparse.ArgumentParser(prog='mediafire-cli',
description=__doc__)
parser.add_argument('--debug', dest='debug', action='store_true',
default=False, help='Enable debug output')
parser.add_argument('--email', dest='email', required=False)
parser.add_argument('--password', dest='password', required=False)
actions = parser.add_subparsers(title='Actions', dest='action')
# http://bugs.python.org/issue9253#msg186387
actions.required = True
# ls
subparser = actions.add_parser('ls',
help=do_ls.__doc__)
subparser.add_argument('uri', nargs='?',
help='MediaFire URI',
default='mediafire:/')
# file-upload
subparser = actions.add_parser('file-upload',
help=do_file_upload.__doc__)
subparser.add_argument('paths', nargs='+',
help='Path[s] to upload')
subparser.add_argument('dest_uri', help='Destination MediaFire URI')
# file-download
subparser = actions.add_parser('file-download',
help=do_file_download.__doc__)
subparser.add_argument('uris', nargs='+',
help='MediaFire File URI[s] to download')
subparser.add_argument('dest_path', help='Destination path')
# file-show
subparser = actions.add_parser('file-show',
help=do_file_show.__doc__)
subparser.add_argument('uris', nargs='+',
help='MediaFire File URI[s] to print out')
# folder-create
subparser = actions.add_parser('folder-create',
help=do_folder_create.__doc__)
subparser.add_argument('uri', help='MediaFire folder path URI')
# resource-delete
subparser = actions.add_parser('resource-delete',
help=do_resource_delete.__doc__)
subparser.add_argument('uri', help='MediaFire resource URI')
subparser.add_argument('--purge', help="Purge, don't send to trash",
dest="purge", action="store_true", default=False)
# file-update-metadata
subparser = actions.add_parser('file-update-metadata',
help=do_file_update_metadata.__doc__)
subparser.add_argument('uri', help='MediaFire file URI')
subparser.add_argument('--filename', help='Set file name',
default=None, dest='filename')
subparser.add_argument('--privacy', help='Set file privacy',
choices=['public', 'private'],
default=None, dest='privacy')
subparser.add_argument('--description',
help='Set file description',
dest='description', default=None)
subparser.add_argument('--mtime', help="Set file modification time",
dest='mtime', default=None)
# folder-update-metadata
subparser = actions.add_parser('folder-update-metadata',
help=do_folder_update_metadata.__doc__)
subparser.add_argument('uri', help='MediaFire folder URI')
subparser.add_argument('--foldername', help='Set folder name',
default=None, dest='foldername')
subparser.add_argument('--privacy', help='Set folder privacy',
choices=['public', 'private'],
default=None, dest='privacy')
subparser.add_argument('--recursive', help='Set privacy recursively',
action='store_true', default=None,
dest='recursive')
subparser.add_argument('--description',
help='Set folder description',
dest='description', default=None)
subparser.add_argument('--mtime', help='Set folder mtime',
default=None, dest='mtime')
# debug-get-resource
subparser = actions.add_parser('debug-get-resource',
help=do_debug_get_resource.__doc__)
subparser.add_argument('uri', help='MediaFire resource URI',
default='mediafire:/', nargs='?')
args = parser.parse_args()
if args.debug:
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logging.getLogger("mediafire.client").setLevel(logging.DEBUG)
client = MediaFireClient()
if args.email and args.password:
client.login(args.email, args.password, app_id=APP_ID)
router = {
"file-upload": do_file_upload,
"file-download": do_file_download,
"file-show": do_file_show,
"ls": do_ls,
"folder-create": do_folder_create,
"resource-delete": do_resource_delete,
"file-update-metadata": do_file_update_metadata,
"folder-update-metadata": do_folder_update_metadata,
"debug-get-resource": do_debug_get_resource
}
if args.action in router:
result = router[args.action](client, args)
if not result:
sys.exit(1)
else:
print('Unsupported action: {}'.format(args.action))
sys.exit(1)
#!/usr/bin/python3
import os
import logging
logging.basicConfig()
logging.getLogger().setLevel(logging.DEBUG)
from mediafire.client import MediaFireClient
APP_ID = '42511'
MEDIAFIRE_EMAIL = os.environ['MEDIAFIRE_EMAIL']
MEDIAFIRE_PASSWORD = os.environ['MEDIAFIRE_PASSWORD']
client = MediaFireClient()
client.login(app_id=APP_ID, email=MEDIAFIRE_EMAIL, password=MEDIAFIRE_PASSWORD)
print("Use 'client' object to interact with MediaFireClient")
