def render_file(filename, parents):
mimetype = mimetypes.MimeTypes().guess_type(filename)[0]
app.logger.info("%s mimetype is %s", filename, mimetype)
content = s3.content(filename)
if mimetype in ("text/csv", "text/tab-separated-values"):
delimiter = "\t" if mimetype == "text/tab-separated-values" else ","
table = csv_table(content, delimiter)
return render_template("s3list.html", crumbs=parents, s3objects=table)
else:
mimetype = "application/octet-stream"
return send_file(io.BytesIO(content), mimetype=mimetype)
def downloadFile():
file_id = ObjectId(request.json['file_id'])
data = fs.get(file_id)
file_name = request.json['file_name']
file_type = mimetypes.MimeTypes().guess_type(str(file_name))[0]
fileBytes = data.read()
return send_file(io.BytesIO(fileBytes),
attachment_filename=file_name,
mimetype=file_type)
def handle_file(self, status_code, path, file_path):
self.send_response(status_code)
content, encoding = memetypes.MimeTypes().guess_type(file_path)
info = os.stat(file_path)
print(content, encoding, info)
self.send_header("Content-Type", content)
self.send_header("Content-Encoding", encoding)
self.send_header("Content-Length", info.st_size)
self.end_headers()
return
def test_encoding(self):
getpreferredencoding = locale.getpreferredencoding
self.addCleanup(setattr, locale, 'getpreferredencoding',
getpreferredencoding)
locale.getpreferredencoding = lambda: 'ascii'
filename = support.findfile("mime.types")
mimes = mimetypes.MimeTypes([filename])
exts = mimes.guess_all_extensions('application/vnd.geocube+xml',
strict=True)
self.assertEqual(exts, ['.g3', '.g\xb3'])
def mimeType(self):
if self._mimeType:
return self._mimeType
elif isinstance(self.source, AttachmentRef):
return self.source.mimeType
elif isinstance(self.source, pathlib.Path):
mimeType, encoding = mimetypes.MimeTypes().guess_type(
str(self.source))
return mimeType
def get_data(self, uri):
'''
TODO: This function has to be updated for M2
'''
docroot = "/home/prem/Documents/IOS/M4/"
if uri == "/bin/":
data = "Can not access bin directory"
return 404, "text/plain", len(data), data.encode()
elif uri.startswith("/bin"):
stdin = sys.stdin.fileno() # usually 0
stdout = sys.stdout.fileno() # usually 1
pr, cw = os.pipe()
pid = os.fork()
if pid > 0:
os.close(cw)
os.dup2(pr, stdin)
res = ""
for line in sys.stdin:
res = res + line + "<br>"
return 200, "text/html", len(res), res.encode()
else:
os.close(pr)
os.dup2(cw, stdout)
args = [docroot[:-1] + uri]
if uri.find(".py") != -1:
cmd = "python3"
args = [cmd, docroot[:-1] + uri]
os.execvp(args[0], args)
else:
os.execvp(args[0], args)
else:
if uri == "/":
text = os.listdir("./www/")
data = ""
for i in text:
if not i.startswith("."):
data = data + '''<a href = ''' + "/" + i + '''>''' + i + '''</a><br>'''
return 200, "text/html", len(data), data.encode()
elif os.path.isfile("./www" + uri):
mime = mimetypes.MimeTypes().guess_type("./www" + uri)[0]
file_pointer = open("./www" + uri, 'rb')
data = file_pointer.read()
return 200, mime, len(data), data
elif os.path.isdir("./www" + uri):
text = os.listdir("./www" + uri)
data = ""
for i in text:
if not i.startswith("."):
data = data + '''<a href = ''' + uri + "/" + i + '''>''' + i + '''</a><br>'''
return 200, "text/html", len(data), data.encode()
else:
data = "<h1>File Not Found</h1>"
return 404, "text/html", len(data), data.encode()
def send_header_as_code(self, status_code, url):
"""send the header of the response with the given status code"""
mime_url = url
if mime_url[-1] == '/':
mime_url = url + "index.html"
mime_type = mimetypes.MimeTypes().guess_type(mime_url)[0]
if mime_type is None:
mime_type = "text/html"
self.send_response(status_code)
self.send_header("Content-type", mime_type)
self.end_headers()
def handle_upload(self, soc, addr):
header = soc.recv(1024).decode().splitlines()
try:
print("Received header : ")
print(header)
version = header[0].split()[-1]
num = header[0].split()[-2]
method = header[0].split()[0]
path = '%s/rfc%s.txt' % (self.DIR, num)
if version != self.V:
soc.sendall(str.encode(
self.V + ' 505 P2P-CI Version Not Supported\n'))
elif not Path(path).is_file():
soc.sendall(str.encode(self.V + ' 404 Not Found\n'))
elif method == 'GET':
header = self.V + ' 200 OK\n'
header += 'Data: %s\n' % (time.strftime(
"%a, %d %b %Y %H:%M:%S GMT", time.gmtime()))
header += 'OS: %s\n' % (platform.platform())
header += 'Last-Modified: %s\n' % (time.strftime(
"%a, %d %b %Y %H:%M:%S GMT", time.gmtime(os.path.getmtime(path))))
header += 'Content-Length: %s\n' % (os.path.getsize(path))
header += 'Content-Type: %s\n' % (
mimetypes.MimeTypes().guess_type(path)[0])
print("sending first header : ")
print(header)
soc.sendall(header.encode())
# Uploading
try:
print('\nUploading...')
send_length = 0
with open(path, 'r') as file:
to_send = file.read(1024)
while to_send:
send_length += len(to_send.encode())
soc.sendall(to_send.encode())
to_send = file.read(1024)
except Exception:
raise MyException('Uploading Failed')
# total_length = int(os.path.getsize(path))
# print('send: %s | total: %s' % (send_length, total_length))
# if send_length < total_length:
# raise MyException('Uploading Failed')
print('Uploading Completed.')
# Restore CLI
print(
'\n 1: Add file for sharing\n 2: Fetch a file information\n 3: View the database\n 4: Download file\n 5: Shut Down the peer\n\nEnter your request: ')
else:
raise MyException('Bad Request.')
except Exception:
soc.sendall(str.encode(self.V + ' 400 Bad Request\n'))
finally:
soc.close()
def get(self, request, name):
print(name)
filepath = os.path.join(ARCHIVE_DIR, name)
if not os.path.exists(filepath):
print('NOT FOUND')
return HttpResponseNotFound('File not found')
mimetype = mimetypes.MimeTypes().guess_type(filepath)[0]
response = HttpResponse()
response['X-Sendfile'] = filepath
response['Content-Type'] = mimetype
response['Content-Disposition'] = 'attachment; filename=%s' % name
return response
def istext(filename):
global args
dump("Checking type of {}".format(filename), 2)
m = mimetypes.MimeTypes()
type, subtype = m.guess_type(filename)
dump("mimetypes returns {} ".format(type), 2)
if type and ('text' in type):
dump("Retuning True", 3)
return True
else:
dump("Retuning False", 3)
return False
def get_file_info(filename: str) -> dict:
"""Given a file path returns its size (in bytes) and its name"""
if not os.path.isfile(filename):
return {}
st = os.stat(filename)
name = os.path.basename(filename)
mime = mimetypes.MimeTypes().guess_type(filename)[0]
return {
"size": st.st_size,
"name": name,
"mime": mime
}
def send_from_package(package, directory, filename, **options):
fp = read_from_package(package, directory, filename)
options.setdefault('conditional', True)
mimetype = mimetypes.MimeTypes().guess_type(filename, strict=False)[0]
try:
return flask.send_file(fp, mimetype=mimetype, **options)
except ValueError:
print("still having mimetype problems. See app.py")
mimetype = "application/octet stream"
return flask.send_file(fp, mimetype=mimetype, **options)
def assets_set_asset(self, asset_name, file, **kwargs):
"""Set an asset image by name."""
content_type = mimetypes.MimeTypes().guess_type(file)
files = {
asset_name: (file, open(file, "rb"), content_type[0], {
"Expires": "0"
}),
}
return self.call_api_post("assets.setAsset",
kwargs=kwargs,
use_json=False,
files=files)
def validate_video_file(upload):
"""
Validates uploaded file name by using mimetypes, part of Python standard
library, to guess the mime type from the file extension.
The file extension is not a reliable way to determine mime type. A better
alternative is using the python-magic library, but that requires the
libmagic library which is extra overhead, so not worth.
"""
mime_type = mimetypes.MimeTypes().guess_type(upload.name)[0]
if mime_type not in VIDEO_MIME_TYPES:
raise ValidationError('File type not supported. MP4, Quicktime, or WebM recommended.')
def assets_set_asset(self, asset_name, file, **kwargs):
"""Set an asset image by name."""
content_type = mimetypes.MimeTypes().guess_type(file)
files = {
asset_name: (file, open(file, 'rb'), content_type[0], {
'Expires': '0'
}),
}
return self.__call_api_post('assets.setAsset',
kwargs=kwargs,
use_json=False,
files=files)
def findvideos(item):
# logger.debug('DEBUG', item)
item.contentTitle = item.fulltitle
itemlist = []
json = []
if 'links' in item.url:
json = item.url['links']
elif 'find_links' in item.url:
for link in item.url['find_links']:
link['url'] = unshortenit.findlinks(link['url'])
mimetype = findS = None
mimetype = mimetypes.MimeTypes().guess_type(link['url'])[0]
if mimetype is None:
findS = servertools.get_server_from_url(link['url'])
if mimetype is None and findS is None:
data = support.match(link['url']).data
itemlist_url = servertools.find_video_items(data=data)
if len(itemlist_url):
for item_url in itemlist_url:
valid = True
patterns = link.get('patterns', False)
if patterns:
valid = False
for pattern in patterns:
match = re.search(pattern, item_url.url)
if match:
valid = True
break
if valid:
json.append({"url": item_url.url})
else:
json.append(link)
else:
url = item.url
item.url = {}
json.append({"url": url})
# support.dbg()
for option in json:
extra = set_extra_values(item, option, item.path)
itemlist.append(
item.clone(url=option['url'],
action='play',
quality=extra.quality,
contentLanguage=extra.language,
extraInfo=extra.info))
videolibrary = item.url.get('videolibrary', True)
item.autoplay = item.url.get('autoplay', False)
item.url = '' # do not pass referer
return support.server(item, itemlist=itemlist, Videolibrary=videolibrary)
def mixresque(self, message):
t = time.asctime(time.localtime(time.time()))
error_file = '<html><head><title>404 Not Found</title></head><body bgcolor="red"><center>' \
'<h1>404 Not Found</h1></center><hr><center>nginx</center></body></html>'
error = 'HTTP/1.1 404 Not Found\r\nDate: '+ t +'\r\nServer: NetSec Prototype Server 1.0\r\n' \
'Content-Length: '+str(len(error_file))+'\r\nContent-Type:' \
' text/html\r\n\r\n'
command, vals = message.split('\r\n', 1)
method, uri, version = command.split(' ')
if method != 'GET':
self.transport.write(str.encode(error + error_file))
self.transport.close()
if version[-3:] not in ['1.1', '1.0']:
self.transport.write(str.encode(error + error_file))
self.transport.close()
if self.document_root[-1:] == '/':
if len(self.document_root) > 1:
self.document_root = self.document_root[:-1]
else:
self.document_root = ''
address = self.document_root + '/' + uri
if os.path.isdir(address):
address += '/index.html'
con_type = mimetypes.MimeTypes().guess_type(address)[0]
# print("con_type: ", con_type)
try:
last_modified = time.asctime(
time.localtime(os.stat(address).st_mtime))
except Exception:
last_modified = t
try:
file = open(address,
'rb') # open file , r => read , b => byte format
response = file.read()
file.close()
con_length = len(response)
except Exception as e:
self.transport.write(str.encode(error + error_file))
self.transport.close()
else:
out = 'HTTP/1.1 200 OK\r\nDate: '+t+'\r\nServer: NetSec Prototype Server 1.0\r\n' \
'Last-Modified: '+last_modified+'\r\nContent-Length: '+str(con_length)+'\r\nConnection:' \
' close\r\nContent-Type: '+con_type+'\r\n\r\n'
# print(out)
self.transport.write(str.encode(out) + response)
self.transport.close()
def send_email():
subject = request.form['email-subject']
body = request.form['email-body']
emails = request.form['emails']
if subject and body and emails:
msg = EmailMessage()
asparagus_cid = make_msgid()
msg['Subject'] = subject
msg['From'] = '*****@*****.**'
msg['To'] = (emails)
msg.add_alternative(body.format(asparagus_cid=asparagus_cid[1:-1]),
subtype='html')
if 'email-attachments[]' in request.files:
files = request.files.getlist('email-attachments[]')
for file in files:
filename = secure_filename(file.filename)
ctype = mimetypes.MimeTypes().guess_type(filename)[0]
if ctype is None:
ctype = 'application/octet-stream'
maintype, subtype = ctype.split('/', 1)
f_data = file.read()
msg.add_attachment(f_data,
maintype=maintype,
filename=filename,
subtype=subtype)
s = smtplib.SMTP('smtp.gmail.com', 587)
s.starttls()
s.login('*****@*****.**', 'gmail password')
s.send_message(msg)
s.quit()
flash('Email successfully sent to recepients')
return render_template('emails.html', color='green')
else:
flash('Email subject, body and list of emails are required field')
return render_template('emails.html', color='red')
def run_errands(self):
args = self.get_configured_args()
if (args.get("list")
and not mimetypes.MimeTypes().guess_type(args["list"])[0] == "text/plain"
):
raise ArgumentError(
"{0} is not of a valid argument to --list, argument must be plain text file.".format(
args["list"]
)
)
if args.get("write_m3u") and not args.get("list"):
raise ArgumentError("--write-m3u can only be used with --list.")
if args["write_to"] and not (
args.get("playlist") or args.get("album") or args.get("all_albums") or args.get("username") or args.get("write_m3u")
):
raise ArgumentError(
"--write-to can only be used with --playlist, --album, --all-albums, --username, or --write-m3u."
)
ffmpeg_exists = shutil.which("ffmpeg")
if not ffmpeg_exists:
logger.warn("FFmpeg was not found in PATH. Will not re-encode media to specified output format.")
args["no_encode"] = True
if args["no_encode"] and args["trim_silence"]:
logger.warn("--trim-silence can only be used when an encoder is set.")
if args["output_file"] == "-" and args["no_metadata"] is False:
logger.warn(
"Cannot write metadata when target is STDOUT. Pass "
"--no-metadata explicitly to hide this warning."
)
args["no_metadata"] = True
elif os.path.isdir(args["output_file"]):
adjusted_output_file = os.path.join(
args["output_file"],
self.parser.get_default("output_file")
)
logger.warn(
"Given output file is a directory. Will download tracks "
"in this directory with their filename as per the default "
"file format. Pass --output-file=\"{}\" to hide this "
"warning.".format(
adjusted_output_file
)
)
args["output_file"] = adjusted_output_file
return args
def adhocBackupFiles(fromPatterns, backupDirID, user_agent):
logging.debug("Adhoc backup fromPatterns: " + str(fromPatterns))
logging.debug("Adhoc backup backupDirID: " + backupDirID)
logging.debug("Adhoc backup user_agent: " + user_agent)
backupTimestamp = datetime.datetime.now().isoformat()
drive_service = getDriveService(user_agent)
copyCount = 0
newCount = 0
replacedCount = 0
filesToCopy = []
for fromPattern in fromPatterns:
globResult = glob.glob(fromPattern)
logging.debug("glob of " + fromPattern + " returned " +
str(globResult))
filesToCopy.extend(globResult)
logging.debug("Files to copy: " + str(filesToCopy))
for file in filesToCopy:
file_size = os.path.getsize(file)
if file_size == 0:
raise Exception(
"The file, " + file +
" is empty. This application cannot copy empty (size = 0) files to Google Drive."
)
matchesFound = deleteIfThere(file, backupDirID, drive_service)
if matchesFound == 0:
newCount += 1
else:
replacedCount += matchesFound
shortFileName = ntpath.basename(file)
MIMETYPE = mimetypes.MimeTypes().guess_type(shortFileName, False)[0]
TITLE = shortFileName
DESCRIPTION = 'Backup from hassio of ' + file
backupFile(file, backupDirID, drive_service, MIMETYPE, TITLE,
DESCRIPTION)
copyCount += 1
result = {
'adhocBackupTimestamp': backupTimestamp,
'fromPatterns': fromPatterns,
'backupDirID': backupDirID,
'copyCount': copyCount,
'newCount': newCount,
'replacedCount': replacedCount
}
return result
def upload(self, account_id, filename):
files = {
'file': (os.path.basename(filename), open(filename, 'rb'),
mimetypes.MimeTypes().guess_type(filename)[0])
}
res = self.session.post(self.api_url + f'account/{account_id}/upload',
headers={'X-File-Parse': 'true'},
files=files)
res.raise_for_status()
res = res.json()
logging.debug(f'uploaded {filename}, response "{res}"')
return res
def __init__(self, **kwargs):
BaseObject.__init__(self, **kwargs)
Config.__init__(self, **kwargs)
self._default_filetype = None
self._mimetypes = mimetypes.MimeTypes()
self.filetypes = {}
filetype_data = kwargs.get('filetype_data', [])
for data in filetype_data:
self.add_filetype(**data)
self.recent_files = {}
self.files_by_path = {}
self.get_recent_files()
self.bind(current_file=self._on_current_file_set)
def visit_file(self, name):
if not os.path.isfile(name):
error('Must be a valid file [', name, ']')
return
mime = mimetypes.MimeTypes().guess_type(name)[0]
if not mime:
error('Unknown file type [', name, ']')
return
mm = mime.split('/')
if mm[0] == 'text':
self.process_text_file(name)
else:
self.process_external_app(name)
def status_code_200(self, path):
# OK
# https://www.tutorialspoint.com/How-to-find-the-mime-type-of-a-file-in-Python, Author: Rajendra Dharmkar, Published on 27-Dec-2017 15:55:12
# https://www.geeksforgeeks.org/python-os-path-basename-method/#:~:text=basename()%20method%20in%20Python,pair%20(head%2C%20tail)., Author: ihritik, Last Updated : 26 Aug, 2019
mimetype = mimetypes.MimeTypes().guess_type(os.path.basename(path))[0]
try:
with open(self.ROOT + path, "r") as f:
content = f.read()
if self.DEBUG: return bytearray(f"HTTP/1.1 200 OK\r\nCache-Control: no-cache\r\nContent-type:{mimetype}\r\n\r\n{content}", "utf-8")
return bytearray(f"HTTP/1.1 200 OK\r\nContent-type:{mimetype}\r\n\r\n{content}", "utf-8")
except:
# Error(s) occured while reading file :(
return bytearray(self.status_code_500())
def file_getmime(filepath):
'''获取文件mime类型
:param filepath: 提供文件路径
:return: mime类型
'''
mimetypes.init('/usr/local/openresty/nginx/conf/mime.types')
mime = mimetypes.MimeTypes()
mimetype = mime.guess_type(filepath)
if mimetype[0] == "None":
from magic import Magic
f = Magic(mime=True)
return f.from_file(filepath)
return mimetype[0]
def __init__(self,
folderModel,
dataFileIndex,
existingUnverifiedDatafile,
verificationModel,
bytesUploadedPreviously=None):
self.folderModel = folderModel
self.dataFileIndex = dataFileIndex
self.uploadModel = None
self.existingUnverifiedDatafile = existingUnverifiedDatafile
self.verificationModel = verificationModel
self.bytesUploadedPreviously = bytesUploadedPreviously
self.mimeTypes = mimetypes.MimeTypes()
def get_mimetype(path):
"""Get the mimetype of a file, using either libmagic or the mimetypes module when libmagic is not available."""
if not os.path.exists(path):
raise ValueError(path)
try:
import magic
mime = magic.Magic(mime=True)
return mime.from_file(path)
except ImportError:
import mimetypes
mime = mimetypes.MimeTypes()
return mime.guess_type(path)[0]
def __init__(
self,
*args,
data_type: DataType,
group: typing.Optional[str],
source: str,
mime_type: typing.Optional[str] = None,
unit: typing.Optional[int] = None,
name: typing.Optional[str] = None,
duplicate_timestamp_strategy:
DuplicateTimestampStrategy = DuplicateTimestampStrategy.RAISE,
):
self.__data_type = Timeseries.DataType(data_type)
self.__duplicate_timestamp_strategy = Timeseries.DuplicateTimestampStrategy(
duplicate_timestamp_strategy)
if not source:
raise Timeseries.InvalidAttributeError(
"timeseries 'source' attribute cannot be empty")
group_and_source = Timeseries.normalize_group_and_source(group=group,
source=source)
self.__group = group_and_source[0]
self.__source = group_and_source[1]
self.__mime_type = None
if self.__data_type == Timeseries.DataType.BINARY:
if mime_type is None:
raise Timeseries.InvalidAttributeError(
"unable to initialize Timeseries with data type BINARY without mime type"
)
# use mime_types_db.add_type or mime_types_db.read to add additional,
# potentially custom types if they happen to be missing from the default db
mime_types_db = mimetypes.MimeTypes(strict=True)
mime_types_db.add_type("application/octet-stream",
".bin",
strict=False)
self.__mime_type = mime_type.strip().lower()
if (self.__mime_type not in mime_types_db.types_map_inv[0] and
self.__mime_type not in mime_types_db.types_map_inv[1]):
raise Timeseries.InvalidAttributeError(
f"unknown mime type '{self.__mime_type}")
self.__timestamps = {}
self.__read_only = False
self.__values = []
self.__unit_id = None if unit is None or unit == -1 else int(unit)
self.__name = name.strip() if name else None
def check_file_before_transfer(self,
path,
encryption,
contact,
groupchat=False):
if not path or not os.path.exists(path):
return
invalid_file = False
stat = os.stat(path)
if os.path.isfile(path):
if stat[6] == 0:
invalid_file = True
msg = _('File is empty')
else:
invalid_file = True
msg = _('File does not exist')
if self.max_file_size is not None and \
stat.st_size > self.max_file_size:
invalid_file = True
size = GLib.format_size_full(self.max_file_size,
GLib.FormatSizeFlags.IEC_UNITS)
msg = _('File is too large, '
'maximum allowed file size is: %s') % size
if invalid_file:
self._raise_information_event('open-file-error2', msg)
return
mime = mimetypes.MimeTypes().guess_type(path)[0]
if not mime:
mime = 'application/octet-stream' # fallback mime type
self._log.info("Detected MIME type of file: %s", mime)
try:
transfer = HTTPFileTransfer(self._account, self._cancel_upload,
path, contact, mime, encryption,
groupchat)
app.interface.show_httpupload_progress(transfer)
except Exception as error:
self._log.exception('Error while loading file')
self._raise_information_event('open-file-error2', str(error))
return
if encryption is not None:
app.interface.encrypt_file(transfer, self._account,
self._request_slot)
else:
self._request_slot(transfer)
def init_mimedb():
"""Initialize the local MIME database."""
global mimedb
try:
mimedb = mimetypes.MimeTypes(strict=False)
except StandardError as msg:
log.error(LOG_CHECK, "could not initialize MIME database: %s" % msg)
return
# For Opera bookmark files (opera6.adr)
add_mimetype(mimedb, 'text/plain', '.adr')
# To recognize PHP files as HTML with content check.
add_mimetype(mimedb, 'application/x-httpd-php', '.php')
# To recognize WML files
add_mimetype(mimedb, 'text/vnd.wap.wml', '.wml')
