def url(self, name): if name.startswith(self.location): name = name[len(self.location) + 1:] name = os.path.basename(self.location) + "/" + name if self.base_url is None: raise ValueError("This file is not accessible via a URL.") myurl = urlparse.urljoin(self.base_url, filepath_to_uri(name)) if "static" not in self.location: # Use a dynamic URL for "non-static" files. try: new_name = os.path.dirname(self.location) + "/" + name fp = filepath_to_uri(new_name) cache_key = 'django-dropbox-size:{}'.format(fp) myurl = cache.get(cache_key) if not myurl: try: shared_link = self.client.sharing_create_shared_link(fp) myurl = shared_link.url + '&raw=1' logger.debug("shared link: {0}, myurl: {1}".format(shared_link, myurl)) except Exception,e: logger.exception(e) if myurl is None: temp_link = self.client.files_get_temporary_link(fp) myurl = temp_link.link logger.debug("temp link: {0}, myurl: {1}".format(temp_link, myurl)) cache.set(cache_key, myurl, SHARE_LINK_CACHE_TIMEOUT) except Exception,e: logger.exception(e)
def size(self, name): cache_key = 'django-dropbox-size:%s' % filepath_to_uri(name) size = cache.get(cache_key) if not size: size = self.client.metadata(filepath_to_uri(name))['bytes'] cache.set(cache_key, size, CACHE_TIMEOUT) return size
def url(self, name): cache_key = 'django-dropbox-url:%s' % filepath_to_uri(name) url = cache.get(cache_key) if not url: url = self.client.share(filepath_to_uri(name), short_url=False)['url'] + '?dl=1' cache.set(cache_key, url, CACHE_TIMEOUT) return url
def url(self, name): cache_key = 'django-dropbox-url:%s' % filepath_to_uri(name) url = cache.get(cache_key) if not url: url = self.client.share(filepath_to_uri(name), short_url=False)['url'] # this replace is for force to dropbox url to send the url like a content and don't # like a link to donwload url = url.replace("www", "photos-4") cache.set(cache_key, url, CACHE_TIMEOUT) return url
def send_file(request, filepath, last_modified=None, filename=None): fullpath = filepath # Respect the If-Modified-Since header. statobj = os.stat(fullpath) if filename: mimetype, encoding = mimetypes.guess_type(filename) else: mimetype, encoding = mimetypes.guess_type(fullpath) mimetype = mimetype or 'application/octet-stream' if settings.USE_SENDFILE: response = django_sendfile_response(request, filepath) else: response = HttpResponse(open(fullpath, 'rb').read(), content_type=mimetype) if not last_modified: response["Last-Modified"] = http_date(statobj.st_mtime) else: if isinstance(last_modified, datetime): last_modified = float(dateformat.format(last_modified, 'U')) response["Last-Modified"] = http_date(epoch_seconds=last_modified) response["Content-Length"] = statobj.st_size if encoding: response["Content-Encoding"] = encoding if filename: filename_escaped = filepath_to_uri(filename) response["Content-Disposition"] = "attachment; filename=%s" % filename_escaped return response
def url(self, name): if self.base_url is None: raise ValueError("This file is not accessible via a URL.") url = filepath_to_uri(name) if url is not None: url = url.lstrip("/") return urljoin(self.base_url, url)
def _get_SIZE_url(self, size): photosize = PhotoSizeCache().sizes.get(size) if not self.size_exists(photosize): self.create_size(photosize) if photosize.increment_count: self.increment_count() return "/".join([self.cache_url(), filepath_to_uri(self._get_filename_for_size(photosize.name))])
def size(self, name): cache_key = 'django-dropbox-size:{}'.format(filepath_to_uri(name)) size = cache.get(cache_key) if not size: size = self.client.files_get_metadata(name).size cache.set(cache_key, size, CACHE_TIMEOUT) return size
def url(self): url = self.file_signature % { 'source': filepath_to_uri(self.source), 'size': self.size_string, 'method': self.method, 'secret': self.secret, 'extension': self.extension} return urlparse.urljoin(self.base_url, url)
def url(self, name): """ Returns an absolute URL where the file's contents can be accessed directly by a Web browser. """ if self.aws_s3_public_url: return urljoin(self.aws_s3_public_url, filepath_to_uri(name)) return self._generate_url(name)
def url(self, name): name = self._normalize_name(self._clean_name(name)) name = filepath_to_uri(name) expire = 3600 if not hasattr(settings, 'QINIU_PREVIEW_EXPIRE') else settings.QINIU_PREVIEW_EXPIRE protocol = 'https://' if self.secure_url else 'http://' url = urljoin(protocol + self.bucket_domain, name) return self.auth.private_download_url(url, expires=expire)
def url(self, name): name = self._normalize_name(self._clean_name(name)) name = filepath_to_uri(name) protocol = u'https://' if self.secure_url else u'http://' url = urljoin(protocol + self.bucket_domain, name) if self.private_url: return self.auth.private_download_url(url, self.private_url_expires) else: return url
def _get_SIZE_url(self, size): photosize = [item for item in PHOTOREPORT_SIZES if item['name'] == size][0] if not self.size_exists(photosize): self.create_size(photosize) if photosize['increment_count']: self.increment_count() return '/'.join([self.cache_url(), filepath_to_uri(self._get_filename_for_size(photosize['name']))])
def url(self, name, headers=None, response_headers=None): name = self._normalize_name(self._clean_name(name)) if self.custom_domain: return "%s//%s/%s" % (self.url_protocol, self.custom_domain, filepath_to_uri(name)) return self.connection.generate_url(self.querystring_expire, method='GET', bucket=self.bucket.name, key=self._encode_name(name), headers=headers, query_auth=self.querystring_auth, force_http=not self.secure_urls, response_headers=response_headers)
def url(self, name): if DIRECT_IMAGE_URL: if self.base_url is None: raise ValueError("This file is not accessible via a URL.") base_url = self.base_url else: base_url = settings.MEDIA_URL if name.startswith('/Public'): name = name[len('/Public') + 1:] return urlparse.urljoin(base_url, filepath_to_uri(name))
def _get_url(self, name, public=False): """ Gets url for the file specified by name. Public argument defines that public_host or dav_host is used. """ if public: scheme = self.scheme host = self.public_host else: scheme = "http" host = self.dav_host return urlparse.urljoin("%s://%s%s" % (scheme, host, self.base_url), filepath_to_uri(name))
def url(self, name, headers=None, response_headers=None): # Preserve the trailing slash after normalizing the path. trailing_slash = '/' if name.endswith('/') else '' name = self._normalize_name(self._clean_name(name)) + trailing_slash if self.custom_domain: return "%s//%s/%s" % (self.url_protocol, self.custom_domain, filepath_to_uri(name)) return self.connection.generate_url(self.querystring_expire, method='GET', bucket=self.bucket.name, key=self._encode_name(name), headers=headers, query_auth=self.querystring_auth, force_http=not self.secure_urls, response_headers=response_headers)
def url(self, name): try: info = self._get_info(name) if not info: raise BlobKeyRequiredError('No blob info found for %s.' % name) return get_serving_url(info.key()) except (NotImageError, TransformationError): return None except BlobKeyRequiredError: if settings.DEBUG: return urlparse.urljoin(settings.MEDIA_URL, filepath_to_uri(name)) else: raise
def url(self, name): if self.base_url is None: raise ValueError("This file is not accessible via a URL.") try: if '%s' in self.base_url: base_url = self.base_url % connection.schema_name else: base_url = u"{0}{1}/".format(self.base_url, connection.schema_name) except AttributeError: base_url = self.base_url return urljoin(base_url, filepath_to_uri(name))
def url(self, path): cache_key = 'django-imgur-url:%s' % filepath_to_uri(path) url = cache.get(cache_key) if not url: directory = os.path.dirname(path) name = os.path.basename(path) album = [a for a in self.albums if a.title == directory][0] images = self.client.get_album_images(album.id) image = [im for im in images if im.name == path][0] url = self.client.get_image(image.id).link cache.set(cache_key, url) return url
def size(self, path): cache_key = 'django-imgur-size:%s' % filepath_to_uri(path) size = cache.get(cache_key) if not size: directory = os.path.dirname(path) name = os.path.basename(path) album = [a for a in self.albums if a.title == directory][0] images = self.client.get_album_images(album.id) image = [im for im in images if im.name == path][0] size = self.client.get_image(image.id).size cache.set(cache_key, size) return size
def url(self, name, use_cache=True): if not settings.FACETS_ENABLED: return super(FacetsFilesMixin, self).url(name) # Is file compilable? then get generated name compiler = default_handlers.get_compiler(None, self, name) if compiler: name = compiler.new_name # Is file in cache? cached_file = use_cache and self.file_cache.get(self.cache_key(name)) or None if not cached_file: return super(FacetsFilesMixin, self).url(name) return urljoin(self.base_url, filepath_to_uri(cached_file))
def test_posix_paths(self): """ Use posixpath to test posix paths independently from current os """ filebrowser.base.os.path = posixpath site.directory = "uploads/" filebrowser.base.MEDIA_URL = "/media/" f = FileObject("uploads/$%^&*/測試文件.jpg", site=site) self.assertEqual(f.path_relative_directory, "$%^&*/測試文件.jpg") self.assertEqual(f.directory, "$%^&*/測試文件.jpg") self.assertEqual(f.folder, r"$%^&*") # Check url gets well encoded self.assertEqual(f.url, filepath_to_uri("/media/uploads/$%^&*/測試文件.jpg"))
def url(self, name, parameters=None, expire=None): # Preserve the trailing slash after normalizing the path. # TODO: Handle force_http=not self.secure_urls like in s3boto name = self._normalize_name(self._clean_name(name)) if self.custom_domain: return "%s//%s/%s" % (self.url_protocol, self.custom_domain, filepath_to_uri(name)) if expire is None: expire = self.querystring_expire params = parameters.copy() if parameters else {} params['Bucket'] = self.bucket.name params['Key'] = self._encode_name(name) url = self.bucket.meta.client.generate_presigned_url( 'get_object', Params=params, ExpiresIn=expire ) if self.querystring_auth: return url return self._strip_signing_parameters(url)
def __init__(self, relative_source, requested_size, opts=None, quality=None, basedir=None, subdir=None, prefix=None, relative_dest=None, processors=None, extension=None): if isinstance(relative_source, basestring): relative_source = force_unicode(relative_source) # Set the absolute filename for the source file source = self._absolute_path(relative_source) else: source = relative_source quality = get_thumbnail_setting('QUALITY', quality) convert_path = get_thumbnail_setting('CONVERT') wvps_path = get_thumbnail_setting('WVPS') if processors is None: processors = PROCESSORS #dynamic_import(get_thumbnail_setting('PROCESSORS')) # Call super().__init__ now to set the opts attribute. generate() won't # get called because we are not setting the dest attribute yet. super(_DjangoThumbnail, self).__init__(source, requested_size, opts=opts, quality=quality, convert_path=convert_path, wvps_path=wvps_path, processors=processors) # Get the relative filename for the thumbnail image, then set the # destination filename if relative_dest is None: relative_dest = \ self._get_relative_thumbnail(relative_source, basedir=basedir, subdir=subdir, prefix=prefix, extension=extension) filelike = not isinstance(relative_dest, basestring) if filelike: self.dest = relative_dest else: self.dest = self._absolute_path(relative_dest) # Call generate now that the dest attribute has been set self.generate() # Set the relative & absolute url to the thumbnail if not filelike: self.relative_url = filepath_to_uri(relative_dest) self.absolute_url = '%s%s' % (settings.MEDIA_URL, self.relative_url)
def url(self, name, headers=None, response_headers=None, expire=None): # Preserve the trailing slash after normalizing the path. name = self._normalize_name(self._clean_name(name)) if self.custom_domain: return "%s//%s/%s" % (self.url_protocol, self.custom_domain, filepath_to_uri(name)) if expire is None: expire = self.querystring_expire return self.connection.generate_url( expire, method="GET", bucket=self.bucket.name, key=self._encode_name(name), headers=headers, query_auth=self.querystring_auth, force_http=not self.secure_urls, response_headers=response_headers, )
def generate_presigned_post_url(self, name, expire=3600): # Preserve the trailing slash after normalizing the path. name = self._normalize_name(self._clean_name(name)) if self.custom_domain: return '%s//%s/%s' % (self.url_protocol, self.custom_domain, filepath_to_uri(name)) if expire is None: expire = self.querystring_expire content_type, _ = guess_type(name) return self.connection.generate_url( expire, method='PUT', bucket=self.bucket.name, key=self._encode_name(name), headers={'Content-Type': content_type}, query_auth=self.querystring_auth, force_http=not self.secure_urls, response_headers={}, )
def url(self, name): """In-memory files aren't actually URL-accessible; we'll pretend.""" return urlparse.urljoin(settings.MEDIA_URL, filepath_to_uri(name))
def url(self, name): return settings.FRONTEND_PROXY_URL.format( filename=filepath_to_uri(name))
def url(self, name, headers=None, response_headers=None, expire=None): return '{}{}'.format(settings.STATIC_URL, filepath_to_uri(name))
def get_thumbnail_url(self): """ Returns the (absolute) URL for the image's thumbnail version. """ return urljoin(settings.MEDIA_URL, filepath_to_uri(self.get_thumbnail_path()))
def url(self): return self.get_file_url(filepath_to_uri(self.name))
def test_filepath_to_uri(self): self.assertEqual(filepath_to_uri('upload\\чубака.mp4'), 'upload/%D1%87%D1%83%D0%B1%D0%B0%D0%BA%D0%B0.mp4')
def test_filepath_to_uri(self): self.assertEqual(filepath_to_uri('upload\\чубака.mp4'), 'upload/%D1%87%D1%83%D0%B1%D0%B0%D0%BA%D0%B0.mp4') self.assertEqual(filepath_to_uri('upload\\чубака.mp4'.encode('utf-8')), 'upload/%D1%87%D1%83%D0%B1%D0%B0%D0%BA%D0%B0.mp4')
def url(self, name): name = self._normalize_name(self._clean_name(name)) name = filepath_to_uri(name) return '/%s' % name
def url(self, name): """In-memory files aren't actually URL-accessible; we'll pretend.""" return urlparse.urljoin('/media/', filepath_to_uri(name))
def url(self, name): if self.base_url is None: raise ValueError("This file is not accessible via a URL.") return urlparse.urljoin(self.base_url, filepath_to_uri(name))
def test_filepath_to_uri(self): self.assertEqual(filepath_to_uri(None), None) self.assertEqual(filepath_to_uri('upload\\чубака.mp4'), 'upload/%D1%87%D1%83%D0%B1%D0%B0%D0%BA%D0%B0.mp4')
def create_missing_vhigh_placeholders(gallery_slug): gallery = Gallery.objects.get(slug=gallery_slug) photocustoms = [] for p in gallery.photos.all().order_by('id'): photocustoms.append(PhotoCustom.objects.get(photo_id=p.id)) n = len(photocustoms) print('Found %d photos in gallery "%s"\n' % (n, gallery.title)) for i, pc in enumerate(photocustoms): photosize = PhotoSizeCache().sizes.get('vhigh_display_placeholder') if pc.size_exists(photosize): print('Placeholder already exists for "%s" at %s' % (pc.photo.title, pc._get_SIZE_url('vhigh_display_placeholder'))) continue display_size = 'vhigh_display' photosize_display = PhotoSizeCache().sizes.get(display_size) if not pc.photo.size_exists(photosize_display): pc.photo.create_size(photosize_display) print('Created %s' % pc.photo._get_filename_for_size(display_size)) i_relpath = '/'.join([ pc.photo.cache_url(), filepath_to_uri(pc.photo._get_filename_for_size(display_size)) ]) o_relpath = '/'.join([ pc.photo.cache_url(), filepath_to_uri(pc._get_filename_for_size(photosize.name)) ]) i_path = os.path.abspath(i_relpath[1:]) o_path = os.path.abspath(o_relpath[1:]) cmd = '/usr/bin/npx sqip -o {} -m {} -n {} -b {} {}'.format( \ o_path, self.placeholder_primitive_mode, self.placeholder_primitive_number, self.placeholder_blur, i_path) #cmd = '/usr/bin/npx sqip -i {} -o {} -w {} -m {} -n {} -b {}'.format( \ # i_path, # o_path, # pc.placeholder_width, # pc.placeholder_primitive_mode, # pc.placeholder_primitive_number, # pc.placeholder_blur) try: subprocess.run(cmd.split(), timeout=180, check=True) print('Created a placeholder for photo "%s" (%d / %d)' % (pc.photo.title, i + 1, n)) except subprocess.CalledProcessError: print( 'Creating a placeholder for %s returned a non-zero exit status!' % i_path) sys.exit() except subprocess.TimeoutExpired: print('Creating a placeholder for %s timed out!' % i_path) sys.exit() try: tree = ET.parse(o_path) root = tree.getroot() dimensions = root.attrib['viewBox'].split()[2:4] root.attrib['width'] = dimensions[0] + 'px' root.attrib['height'] = dimensions[1] + 'px' tree.write(open(o_path, 'wb')) print('Updated placeholder SVG dimensions') except Exception: print('Writing placeholder dimensions for %s failed!' % i_path) print()
def fotos(request, path=''): path = unquote(path) if any(k in request.GET for k in ['album', 'search_album', 'search_tag']): # redirect old URL path = request.GET.get('album', '') q = None if request.GET.get('search_album'): q = 'album:' + request.GET.get('search_album') if request.GET.get('search_tag'): q = 'tag:' + request.GET.get('search_tag') url = reverse('fotos', kwargs={'path': path}) if q is not None: qs = QueryDict('', mutable=True) qs['q'] = q url += '?' + qs.urlencode() return redirect(url, permanent=True) album = fEs.by_path(path) if album is None: bits = path.rsplit('/', 1) if len(bits) == 2: path = bits[0] name = bits[1].replace('+', ' ') entity = fEs.by_path_and_name(path, name) if entity is not None: # Zen Photo used + signs in the filename part of the URL. url = reverse('fotos', kwargs={'path': path}) \ + '#' + filepath_to_uri(name) return redirect(url, permanent=True) raise Http404 if album._type != 'album': # This is a photo, not an album. # Backwards compatibility, probably to Zen Photo. url = reverse('fotos', kwargs={'path': album.path}) \ + '#' + filepath_to_uri(album.name) return redirect(url, permanent=True) user = request.user if request.user.is_authenticated() else None if not album.may_view(user) and user is None: # user is not logged in return redirect_to_login(request.get_full_path()) if not album.may_view(user): # user is logged in, but may not view the album title = album.title if not title: title = album.name # respond with a nice error message response = render( request, 'fotos/fotos.html', {'fotos': {'parents': album_parents_json(album)}, 'error': 'permission-denied'}, ) response.status_code = 403 return response if 'download' in request.GET: if album.is_root: # Downloading ALL photos would be way too much raise PermissionDenied download = ZipSeeker() add_download_files(download, album, album.full_path, user) response = StreamingHttpResponse(download.blocks(), content_type='application/zip') response['Content-Length'] = download.size() response['Last-Modified'] = http_date(download.lastModified()) # TODO: human-readable download name? response['Content-Disposition'] = 'attachment; filename=' + \ album.name + '.zip' return response people = None if fEs.is_admin(user): # Get all members (now or in the past), and sort them first # by whether they are active (active members first) and # then by their name. humanNames = {} active = [] inactive = [] for u in Es.users(): humanNames[str(u.name)] = six.text_type(u.humanName) if u.is_active: active.append(str(u.name)) else: inactive.append(str(u.name)) active.sort() inactive.sort() people = [] for name in active + inactive: people.append((name, humanNames[name])) fotos = album_json(album, user) return render(request, 'fotos/fotos.html', {'fotos': fotos, 'fotos_admin': fEs.is_admin(user), 'people': people})
def url(self, name): name = self._normalize_name(self._clean_name(name)) name = filepath_to_uri(name) protocol = 'https://' if self.secure_url else 'http://' return urljoin(protocol + self.bucket_domain, name)
def url(self, name): path = self._git_path(name) if self.base_url is None: raise ValueError("This file is not accessible via a URL.") return urljoin(self.base_url, filepath_to_uri(path))
def url(self, name): try: return super(DevBlobstoreStorage, self).url(name) except BlobKeyRequiredError: return urlparse.urljoin(settings.MEDIA_URL, filepath_to_uri(name))
def test_filepath_to_uri(inp): filepath_to_uri(inp)
def url(self, name): return self.BASE_URL + filepath_to_uri(name)
def get_avatar(self, business: Business): if not business.avatar: return None filepath = filepath_to_uri(business.avatar.name) return f"{settings.MEDIA_URL}{filepath}"
def full_url(self, name): name = self._normalize_name(self._clean_name(name)) name = filepath_to_uri(name) full_url = urllib.parse.urljoin(settings.REMOTE_MEDIA_URL, name) log.info('>>> QiniuStorage full_url: %s' % name) return full_url
def get_base_url(self): return filepath_to_uri("model_browser/images/textured_polyhedrons/"+self.polyhedron_mapped_to.name +"/"+self.texture_mapped_from.texture_line.name+"/")
def url(self, name): return urljoin(self.base_url, filepath_to_uri(name))
def url(self, name): if self.base_url is None: raise ValueError("This file is not accessible via a URL.") return urljoin(self.base_url, filepath_to_uri(name))
def _url(self, name): return urljoin('/', filepath_to_uri(name))