def get_file_name_mime(self, url):
		pgctnt, hName, mime = self.wg.getFileNameMime(url)

		parsed = urllib.parse.urlparse(url)
		pathname = os.path.split(parsed.path)[-1]
		if not hName and not mime and not pathname:
			self.log.error("cannot figure out content type for url: %s", url)
			return pgctnt, "unknown.unknown", "application/octet-stream"

		# empty path with mimetype of text/html generally means it's a directory index (or some horrible dynamic shit).
		if not hName and not pathname and mime == "text/html":
			self.log.info("No path and root location. Assuming index.html")
			return pgctnt, "index.html", "text/html"

		ftype, guessed_mime = mimetypes.guess_type(hName)
		if ftype:
			return pgctnt, hName, guessed_mime if not mime else mime

		ftype, guessed_mime = mimetypes.guess_type(pathname)
		if ftype:
			return pgctnt, pathname, guessed_mime if not mime else mime

		chunks = [hName, pathname]
		chunks = [chunk for chunk in chunks if chunk]

		outname = " - ".join(chunks)
		if mime and mimetypes.guess_extension(mime):
			newext = mimetypes.guess_extension(mime)
		else:
			newext = ".unknown"

		if not outname:
			outname = "unknown"
		return pgctnt, outname+newext, mime if mime else "application/octet-stream"

def _upload_plot(client, bucket, plot):

    extra_args = dict(ACL='public-read')
    url_template = '//{0}.s3.amazonaws.com/{1}/{2}/{3}'

    with DirectoryContext(plot.directory) as dir_ctx:
        try:
            extra_args['ContentType'] = mime.guess_type(plot.content)[0]
            client.upload_file(plot.content, bucket,
                               path.join(plot.plot_id, plot.version, plot.content),
                               ExtraArgs=extra_args)

            extra_args['ContentType'] = mime.guess_type(plot.thumbnail)[0]
            client.upload_file(plot.thumbnail, bucket,
                               path.join(plot.plot_id, plot.version, plot.thumbnail),
                               ExtraArgs=extra_args)

            if path.exists('resources'):
                for dir_path, subdir_list, file_list in walk('resources'):
                    for fname in file_list:
                        full_path = path.join(dir_path, fname)
                        extra_args['ContentType'] = mime.guess_type(full_path)[0]
                        client.upload_file(full_path, bucket,
                                           path.join(plot.plot_id, plot.version, full_path),
                                           ExtraArgs=extra_args)

            results = [url_template.format(bucket, plot.plot_id, plot.version, plot.content),
                       url_template.format(bucket, plot.plot_id, plot.version, plot.thumbnail)]

            return pd.Series(results)

        except botocore.exceptions.ClientError as e:
            print(e.response)
            return False

 def put(self, file='', content_type='', content_enc='',
         isbin=re.compile(r'[\000-\006\177-\277]').search,
         **kw):
     headers = self.__get_headers(kw)
     filetype = type(file)
     if filetype is type('') and (isbin(file) is None) and \
        os.path.exists(file):
         ob = open(file, 'rb')
         body = ob.read()
         ob.close()
         c_type, c_enc = guess_type(file)
     elif filetype is FileType:
         body = file.read()
         c_type, c_enc = guess_type(file.name)
     elif filetype is type(''):
         body = file
         c_type, c_enc = guess_type(self.url)
     else:
         raise ValueError, 'File must be a filename, file or string.'
     content_type = content_type or c_type
     content_enc = content_enc or c_enc
     if content_type: headers['Content-Type'] = content_type
     if content_enc:  headers['Content-Encoding'] = content_enc
     headers['Content-Length'] = str(len(body))
     return self.__snd_request('PUT', self.uri, headers, body)

    def get_detail(self, request, **kwargs):
        """
        Returns a single serialized resource.
        Calls ``cached_obj_get/obj_get`` to provide the data, then handles that result
        set and serializes it.
        Should return a HttpResponse (200 OK).
        Guess the mimetype of the file and return it as an attachment object
        """

        basic_bundle = self.build_bundle(request=request)

        obj = self.obj_get(basic_bundle, **kwargs)

        bundle = self.build_bundle(obj=obj, request=request)
        bundle = self.full_dehydrate(bundle)
        bundle = self.alter_detail_data_to_serialize(request, bundle)

        #return our response here
        #get extension from the FlowFile object
        #match this to a dictionary of mimetypes with extensions
        fb = obj.file.read()
        mimetype = mimetypes.guess_type(obj.full_path)[0]
        #if mimetype.index('spreadsheetml') > 0:
        
        response = http.HttpResponse(fb, content_type=mimetypes.guess_type(obj.full_path)[0])
        #if it's not an image, it is a download link - add the necessary content disposition info
        if(mimetype.count('image') == 0):
            response['Content-Disposition'] = 'attachment; filename=%s' % obj.original_filename
        return response

def _get_resource(resource_url: str) -> (str, bytes):
    """Download or reads a file (online or local).

    Parameters:
        resource_url (str): URL or path of resource to load
    Returns:
        str, bytes: Tuple containing the resource's MIME type and its data.
    Raises:
        NameError: If an HTTP request was made and ``requests`` is not available.
        ValueError: If ``resource_url``'s protocol is invalid.
    """
    url_parsed = urlparse(resource_url)
    if url_parsed.scheme in ['http', 'https']:
        # Requests might not be installed
        if requests_get is not None:
            request = requests_get(resource_url)
            data = request.content
            if 'Content-Type' in request.headers:
                mimetype = request.headers['Content-Type']
            else:
                mimetype = mimetypes.guess_type(resource_url)
        else:
            raise NameError("HTTP URL found but requests not available")
    elif url_parsed.scheme == '':
        # '' is local file
        with open(resource_url, 'rb') as f:
            data = f.read()
        mimetype, _ = mimetypes.guess_type(resource_url)
    elif url_parsed.scheme == 'data':
        raise ValueError("Resource path is a data URI", url_parsed.scheme)
    else:
        raise ValueError("Not local path or HTTP/HTTPS URL", url_parsed.scheme)

    return mimetype, data

def movieView(request,id,movie):
	feature=get_object_or_404(CaseFeature, case__pk=id, name='MovieGallery')
	path=feature.getMoviePath(movie)
	print mimetypes.guess_type(path)[0]
	response=HttpResponse(FileWrapper(open(path)), content_type=mimetypes.guess_type(path)[0])
	response['Content-Length']=os.path.getsize(path)
	return response

 def push_file(self, pfile, body=None, file_type=None, file_name=None):
     # FP
     if not isinstance(pfile, str):
         if os.fstat(pfile.fileno()).st_size > self.UPLOAD_LIMIT:
             return 'File too big'
         if not file_type:
             file_type, __ = mimetypes.guess_type(pfile.name)
         if not file_name:
             file_name = pfile.name
         payload = {'file_type': file_type,
                    'file_name': file_name}
         r = self._s.get(self.UPLOAD_URL, params=payload)
         _pushbullet_responses(r)
         file_url = r.json()['file_url']
         upload_url = r.json()['upload_url']
         data = r.json()['data']
         files = {'file': pfile}
         _pushbullet_responses(requests.post(upload_url, files=files, data=data))
     # String/url
     else:
         if not file_type:
             file_type, __ = mimetypes.guess_type(pfile)
         if not file_name:
             __, file_name = pfile.rsplit('/', 1)
         file_url = pfile
     data = {'type': 'file',
             'file_type': file_type,
             'file_name': file_name,
             'file_url': file_url,
             'body': body}
     return self._push(data)

def save_uploaded():
	fname, content = get_uploaded_content()
	print mimetypes.guess_type(content)
	if content:
		return save_file(fname, content);
	else:
		raise Exception

def create_file_message(recipient_address, *args):
    """ Creates a Python email with file attachments as part of a
    MIME-class message.
    :param recipient_address: Email address of the recipient
    :param *args: List parameter containing filenames
    :return: MIMEMultipart instance
    """
    
    message = MIMEMultipart()
    message["to"] = recipient_address
    
    # Only attach image, plain and html text file types, according to the
    # first element of mimetypes' guess_type method
    for fn in args:
        fn = os.path.normpath(fn)
        
        if not mimetypes.guess_type(fn)[0]:
            continue
        
        if mimetypes.guess_type(fn)[0].find("image") >= 0:
            with open(fn, "rb") as f:
                message.attach(MIMEImage(f.read()))
            
        elif mimetypes.guess_type(fn)[0].find("plain") >= 0:
            with open(fn, "r") as f:
                message.attach(MIMEText(f.read(), "plain"))
                
        elif mimetypes.guess_type(fn)[0].find("html") >= 0:
            with open(fn, "r") as f:
                message.attach(MIMEText(f.read(), "html"))
                
    return message

def theme_create_static_file(request, name):
    theme = get_object_or_404(Theme, name=name)
    ret = {}

    if request.method == 'POST':
        name = request.POST['name']
        if theme.static_files.filter(name=name).count():
            ret = {'result':'error', 'message':'Static File already exists.'}
        else:
            sf = theme.static_files.create(name=name)

            if request.POST.get('url', None):
                sf.url = request.POST['url']
                sf.mime_type = mimetypes.guess_type(sf.url)[0] or ''
                sf.save()
            else:
                # Saves an empty file as a starting point
                file_name = '%s-%s-%s'%(theme.pk, sf.pk, name)
                content = ContentFile('')
                sf.file.save(file_name, content)

                # Detects the mimetype for the given name
                sf.mime_type = mimetypes.guess_type(file_name)[0] or ''
                sf.save()
            ret = {'result':'ok', 'info':{'pk':sf.pk, 'url':sf.get_url()}}

    return HttpResponse(simplejson.dumps(ret), mimetype='text/javascript')

def _get_rss_item(page):
    labels = get_page_labels(page)
    if "draft" in labels or "queue" in labels:
        return ""
    if "date" not in page:
        return ""

    xml = u"<item>\n"
    xml += u"\t<title>%s</title>\n" % _escape_xml(page["title"])
    xml += u"\t<guid>%s</guid>\n" % _full_url(page["url"])
    xml += u"\t<pubDate>%s</pubDate>\n" % _format_rfc_date(page["date"])

    if "file" in page:
        _filename = page["file"].split("/")[-1]
        mime_type = mimetypes.guess_type(_filename)[0]
        xml += u"\t<enclosure url='%s' type='%s' length='%s'/>\n" % (page["file"], mime_type, page.get("filesize", "0"))

    if "illustration" in page:
        _filename = page["illustration"].split("/")[-1]
        mime_type = mimetypes.guess_type(_filename)[0]
        xml += u"\t<enclosure url='%s' type='%s' length='%s'/>\n" % (page["illustration"], mime_type, 0)

    if get_config("rss_with_bodies") != False:
        xml += u"\t<description>%s</description>\n" % _escape_xml(_fix_rss_item_description(page.html, page))

    author = get_page_author(page)
    if author is not None:
        xml += u"\t<author>%s</author>\n" % author.get("email", "[email protected]")

    xml += u"</item>\n"
    return xml

def TextFileChecker(FileFolder, FileName):
    FileCheck = False
        
    if (mimetypes.guess_type(FileFolder + FileName)[0] == 'text/plain') or (mimetypes.guess_type(FileFolder + FileName)[0] == 'application/x-ns-proxy-autoconfig') or (mimetypes.guess_type(FileFolder + FileName)[0] == None):
        FileCheck = True

    return FileCheck

def add_image_set_by_array(images, parents, name):
    # check for duplicate name
    if db.images.find_one({'name': name}) != None:
        raise ValueError(('An image set with the name %s already exists. Please ' +
                         'change the folder name and try uploading again.') % name)

    # put all the parent images into gridFS, save their object IDs
    parent_list = []
    for image in parents:
        with open(image, 'rb') as f:
            data = f.read()
            content_type = guess_type(image)[0]
            if content_type == None:
                raise TypeError(('Couldn\'t guess the file extension for %s. ' +
                                 'Check the filename.') % image)
            parent_id = fs.put(data, content_type=content_type)
            parent_list.append(parent_id)

    # put all the images into gridFS, save their object IDs
    image_list = []
    for image in images:
        with open(image['path'], 'rb') as f:
            data = f.read()
            content_type = guess_type(image['path'])[0]
            if content_type == None:
                raise TypeError(('Couldn\'t guess the file extension for %s. ' +
                                 'Check the filename.') % image['path'])
            image_id = fs.put(data, content_type=content_type)
            image_list.append({'image_id': image_id, 'parent': parent_list[image['category']], 'category': image['category']})

    # save the image set, return the 
    return db.images.insert({'name': name,
                             'parents': parent_list,
                             'images': image_list})

	def clean_file(self):
		data = self.cleaned_data['file']
		task = self.cleaned_data['solution'].task
		max_file_size_kb = task.max_file_size
		max_file_size = 1024 * max_file_size_kb
		supported_types_re = re.compile(task.supported_file_types)
		if data:
			contenttype = mimetypes.guess_type(data.name)[0] # don't rely on the browser: data.content_type could be wrong or empty
			if (contenttype is None) or (not (supported_types_re.match(contenttype) or ziptype_re.match(contenttype))):
				raise forms.ValidationError(_('The file of type %s is not supported.' %contenttype))
			if ziptype_re.match(contenttype):
				try:
					zip = zipfile.ZipFile(data)
					if zip.testzip():
						raise forms.ValidationError(_('The zip file seams to be corrupt.'))
					if sum(fileinfo.file_size for fileinfo in zip.infolist()) > 1000000:
						raise forms.ValidationError(_('The zip file is to big.'))	
					for fileinfo in zip.infolist():
						(type, encoding) = mimetypes.guess_type(fileinfo.filename)
						ignorred = SolutionFile.ignorred_file_names_re.search(fileinfo.filename)
						supported = type and supported_types_re.match(type)
						if not ignorred and not supported:
							raise forms.ValidationError(_("The file '%(file)s' of guessed mime type '%(type)s' in this zip file is not supported." %{'file':fileinfo.filename, 'type':type}))
						# check whole zip instead of contained files
						#if fileinfo.file_size > max_file_size:
						#	raise forms.ValidationError(_("The file '%(file)s' is bigger than %(size)iKB which is not suported." %{'file':fileinfo.filename, 'size':max_file_size_kb}))
				except forms.ValidationError:
					raise
				except:
					raise forms.ValidationError(_('Uhoh - something unexpected happened.'))
			if data.size > max_file_size:
				raise forms.ValidationError(_("The file '%(file)s' is bigger than %(size)iKB which is not suported." %{'file':data.name, 'size':max_file_size_kb}))
			return data

 def add_image(self, album_id, imagename, title, comment, reduce_size, size, colors):
     album_url = "/data/feed/api/user/%s/albumid/%s" % (self.email, album_id)
     mime = mimetypes.guess_type(imagename)[0]
     if mime in SUPPORTED_MIMES or mime in CONVERTED_MIMES:
         temp = None
         if reduce_size is True or colors is True or mime in CONVERTED_MIMES:
             image = Image.open(imagename)
             w, h = image.size
             temp = tempfile.mkstemp(suffix=".png", prefix="picapy_tmp", dir="/tmp")[1]
             print(("converting from %s to %s" % (imagename, temp)))
             if reduce_size is True and (w > size or h > size):
                 maximo = size
                 if w > h:
                     h = h * maximo / w
                     w = maximo
                 else:
                     w = w * maximo / h
                     h = maximo
                 image = image.resize([w, h], Image.ANTIALIAS)
             if colors is True:
                 image = image.convert("P", palette=Image.WEB)
             image.save(temp)
             imagename = temp
             mime = mimetypes.guess_type(imagename)[0]
         try:
             photo = self.gd_client.InsertPhotoSimple(album_url, title, comment, imagename, content_type=mime)
         except GooglePhotosExceptio as e:
             self.gd_client = gdata.photos.service.PhotosService()
             self.gd_client.ProgrammaticLogin()
             photo = self.gd_client.InsertPhotoSimple(album_url, title, comment, imagename, content_type=mime)
         if temp is not None and os.path.exists(temp):
             os.remove(temp)
         return photo

    def test_isbinary(self):
        binary = self.viewer._is_binary
        for f in ['foo.rdf', 'foo.xml', 'foo.js', 'foo.py'
                  'foo.html', 'foo.txt', 'foo.dtd', 'foo.xul',
                  'foo.properties', 'foo.json', 'foo.src', 'CHANGELOG']:
            m, encoding = mimetypes.guess_type(f)
            assert not binary(m, f), '%s should not be binary' % f

        for f in ['foo.dtd', 'foo.xul', 'foo.properties']:
            m, encoding = mimetypes.guess_type(f)
            assert not binary(None, f), '%s should not be binary' % f

        for f in ['foo.png', 'foo.gif', 'foo.exe', 'foo.swf']:
            m, encoding = mimetypes.guess_type(f)
            assert binary(m, f), '%s should be binary' % f

        filename = tempfile.mktemp()
        for txt in ['#python', u'\0x2']:
            open(filename, 'w').write(txt)
            m, encoding = mimetypes.guess_type(filename)
            assert not binary(m, filename), '%s should not be binary' % txt

        for txt in ['#!/usr/bin/python', 'MZ']:
            open(filename, 'w').write(txt)
            m, encoding = mimetypes.guess_type(filename)
            assert binary(m, filename), '%s should be binary' % txt

 def s3write(bucket, root, path):
     #key.set_metadata('mode', str(stat[0]))
     #key.set_metadata('gid', str(stat[5]))
     #key.set_metadata('uid', str(stat[4]))
     #key.set_metadata('mtime', str(stat[8]))
     # GUESS MIME TYPE
     
     #if is_dir:
     #    key.set_contents_from_string("", headers={'Content-Type': 'application/x-directory'})
     
     s3name = FastS3.local_to_s3(root, path)
     log.debug('Executing S3 WRITE BACK for %s' % s3name)
     with FileLock(path):
         key = bucket.get_key(s3name)
         if key is None:
             #New File
             content_type, encoding = mimetypes.guess_type(s3name)
             key = bucket.new_key(s3name)
             log.debug('Writing new file to S3 %s' % s3name)
             key.set_contents_from_filename(path, replace=True,
                                            headers={'Content-Type': content_type})
         else:
             #Check existing file
             content_type, encoding = mimetypes.guess_type(s3name)
             with open(path, 'rb') as f:
                 localmd5 = key.compute_md5(f)[0]
             if key.etag[1:-1] != localmd5:
                 log.info('Overwriting File on S3 %s.' % s3name)
                 key.set_contents_from_filename(path, replace=True,
                                                headers={'Content-Type': content_type})
     log.debug('S3 WRITE BACK complete')

def mimeTypeGuesser(name=None, data=None, content_type=None):
    if name is None and data is None and content_type is None:
        return None

    mimeType = mimeTypeGetter(name=name, data=data, content_type=content_type)

    if name and not mimeType:
        mimeType, encoding = mimetypes.guess_type(name, strict=True)
        if not mimeType:
            mimeType, encoding = mimetypes.guess_type(name, strict=False)
        #
        # XXX If `encoding` is not None, we should re-consider the
        # guess, since the encoding here is Content-Encoding, not
        # charset.  In particular, things like .tar.gz map to
        # ('application/x-tar', 'gzip'), which may require different
        # handling, or at least a separate content-type.

    if data and not mimeType:
        # no idea, really, but let's sniff a few common things:
        for prefix, type, charset in _prefix_table:
            if data.startswith(prefix):
                mimeType = type
                break

    return mimeType

    def load_file(self):
        fname = askopenfilename(filetypes=(("PNG Image", "*.png"),
                                           ("JPG Image", "*.jpg;*.jpeg"),
                                           ("GIF Image", "*.gif"),
                                           ("Bitmap Image", "*.bmp"),
                                           ("All Files", "*")))
        print(mimetypes.guess_type(fname)[0])
        try:
            wp = Client('https://your.wordpress.installation/xmlrpc.php', 'Username', 'password')
        except TimeoutError:
            self.status.delete(0, END)
            self.status.insert(0, 'Unable to connect to WP')
        except gaierror:
            self.status.config(state=NORMAL)
            self.status.delete(1.0, END)
            self.status.insert(1.0, 'DNS lookup failed')
            self.status.config(state=DISABLED)
            raise

        print(MyFrame.path_leaf(fname))
        data = {'name': MyFrame.path_leaf(fname), 'type': mimetypes.guess_type(fname)[0]}
        with open(fname, 'rb') as img:
            data['bits'] = xmlrpc_client.Binary(img.read())
        response = wp.call(media.UploadFile(data))
        print(response['url'])
        self.status.config(state=NORMAL)
        self.status.delete(1.0, END)
        self.status.insert(1.0, 'Link: '+response['url'])
        self.status.config(state=DISABLED)

    def create_message_with_attchments_local_files(cls, sender, to, cc, bcc, subject, message_html):
        message = MIMEMultipart()
        message['to'] = to
        message['cc'] = cc
        message['bcc'] = bcc
        message['from'] = sender
        message['subject'] = subject
        message_html += '<p>Sent from my <a href="http://www.iogrow.com/">ioGrow account </a></p>'
        msg = MIMEText(smart_str(message_html), 'html')
        message.attach(msg)
        path = os.path.join('static/src/img/mail_images', 'sm-iogrow-true.png')
        content_type, encoding = mimetypes.guess_type(path)
        path2 = os.path.join('static/src/img/mail_images', 'Logo-iogrow.png')
        content_type2, encoding2 = mimetypes.guess_type(path2)
        main_type, sub_type = content_type.split('/', 1)
        main_type2, sub_type2 = content_type2.split('/', 1)

        if main_type == 'image':
            fp = open(path, 'r')
            msg = MIMEImage(fp.read(), _subtype=sub_type)
            fp.close()
        if main_type2 == 'image':
            fp2 = open(path2, 'rb')
            msg2 = MIMEImage(fp2.read(), _subtype=sub_type)
            fp2.close()
        msg.add_header('Content-Disposition', 'attachment', filename="logo")
        msg.add_header("Content-ID", "<logo_cid>")
        message.attach(msg)
        msg2.add_header('Content-Disposition', 'attachment', filename="user")
        msg2.add_header("Content-ID", "<user_cid>")
        message.attach(msg2)
        return {'raw': base64.urlsafe_b64encode(message.as_string())}