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 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 __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_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,
'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,
'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 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 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_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)
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 createfolder(foldername):
client = MediaFireClient()
client.login( email='*****@*****.**',
password='******',
app_id='42511')
client.create_folder('/'+foldername)
def __get_client(self, user, password):
client = MediaFireClient()
client.login(email=user, password=password, app_id='42511')
return client
#!/usr/bin/env python3
from mediafire.client import (MediaFireClient, File, Folder)
client = MediaFireClient()
client.login(app_id='45211')
client.download_file("mf:/i547ewwpknmh41l","thing")
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 setUp(self):
# we can operate w/o login
self.client = MediaFireClient(_api=DummyMediaFireApi)
