def ficha_atividade(request, v1, v2):
'''Ficha de Atividade Coletiva da Equipe'''
message = 'Ficha usada apenas pelas equipes PSF'
if Equipe.objects.filter(ine=v2).exists():
response = HttpResponse(content_type='application/pdf')
response['Content-Disposition'] = 'inline;\
filename="%s_ficha_atividade.pdf"' % v2
pdf = canvas.Canvas(response, pagesize=A4)
pdf.drawImage(find('core/img/Ficha_de_Atividade_Coletiva-0.png'),
0, 0, 21*cm, 29.7*cm)
pdf.setFillColor(white)
pdf.rect(10.45*cm, 21.4*cm, 9.83*cm, 3.5*cm, stroke=False,
fill=True)
alt = 24.7*cm
for value in Profissional.objects.filter(equipe__ine=v2).order_by('nome'):
pdf.setFillColor(black)
pdf.setFontSize(0.2*cm)
pdf.drawString(12.4*cm, alt, value.nome)
pdf.drawString(10.6*cm, alt, value.cns)
pdf.drawString(17*cm, alt, value.cbo.cbo)
pdf.drawString(17.7*cm, alt, value.cbo.nome)
alt -= 6.0
pdf.showPage()
pdf.drawImage(find('core/img/Ficha_de_Atividade_Coletiva-1.png'),
0, 0, 21*cm, 29.7*cm)
pdf.showPage()
pdf.save()
return response
else:
return HttpResponse(message)
def register_fonts():
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.pdfbase import pdfmetrics
pdfmetrics.registerFont(TTFont('OpenSans', finders.find('fonts/OpenSans-Regular.ttf')))
pdfmetrics.registerFont(TTFont('OpenSansIt', finders.find('fonts/OpenSans-Italic.ttf')))
pdfmetrics.registerFont(TTFont('OpenSansBd', finders.find('fonts/OpenSans-Bold.ttf')))
def get_media_source_from_url(url):
"""
For a given media/static URL, return the matching full path in the media/static directory
"""
# Media
if MEDIA_URL and url.startswith(MEDIA_URL):
return os.path.join(MEDIA_ROOT, url[len(MEDIA_URL):].lstrip('/'))
elif MEDIA_URL and url.startswith('/media/'):
return os.path.join(MEDIA_ROOT, url[len('/media/'):].lstrip('/'))
# Static
elif STATIC_URL and url.startswith(STATIC_URL):
return find(url[len(STATIC_URL):].lstrip('/'))
elif STATIC_URL and url.startswith('/static/'):
return find(url[len('/static/'):].lstrip('/'))
# External URLs
elif is_remote_url(url):
return url
else:
raise Exception('Invalid media/static url given: %s' % url)
def test_images(self):
abs_path = finders.find('blogango/images/agiliq_blog_logo.png')
self.assertIsNotNone(abs_path)
abs_path = finders.find('blogango/images/person_default.jpg')
self.assertIsNotNone(abs_path)
abs_path = finders.find('logango/images/person_default.jpg')
self.assertIsNone(abs_path)
def test_css(self):
abs_path = finders.find('blogango/css/as_blog_styles.css')
self.assertIsNotNone(abs_path)
abs_path = finders.find('blogango/css/prettify.css')
self.assertIsNotNone(abs_path)
abs_path = finders.find('logango/css/prettify.css')
self.assertIsNone(abs_path)
def get_resized_image(filename, final_resolution):
fullname = finders.find(filename)
filename = filename.split("/").pop()
filename, extension = filename.split(".")
i = Image.open(fullname)
aspect_ratio = i.size[1]/float(i.size[0])
final_width = final_resolution
final_height = int(final_resolution*aspect_ratio)
if i.size[0] < final_resolution:
return fullname, extension
filename = "%s_%s_%s.%s" % (filename, final_width, final_height,
extension)
cache_dir_name = getattr(settings, 'RESPONSIVE_IMAGES_CACHE_DIR',
'responsive_images_cache')
cache_path = os.path.join(settings.MEDIA_ROOT, cache_dir_name)
if not finders.find(cache_dir_name):
os.mkdir(cache_path)
resized_image_full_path = os.path.join(cache_path, filename)
if not finders.find(cache_dir_name + "/" + filename):
size = (final_width, final_height)
resized_image = i.resize(size, Image.ANTIALIAS)
resized_image.save(resized_image_full_path, extension,
quality=getattr('settings', 'RESPONSIVE_IMAGE_QUALITY', 75))
return resized_image_full_path, extension
def fetch_resources(uri, rel):
"""
Retrieves embeddable resource from given ``uri``.
For now only local resources (images, fonts) are supported.
:param str uri: path or url to image or font resource
:returns: path to local resource file.
:rtype: str
:raises: :exc:`~easy_pdf.exceptions.UnsupportedMediaPathException`
"""
# For protocol relative, http and https URLs, we need to short circuit to skip
# path checking at the end of function
if uri.startswith('//') or uri.startswith('http://') or uri.startswith('https://'):
return uri
elif settings.STATIC_URL and uri.startswith(settings.STATIC_URL):
path = finders.find(uri.replace(settings.STATIC_URL, ""))
elif settings.MEDIA_URL and uri.startswith(settings.MEDIA_URL):
path = os.path.join(settings.MEDIA_ROOT, uri.replace(settings.MEDIA_URL, ""))
else:
path = os.path.join(settings.STATIC_ROOT, uri)
if not os.path.isfile(path):
path = finders.find(uri.replace(settings.STATIC_URL, ""))
if not os.path.isfile(path):
raise UnsupportedMediaPathException(
"media urls must start with {} or {}".format(
settings.MEDIA_ROOT, settings.STATIC_ROOT
)
)
return path.replace("\\", "/")
def _create_scan_png(scan, filename, scan_number):
"""
Create standard png with afm and summary information.
"""
image = Image.fromarray(scan.colorize())
if image.size != (512, 512):
logger.debug('Image not correct size: {}, should be 512 x 512'.format(image.size))
image = image.resize((512, 512), resample=Image.NEAREST)
logger.debug('Resized image to 512 x 512')
processed_image = Image.new(image.mode, (654, 580), 'white')
processed_image.paste(image,
(20, 20, image.size[0] + 20, image.size[1] + 20))
calibri = ImageFont.truetype(finders.find('afm/fonts/calibrib.ttf'), 20)
draw = ImageDraw.Draw(processed_image)
scale_image = Image.open(finders.find('afm/img/scale_12.png'))
processed_image.paste(scale_image,
(28 + image.size[0],
30,
28 + image.size[0] + scale_image.size[0],
30 + scale_image.size[1]))
draw.text(
(28 + image.size[0] + scale_image.size[0] + 7, 25),
'{0:.0f} {1}'.format(scan.height_scale, scan.unit), 'black', calibri)
draw.text(
(28 + image.size[0] + scale_image.size[0] + 7, 20 + scale_image.size[1]),
'0.0 {}'.format(scan.unit), 'black', calibri)
zrange_str = 'Z-Range: {0:.2f} nm'.format(scan.zrange)
rms_str = 'RMS: {0:.2f} nm'.format(scan.rms)
size_str = 'Area: {0} \u03bcm X {0} \u03bcm'.format(math.sqrt(scan.scan_area))
draw.text((20, 25 + image.size[1]), filename, 'black', calibri)
draw.text(
(20 + image.size[0] - calibri.getsize(size_str)[0], 25 + image.size[1]),
size_str, 'black', calibri)
if scan.unit == 'nm':
draw.text(
(20, 50 + image.size[1]), zrange_str, 'black', calibri)
draw.text(
(20 + image.size[0] - calibri.getsize(rms_str)[0], 50 + image.size[1]),
rms_str, 'black', calibri)
else:
type_str = '{} AFM'.format(scan.type)
draw.text(
(20 + image.size[0] - calibri.getsize(type_str)[0], 50 + image.size[1]),
type_str, 'black', calibri)
tempio = six.BytesIO()
processed_image.save(tempio, format='PNG')
if scan.type == 'Amplitude':
filename += 'a'
elif scan.type == 'Phase':
filename += 'p'
return InMemoryUploadedFile(
tempio, field_name=None, name=filename + '.png',
content_type='image/png', size=len(tempio.getvalue()), charset=None)
def test_finder_non_jspm_package_file(self):
# assert that it's not found with the standard finders
location = finders.find('node_modules/system.js', all=False)
self.assertIsNone(location)
# but it is found with the custom finder...
with override_settings(STATICFILES_FINDERS=('systemjs.finders.SystemFinder',)):
location = finders.find('node_modules/system.js', all=False)
self.assertIsNone(location)
def render(self, context, instance, placeholder):
context = super(SlickCarouselPlugin, self).render(
context, instance, placeholder)
slick_dict = {'slide': ':not(template)'}
breakpoints = {}
if instance.slick_preset:
slick_dict.update({
'infinite': instance.slick_preset.infinite,
'speed': instance.slick_preset.speed,
'dots': instance.slick_preset.dots,
'arrows': instance.slick_preset.arrows,
'slidesToShow': instance.slick_preset.slides_to_show,
'slidesToScroll': instance.slick_preset.slides_to_scroll,
'autoplay': instance.slick_preset.autoplay,
'autoplaySpeed': instance.slick_preset.autoplay_speed,
'pauseOnHover': instance.slick_preset.pause_on_hover,
'pauseOnDotsHover': instance.slick_preset.pause_on_dots_hover,
'fade': instance.slick_preset.fade,
'rows': instance.slick_preset.rows,
'slidesPerRow': instance.slick_preset.slides_per_row,
'centerMode': instance.slick_preset.center_mode,
'centerPadding': instance.slick_preset.center_padding,
'variableWidth': instance.slick_preset.variable_width,
'adaptiveHeight': instance.slick_preset.adaptive_height,
'vertical': instance.slick_preset.vertical,
'rtl': instance.slick_preset.rigth_to_left,
'respondTo': instance.slick_preset.respond_to,
'mobileFirst': instance.slick_preset.mobile_first,
})
if instance.breakpoints:
breakpoints, responsive = self._get_breakpoints(instance)
slick_dict.update({'responsive': responsive})
breakpoints = json.dumps(breakpoints)
slick_settings = json.dumps(slick_dict)
try:
os.path.isfile(finders.find('cmsplugin_slick/slick/slick.min.js'))
os.path.isfile(finders.find('cmsplugin_slick/slick/slick.css'))
slick_static_path = os.path.dirname(static('cmsplugin_slick/slick/slick.min.js'))
except:
try:
slick_static_path = settings.SLICK_CDN
except:
slick_static_path = '//cdn.jsdelivr.net/jquery.slick/1.6.0/'
context.update({
'slick_settings': slick_settings,
'breakpoints': breakpoints,
'slick_static_path': slick_static_path,
})
return context
def test_font_awesome(self):
path = 'plugins/font-awesome/css/font-awesome.min.css'
absolute_path = finders.find(path)
assert absolute_path is not None
assert os.path.exists(absolute_path)
path = 'plugins/font-awesome/fonts/FontAwesome.otf'
absolute_path = finders.find(path)
assert absolute_path is not None
assert os.path.exists(absolute_path)
def _register_fonts(self):
"""
Register fonts with reportlab. By default, this registers the OpenSans font family
"""
pdfmetrics.registerFont(TTFont('OpenSans', finders.find('fonts/OpenSans-Regular.ttf')))
pdfmetrics.registerFont(TTFont('OpenSansIt', finders.find('fonts/OpenSans-Italic.ttf')))
pdfmetrics.registerFont(TTFont('OpenSansBd', finders.find('fonts/OpenSans-Bold.ttf')))
pdfmetrics.registerFont(TTFont('OpenSansBI', finders.find('fonts/OpenSans-BoldItalic.ttf')))
pdfmetrics.registerFontFamily('OpenSans', normal='OpenSans', bold='OpenSansBd',
italic='OpenSansIt', boldItalic='OpenSansBI')
def dados_utilizados(request):
if finders.find('db-dump/radar.sql.bz2'):
dump_file_path = finders.find('db-dump/radar.sql.bz2')
time = os.path.getmtime(dump_file_path)
dt = datetime.datetime.fromtimestamp(time)
dt_str = dt.strftime('%d/%m/%Y')
arquivo = True
return render_to_response('dados_utilizados.html', {'dumpdate': dt_str, 'arquivo_dump': arquivo},context_instance=RequestContext(request))
else:
arquivo = False
return render_to_response('dados_utilizados.html', {'_arquivo_dump': arquivo})
def populate_player_icons(apps, schema_editor):
Player = apps.get_model("bughouse", "Player")
for player in Player.objects.all():
static_file_name = "{0}.jpg".format(player.name.lower())
static_image_path = find(os.path.join('images', 'player-icons', static_file_name))
if static_image_path:
static_file = open(static_image_path, 'r')
else:
static_file = open(find(os.path.join('images', 'player-icons', 'default.jpg')), 'r')
image_file = File(static_file)
player.icon.save(static_file_name, image_file, save=True)
def test_create_email_msg_attachments(self):
class TestMail(BaseMail):
params = []
template_name = 'test'
test_mail = TestMail()
attachments = [
(finders.find('admin/img/nav-bg.gif'), 'nav-bg.gif', 'image/png'),
(finders.find('admin/css/base.css'), 'base.css', 'plain/text')]
msg = test_mail.create_email_msg([], attachments=attachments)
self.assertEqual(len(msg.attachments), 1) # base.css
self.assertEqual(len(msg.related_attachments), 1) # nav-bg.gif
def static_mtime_b64(*staticfile_paths): """ Return the b64 encoded most recent changed date among staticfile_paths, for cache invalidation. """ latest = None for path in staticfile_paths: found = finders.find(path) if found and (not latest or latest < getmtime(finders.find(path))): latest = getmtime(finders.find(path)) if latest: return float_b64(latest) return None
def _collect_static_file(self, file_type, base_file):
a,b,c = self._get_prefix_triple()
file_list = base_file['file_name']
if not isinstance(file_list, (list, tuple)):
file_list=[file_list]
for f in file_list:
ra,rb,rc = (finders.find(a+f) and a+f,
finders.find(b+f) and b+f,
finders.find(c+f) and c+f)
if ra or rb or rc: break
return ra,rb,rc
def render(self, context):
output = self.nodelist.render(context)
filenames = output.strip().split("\n")
from django.contrib.staticfiles import finders
from django.conf import settings
from django.core.files.storage import default_storage
from django.core.files.base import ContentFile
import os
import re
import sass
foundation_path = finders.find('scss/foundation.scss')
foundation_dir = os.path.dirname(foundation_path)
# include_paths = [os.path.join(d, 'scss') for d in settings.STATICFILES_DIRS] + [foundation_dir.encode('utf-8'),]
include_paths = []
for finder in finders.get_finders():
for path, storage in finder.list([]):
path_dir = os.path.dirname(storage.path(path)).encode('utf-8')
if path_dir not in include_paths:
include_paths.append(path_dir)
for f in filenames:
full_href = re.search('href="(.*)"', f).groups()[0]
if full_href.endswith('.scss'):
cache_key = "sass_%s" % full_href
cached = cache.get(cache_key)
if not cached or settings.DEBUG:
if full_href.startswith(settings.STATIC_URL):
href = full_href.replace(settings.STATIC_URL, '')
destination = href.replace('scss', 'css')
absolute_path = finders.find(href)
elif full_href.startswith(settings.MEDIA_ROOT):
destination = full_href.replace(settings.MEDIA_ROOT, '').replace('scss', 'css')
absolute_path = full_href
content = sass.compile(filename=absolute_path.encode('utf-8'), include_paths=include_paths)
if default_storage.exists(destination):
default_storage.delete(destination)
default_storage.save(destination, ContentFile(content))
cached = os.path.join(settings.MEDIA_URL, destination)
cache.set(cache_key, cached, None)
output = output.replace(full_href, cached)
return output
def dokuman_convert(instance):
if True:
dosya = instance.dosya
klasor = dosya.filename_root + '-katalog-gorunumu-dosyalari'
swfKlasor = os.path.dirname(dosya.path) + '/' + klasor
default_storage.open(dosya.path).file.save_to_filename('/tmp/pdf')
pdf = file('/tmp/pdf', 'rb')
pdfPy = PdfFileReader(pdf)
sayfa = pdfPy.getNumPages()
size_x, size_y = pdfPy.getPage(0).mediaBox.upperRight
if size_x > size_y:
base = file(finders.find('yan.pdf'), 'rb')
else:
base = file(finders.find('portre.pdf'),'rb')
pre_second_page = PdfFileReader(base).getPage(0)
pre_second_page.mediaBox.upperRight = (size_x, size_y)
second_page = PdfFileWriter()
second_page.addPage(pre_second_page)
stream = file('/tmp/fitted_page','wb')
second_page.write(stream)
stream.close()
base.close()
pdf.close()
for i in range(0, sayfa + 1):
args = ['/usr/local/bin/pdf2swf',
'/tmp/pdf', '-o',
'/tmp/' + '%d.swf' % (i + 1,),
'-f', '-T', '9', '-t', '-p',
'%d' % i, '-s', 'storeallcharacters']
if i==0:
args[1] = '/tmp/fitted_page'
args[3] = '/tmp/2.swf'
args[9] = '1'
i = 1
elif i == 1:
args[3] = '/tmp/1.swf'
i = 0
# p = subprocess.Popen(args, stdout=subprocess.PIPE)
# for line in iter(p.stdout.readline, ''):
# print line
# if line[:5] == 'ERROR' or line[:5] == 'FATAL':
args += ['-s', 'poly2bitmap']
p = subprocess.Popen(args)
p.wait()
name = swfKlasor + '/' + '%d.swf' % (i + 1,)
swf_file = open('/tmp/%d.swf' % (i + 1,), 'rb')
swf = swf_file.read()
content = ContentFile(swf)
default_storage.save(name, content)
swf_file.close()
def get_i18n_name(lang_code):
"""Ensure lang_code is supported by Select2."""
lower_lang = lang_code.lower()
split_lang = lang_code.split('-')[0]
# Use the SELECT2_TRANSLATIONS if available
if SELECT2_TRANSLATIONS:
if lower_lang in SELECT2_TRANSLATIONS:
return SELECT2_TRANSLATIONS.get(lower_lang)
elif split_lang in SELECT2_TRANSLATIONS:
return SELECT2_TRANSLATIONS.get(split_lang)
# Otherwise fallback to manually checking if the static file exists
if finders.find('admin/js/vendor/select2/i18n/%s.js' % lang_code):
return lang_code
elif finders.find('admin/js/vendor/select2/i18n/%s.js' % split_lang):
return lang_code.split('-')[0]
def import_pdf_font(self, base_name, face_name):
if self.fonts.get(face_name, None) is None:
afm = find(base_name + '.afm')
pfb = find(base_name + '.pfb')
try:
face = pdfmetrics.EmbeddedType1Face(afm, pfb)
pdfmetrics.registerTypeFace(face)
font = pdfmetrics.Font(face_name, face_name, 'WinAnsiEncoding')
pdfmetrics.registerFont(font)
except:
pass
else:
self.fonts[face_name] = True
def translate_static(value, language):
# Split language and country code
codes = language.split('-')
if len(codes) > 1:
codes[1] = codes[1].upper()
language = '_'.join(codes)
base = codes[0]
if finders.find('locale/%s/%s' % (language, value)): # Looks for language and country code
return 'locale/%s/%s' % (language, value)
elif finders.find('locale/%s/%s' % (base, value)): # Looks for language code
return 'locale/%s/%s' % (base, value)
else:
return value
def getChild(self, path, request):
# trim static/ from beginning of path
path = '/'.join(request.prepath[1:] + request.postpath)
file_path = find(path)
if not file_path:
return self.childNotFound
return self.createSimilarFile(file_path)
def serve(request, path, document_root=None, insecure=False, **kwargs):
"""
Serve static files below a given point in the directory structure or
from locations inferred from the staticfiles finders.
To use, put a URL pattern such as::
(r'^(?P<path>.*)$', 'django.contrib.staticfiles.views.serve')
in your URLconf.
It uses the django.views.static view to serve the found files.
"""
if not settings.DEBUG and not insecure:
raise ImproperlyConfigured("The staticfiles view can only be used in "
"debug mode or if the --insecure "
"option of 'runserver' is used")
normalized_path = posixpath.normpath(unquote(path)).lstrip('/')
absolute_path = finders.find(normalized_path)
if not absolute_path:
if path.endswith('/') or path == '':
raise Http404("Directory indexes are not allowed here.")
raise Http404("'%s' could not be found" % path)
document_root, path = os.path.split(absolute_path)
return static.serve(request, path, document_root=document_root, **kwargs)
def download_anki_backup(request):
from django.contrib.staticfiles import finders
result = finders.find('resources/anki_backup.apkg')
fsock = open(result, 'rb')
response = HttpResponse(fsock, content_type='binary/octet-stream')
response['Content-Disposition'] = "attachment; filename=backup-0.apkg"
return response
def static_proxy(request):
"""
Serves TinyMCE plugins inside the inline popups and the uploadify
SWF, as these are normally static files, and will break with
cross-domain JavaScript errors if ``STATIC_URL`` is an external
host. URL for the file is passed in via querystring in the inline
popup plugin template.
"""
# Get the relative URL after STATIC_URL.
url = request.GET["u"]
protocol = "http" if not request.is_secure() else "https"
host = protocol + "://" + request.get_host()
for prefix in (host, settings.STATIC_URL):
if url.startswith(prefix):
url = url.replace(prefix, "", 1)
response = ""
mimetype = ""
path = finders.find(url)
if path:
if isinstance(path, (list, tuple)):
path = path[0]
with open(path, "rb") as f:
response = f.read()
mimetype = "application/octet-stream"
if url.endswith(".htm"):
# Inject <base href="{{ STATIC_URL }}"> into TinyMCE
# plugins, since the path static files in these won't be
# on the same domain.
mimetype = "text/html"
static_url = settings.STATIC_URL + os.path.split(url)[0] + "/"
if not urlparse(static_url).scheme:
static_url = urljoin(host, static_url)
base_tag = "<base href='%s'>" % static_url
response = response.replace("<head>", "<head>" + base_tag)
return HttpResponse(response, mimetype=mimetype)
def render(self, context):
path = self.path.resolve(context)
if not re.search(r'\.svg$', path):
raise template.TemplateSyntaxError(
"SVG template nodes must be given a path to a SVG file to return.") # NOQA
fullpath = finders.find(path)
if fullpath is None:
raise template.TemplateSyntaxError(
"SVG file ({}) not found.".format(fullpath))
content = open(fullpath, 'r').read()
# Test if it is valid XML
ET.fromstring(content)
if self.kwargs:
kwargs = {x: y.resolve(context) for x, y in self.kwargs.items()}
content = re.sub(
r'(<svg[^>]*)', r'\1{}'.format(flatatt(kwargs)), content,
flags=re.MULTILINE)
if self.varname is None:
return content
context[self.varname] = mark_safe(content)
return ''
def serve(request, path, insecure=False, **kwargs):
"""
Serve static files below a given point in the directory structure or
from locations inferred from the staticfiles finders.
To use, put a URL pattern such as::
from django.contrib.staticfiles import views
path('<path:path>', views.serve)
in your URLconf.
It uses the django.views.static.serve() view to serve the found files.
"""
if not settings.DEBUG and not insecure:
raise Http404
normalized_path = posixpath.normpath(path).lstrip('/')
absolute_path = finders.find(normalized_path)
if not absolute_path:
if path.endswith('/') or path == '':
raise Http404("Directory indexes are not allowed here.")
raise Http404("'%s' could not be found" % path)
document_root, path = os.path.split(absolute_path)
return static.serve(request, path, document_root=document_root, **kwargs)
def get_locale_js_url(lang):
url = 'datepicker/js/locales/bootstrap-datepicker.%s.js' % lang
if finders.find(url):
return settings.STATIC_URL + url
if '-' in lang:
return get_locale_js_url(lang.split('-')[0].lower())
return ''
def serve(request, path, document_root=None, insecure=False, **kwargs):
"""
Serve static files below a given point in the directory structure or
from locations inferred from the staticfiles finders.
To use, put a URL pattern such as::
(r'^(?P<path>.*)$', 'assetfiles.views.serve')
in your URLconf.
It uses the django.views.static view to serve the found files.
"""
if not settings.DEBUG and not insecure:
raise ImproperlyConfigured('The staticfiles view can only be used in '
'debug mode or if the the --insecure '
"option of 'runserver' is used")
normalized_path = posixpath.normpath(unquote(path)).lstrip('/')
static_path = finders.find(normalized_path)
if static_path:
document_root, path = os.path.split(static_path)
return static.serve(request, path, document_root=document_root, **kwargs)
asset_path, filter = assets.find(normalized_path)
if asset_path:
content = filter.filter(asset_path)
mimetype, encoding = mimetypes.guess_type(normalized_path)
return HttpResponse(content, content_type=mimetype)
if path.endswith('/') or path == '':
raise Http404('Directory indexes are not allowed here.')
raise Http404("'%s' could not be found" % path)
@csrf_exempt
def template(request, name, val):
template_conf_missing = False
try:
config.check()
except OSError, e:
if e.errno == errno.ENOENT:
template_conf_missing = True
else:
raise
initialError = None
debug = request.GET.get('debug', False)
theme = request.GET.get('theme', config.ui_config['theme'])
css_file = finders.find('css/dashboard-%s.css' % theme)
if css_file is None:
initialError = "Invalid theme '%s'" % theme
theme = config.ui_config['theme']
context = {
'schemes_json': json.dumps(config.schemes),
'ui_config_json': json.dumps(config.ui_config),
'jsdebug': debug or settings.JAVASCRIPT_DEBUG,
'debug': debug,
'theme': theme,
'initialError': initialError,
'querystring': json.dumps(dict(request.GET.items())),
'template_conf_missing': template_conf_missing,
'userName': '',
'permissions': json.dumps(getPermissions(request.user)),
def static_file_exists(path):
"""Return True/False based on whether a static file exists"""
return True if finders.find(path) else False
def home(request):
# pandas_gbq.context.credentials = credentials
# pandas_gbq.context.project = "bigdata-253023"
state_table_prefix = "home_value_byState_"
county_table_prefix = "home_value_byCounty_"
tables = ["all", "singleFamily", "condo", "topTier", "bottomTier"]
# # Query and save data as dataframes
# data = {}
# hist = {}
# # Query data from BigQuery and cache into pickles
# for i, table in enumerate(tables):
# # State data
# SQL = "SELECT * FROM HomeViz.home_value_byState_" + table
# df = pandas_gbq.read_gbq(SQL)
# data["state_" + table] = df.set_index('RegionName').iloc[:,-1].rename("state_" + table).dropna().to_dict()
# hist["state_" + table] = df.drop(columns=['RegionID', 'SizeRank']).set_index("RegionName").fillna(0).to_dict(orient='index')
# # County data
# SQL = "SELECT * FROM HomeViz.home_value_byCounty_" + table
# df = pandas_gbq.read_gbq(SQL)
# # Create new column "id" by concatenating "StateCodeFIPS" and "MunicipalCodeFIPS" columns
# df["StateCodeFIPS"] = df["StateCodeFIPS"].astype(str).apply(lambda x: x.zfill(2))
# df["MunicipalCodeFIPS"] = df["MunicipalCodeFIPS"].astype(str).apply(lambda x: x.zfill(3))
# df["id"] = df["StateCodeFIPS"] + df["MunicipalCodeFIPS"]
# data["county_" + table] = df.set_index('id').iloc[:,-2].rename("county_" + table).dropna().to_dict()
# hist["county_" + table] = df.drop(columns=['RegionID', 'RegionName', 'State', 'Metro', 'StateCodeFIPS', 'MunicipalCodeFIPS', 'SizeRank']).set_index("id").fillna(0).to_dict(orient='index')
# # Query data from BigQuery and cache into pickles
# for i, table in enumerate(tables):
# # State data
# SQL = "SELECT * FROM HomeViz.home_value_byState_" + table
# df = pandas_gbq.read_gbq(SQL)
# df.to_pickle("./static/dfs{}.pkl".format(i))
# # County data
# SQL = "SELECT * FROM HomeViz.home_value_byCounty_" + table
# df = pandas_gbq.read_gbq(SQL)
# # Create new column "id" by concatenating "StateCodeFIPS" and "MunicipalCodeFIPS" columns
# df["StateCodeFIPS"] = df["StateCodeFIPS"].astype(str).apply(lambda x: x.zfill(2))
# df["MunicipalCodeFIPS"] = df["MunicipalCodeFIPS"].astype(str).apply(lambda x: x.zfill(3))
# df["id"] = df["StateCodeFIPS"] + df["MunicipalCodeFIPS"]
# df.to_pickle("./static/dfc{}.pkl".format(i))
# data = {}
# # Consolidated data for heat map (state)
# for cat in state_col_label:
# data[cat] = df1.set_index("RegionName")[cat].dropna().to_dict()
# # Consolidated data for heat map (county)
# for cat in county_col_label:
# data[cat] = df2.set_index("id")[cat].dropna().to_dict()
# # Historical home value data for plots (state, all)
# # Reformat df to dict
# # Format: {category --> {state/county -> {column -> value}}}
# hist = {}
# for i, cat in enumerate(state_col_label):
# hist[cat] = state_dfs[i].drop(columns=['RegionID', 'SizeRank']).set_index("RegionName").fillna(0).to_dict(orient='index')
# for i, cat in enumerate(county_col_label):
# hist[cat] = county_dfs[i].drop(columns=['RegionID', 'RegionName', 'State', 'Metro', 'StateCodeFIPS', 'MunicipalCodeFIPS', 'SizeRank']).set_index("id").fillna(0).to_dict(orient='index')
# # Cache files
# with open("./static/data.pkl", "wb") as handle:
# pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL)
# with open("./static/hist.pkl", "wb") as handle:
# pickle.dump(hist, handle, protocol=pickle.HIGHEST_PROTOCOL)
# income = {}
# # Get income data
# SQL = "SELECT FIPS, Area_name, Median_Household_income_2017 AS income, Unemployment_rate_2018 AS unemployment FROM HomeViz.income"
# df = pandas_gbq.read_gbq(SQL)
# df["FIPS"] = df["FIPS"].astype(str).apply(lambda x: x.zfill(5))
# income['income'] = df.set_index('FIPS')['income'].dropna().to_dict()
# income['unemployment'] = df.set_index('FIPS')['unemployment'].dropna().to_dict()
# with open("./static/income.pkl", "wb") as handle:
# pickle.dump(income, handle, protocol=pickle.HIGHEST_PROTOCOL)
# summary = {}
# # Get income data
# SQL = "SELECT * FROM HomeViz.home_value_byState_summaryAll"
# df = pandas_gbq.read_gbq(SQL)
# summary['state'] = df.set_index('RegionName').drop(columns=['Date', 'RegionID']).dropna().to_dict(orient='index')
# SQL = "SELECT index.id, summary.state, summary.SizeRank, summary.zhvi, summary.MoM, summary.QoQ, summary.YoY, summary._5Year, summary._10Year, summary.PeakMonth, summary.PeakQuarter, summary.PeakZHVI, summary.PctFallFromPeak, summary.LastTimeAtCurrZHVI FROM HomeViz.home_value_byCounty_summaryAll AS summary JOIN HomeViz.county_index as index ON summary.RegionID = index.RegionID and summary.state = index.state"
# df = pandas_gbq.read_gbq(SQL)
# df["id"] = df["id"].astype(str).apply(lambda x: x.zfill(5))
# summary['county'] = df.set_index('id').dropna().to_dict(orient='index')
# with open("./static/summary.pkl", "wb") as handle:
# pickle.dump(summary, handle, protocol=pickle.HIGHEST_PROTOCOL)
# Retrieve Cache files
with open(find("data.pkl"), "rb") as handle:
data = pickle.load(handle)
with open(find("hist.pkl"), "rb") as handle:
hist = pickle.load(handle)
with open(find("income.pkl"), "rb") as handle:
income = pickle.load(handle)
with open(find("summary.pkl"), "rb") as handle:
summary = pickle.load(handle)
return render(request, 'home.html', {
"data": data,
"hist": hist,
"income": income,
"summary": summary
})
def get_all_photos():
"""This function is not used; it can be used to view all photos available."""
with open(find("animal_photo_urls.txt")) as f:
urls = f.readlines()
return [url.strip() + "?w=400" for url in urls]
def find_file(self, url):
if self.use_finders and url.startswith(self.static_prefix):
path = finders.find(url[len(self.static_prefix):])
if path:
return self.get_static_file(path, url)
return super(DjangoWhiteNoise, self).find_file(url)
Enum,
get_random_string,
resize_image,
roman_numeral,
safe_file_name,
url_with_query_in_data
)
from lib.remote_page import RemotePage, RemotePageException
from lib.models import UrlMixin
from lib.validators import generate_url_key_validator
from userprofile.models import User, UserProfile, GraderUser
logger = logging.getLogger('aplus.course')
# Read pseudonymization data from file
with open(finders.find('pseudonym.json')) as json_file:
DATA = json.load(json_file)
class Course(UrlMixin, models.Model):
"""
Course model represents a course in a university. A course has a name and an
identification number. It also has a URL which is included in the addresses
of pages under the course.
"""
name = models.CharField(max_length=255)
code = models.CharField(max_length=255)
url = models.CharField(unique=True, max_length=255, blank=False,
validators=[generate_url_key_validator()],
help_text=_("Input an URL identifier for this course."))
teachers = models.ManyToManyField(UserProfile,
related_name="teaching_courses", blank=True)
def get_all_photos():
with open(find("candidate/animal_photo_urls.txt")) as f:
urls = f.readlines()
return [url.strip() + "?w=400" for url in urls]
def get_fallback_avatar(size):
"""Return fallback avatar."""
filename = finders.find(f"weblate-{size}.png")
with open(filename, "rb") as handle:
return handle.read()
def HeaderFooterPersona(canvas, doc):
canvas.saveState()
title = "Reporte de Personas"
canvas.setTitle(title)
Story = []
styles = getSampleStyleSheet()
archivo_imagen = finders.find('assets/img/logo.jpg')
canvas.drawImage(archivo_imagen,
30,
720,
width=540,
height=100,
preserveAspectRatio=True)
fecha = datetime.now().strftime('%d/%m/%Y ')
# Estilos de Párrafos
ta_c = ParagraphStyle(
'parrafos',
alignment=TA_CENTER,
fontSize=10,
fontName="Helvetica",
)
ta_l = ParagraphStyle(
'parrafos',
alignment=TA_LEFT,
fontSize=13,
fontName="Helvetica-Bold",
)
ta_l7 = ParagraphStyle(
'parrafos',
alignment=TA_LEFT,
fontSize=7,
fontName="Helvetica-Bold",
)
ta_r = ParagraphStyle(
'parrafos',
alignment=TA_RIGHT,
fontSize=13,
fontName="Helvetica-Bold",
)
# Header
header = Paragraph(
"REPORTE DE PERSONAS ",
ta_l,
)
w, h = header.wrap(doc.width + 250, doc.topMargin)
header.drawOn(canvas, 215, doc.height - 10 + doc.topMargin - 80)
#header1 = Paragraph("<u>DIRECCIÓN DE AGRICULTURA Y TIERRA</u> ",ta_r,)
#w,h = header1.wrap(doc.width-115, doc.topMargin)
#header1.drawOn(canvas, 140, doc.height -10 + doc.topMargin - 2)
P1 = Paragraph('''N°''', ta_c)
P2 = Paragraph('''CEDULA''', ta_c)
P3 = Paragraph('''NOMBRE''', ta_c)
P4 = Paragraph('''APELLIDO''', ta_c)
P5 = Paragraph('''CORREO''', ta_c)
P6 = Paragraph('''ROL''', ta_c)
data = [[P1, P2, P3, P4, P5, P6]]
header2 = Table(data, colWidths=[35, 85, 80, 80, 150, 80])
header2.setStyle(
TableStyle([
('GRID', (0, -1), (-1, -1), 1, colors.black),
('BACKGROUND', (0, 0), (-1, 0), '#50b7e6'),
('ALIGN', (0, 0), (-1, -3), "CENTER"),
]))
w, h = header2.wrap(doc.width - 115, doc.topMargin)
header2.drawOn(canvas, 42.5, doc.height - 40 + doc.topMargin - 93)
# FOOTER
footer4 = Paragraph("Fecha: " + str(fecha), ta_l7)
w, h = footer4.wrap(doc.width - 200, doc.bottomMargin)
footer4.drawOn(canvas, doc.height - 105, doc.topMargin + 620, h)
canvas.restoreState()
def HeaderFooterTrans(canvas, doc):
canvas.saveState()
title = "Reporte de Transacciones"
canvas.setTitle(title)
Story = []
styles = getSampleStyleSheet()
archivo_imagen = finders.find('assets/img/logo.jpg')
canvas.drawImage(archivo_imagen,
30,
720,
width=540,
height=100,
preserveAspectRatio=True)
fecha = datetime.now().strftime('%d/%m/%Y ')
# Estilos de Párrafos
ta_c = ParagraphStyle(
'parrafos',
alignment=TA_CENTER,
fontSize=10,
fontName="Helvetica",
)
ta_l = ParagraphStyle(
'parrafos',
alignment=TA_LEFT,
fontSize=13,
fontName="Helvetica-Bold",
)
ta_l7 = ParagraphStyle(
'parrafos',
alignment=TA_LEFT,
fontSize=7,
fontName="Helvetica-Bold",
)
ta_r = ParagraphStyle(
'parrafos',
alignment=TA_CENTER,
fontSize=11,
fontName="Helvetica-Bold",
)
# Header
header = Paragraph(
"REPORTE DE TRANSACCIONES ",
ta_l,
)
w, h = header.wrap(doc.width + 250, doc.topMargin)
header.drawOn(canvas, 215, doc.height - 10 + doc.topMargin - 80)
total1 = Paragraph(
"Total: " + str(total) + " bs.",
ta_l,
)
w, h = total1.wrap(doc.width + 250, doc.topMargin)
total1.drawOn(canvas, 425, doc.height - 10 + doc.topMargin - 60)
meses = Paragraph(
"Mes: " + str(mes1) + ".",
ta_l,
)
w, h = meses.wrap(doc.width + 250, doc.topMargin)
meses.drawOn(canvas, 75, doc.height - 10 + doc.topMargin - 60)
#header1 = Paragraph("<u>DIRECCIÓN DE AGRICULTURA Y TIERRA</u> ",ta_r,)
#w,h = header1.wrap(doc.width-115, doc.topMargin)
#header1.drawOn(canvas, 140, doc.height -10 + doc.topMargin - 2)
P1 = Paragraph('''N°''', ta_c)
P2 = Paragraph('''FECHA''', ta_c)
P3 = Paragraph('''TIPO''', ta_c)
P4 = Paragraph('''MONTO''', ta_c)
data = [[P1, P2, P3, P4]]
header2 = Table(data, colWidths=[35, 85, 80, 250])
header2.setStyle(
TableStyle([
('GRID', (0, -1), (-1, -1), 1, colors.black),
('BACKGROUND', (0, 0), (-1, 0), '#50b7e6'),
('ALIGN', (0, 0), (-1, -3), "CENTER"),
]))
w, h = header2.wrap(doc.width - 115, doc.topMargin)
header2.drawOn(canvas, 72.5, doc.height - 40 + doc.topMargin - 93)
# FOOTER
footer4 = Paragraph("Fecha: " + str(fecha), ta_l7)
w, h = footer4.wrap(doc.width - 200, doc.bottomMargin)
footer4.drawOn(canvas, doc.height - 105, doc.topMargin + 620, h)
canvas.restoreState()
def test_mode_extra_css():
w = CodeMirrorEditor(options={"mode": "tiki"})
js, css = w.media._js, w.media._css
assert "codemirror2/mode/tiki/tiki.css" in css["screen"]
for f in chain(js, css["screen"]):
assert find(f)
def test_searched_locations(self):
finders.find('spam')
self.assertEqual(finders.searched_locations,
[os.path.join(TEST_ROOT, 'project', 'documents')])
def _handle_github_contributions(org, repo, timedelta=3600, weeks_back=8):
"""
This function returns the url of an image of recent GitHub contributions
If the image is not present or outdated it will be reconstructed
"""
path = "GitHub_{0}_{1}_Contribution.png".format(org, repo)
full_path = os.path.join(djangoSettings.MEDIA_ROOT, path)
# We have to replot the image
# Set plot font
font = {"family": "normal"}
matplotlib.rc("font", **font)
# Query GitHub API for contributions
user_agent = {"user-agent": "oeplatform"}
http = urllib3.PoolManager(headers=user_agent)
try:
reply = http.request(
"GET",
"https://api.github.com/repos/{0}/{1}/stats/commit_activity".
format(org, repo),
).data.decode("utf8")
except:
pass
reply = json.loads(reply)
if not reply:
return None
# If there are more weeks than nessecary, truncate
if weeks_back < len(reply):
reply = reply[-weeks_back:]
# GitHub API returns a JSON dict with w: weeks, c: contributions
(times, commits) = zip(*[(
datetime.datetime.fromtimestamp(int(week["week"])).strftime("%m-%d"),
sum(map(int, week["days"])),
) for week in reply])
max_c = max(commits)
# generate a distribution wrt. to the commit numbers
commits_ids = [i for i in range(len(commits)) for _ in range(commits[i])]
# transform the contribution distribution into a density function
# using a gaussian kernel estimator
if commits_ids:
density = stats.kde.gaussian_kde(commits_ids, bw_method=0.2)
else:
# if there are no commits the density is a constant 0
density = lambda x: 0
# plot this distribution
x = numpy.arange(0.0, len(commits), 0.01)
c_real_max = max(density(xv) for xv in x)
fig1 = plt.figure(figsize=(4, 2)) # facecolor='white',
# replace labels by dates and numbers of commits
ax1 = plt.axes(frameon=False)
plt.fill_between(x, density(x), 0)
ax1.set_frame_on(False)
ax1.axes.get_xaxis().tick_bottom()
ax1.axes.get_yaxis().tick_left()
plt.yticks(numpy.arange(c_real_max - 0.001, c_real_max), [max_c],
size="small")
plt.xticks(numpy.arange(0.0, len(times)), times, size="small", rotation=45)
# save the figure
plt.savefig(full_path, transparent=True, bbox_inches="tight")
url = finders.find(path)
return url
},
)
USE_SPELLCHECKER = getattr(settings, "TINYMCE_SPELLCHECKER", False)
USE_COMPRESSOR = getattr(settings, "TINYMCE_COMPRESSOR", False)
INCLUDE_JQUERY = getattr(settings, "TINYMCE_INCLUDE_JQUERY", True)
USE_EXTRA_MEDIA = getattr(settings, "TINYMCE_EXTRA_MEDIA", None)
USE_FILEBROWSER = getattr(settings, "TINYMCE_FILEBROWSER", "filebrowser"
in settings.INSTALLED_APPS)
JS_URL = getattr(
#settings, "TINYMCE_JS_URL", os.path.join(settings.STATIC_URL, "tinymce/tinymce.min.js"),
settings,
"TINYMCE_JS_URL",
os.path.join(settings.STATIC_URL, "tinymce/static/tinymce/tinymce.min.js"),
)
try:
from django.contrib.staticfiles import finders
JS_ROOT = getattr(settings, "TINYMCE_JS_ROOT",
finders.find("tinymce", all=False))
except AppRegistryNotReady:
JS_ROOT = getattr(settings, "TINYMCE_JS_ROOT",
os.path.join(settings.STATIC_ROOT, "tinymce"))
JS_BASE_URL = JS_URL[:JS_URL.rfind("/")]
def replace_static_url(original, prefix, quote, rest):
"""
Replace a single matched url.
"""
original_uri = "".join([prefix, rest])
# Don't mess with things that end in '?raw'
if rest.endswith('?raw'):
static_paths_out.append((original_uri, original_uri))
return original
# In debug mode, if we can find the url as is,
if settings.DEBUG and finders.find(rest, True):
static_paths_out.append((original_uri, original_uri))
return original
# if we're running with a MongoBacked store course_namespace is not None, then use studio style urls
elif (not static_asset_path) and course_id:
# first look in the static file pipeline and see if we are trying to reference
# a piece of static content which is in the edx-platform repo (e.g. JS associated with an xmodule)
exists_in_staticfiles_storage = False
try:
exists_in_staticfiles_storage = staticfiles_storage.exists(
rest)
except Exception as err:
log.warning(
"staticfiles_storage couldn't find path {0}: {1}".format(
rest, str(err)))
if exists_in_staticfiles_storage:
url = staticfiles_storage.url(rest)
else:
# if not, then assume it's courseware specific content and then look in the
# Mongo-backed database
# Import is placed here to avoid model import at project startup.
from common.djangoapps.static_replace.models import AssetBaseUrlConfig, AssetExcludedExtensionsConfig
base_url = AssetBaseUrlConfig.get_base_url()
excluded_exts = AssetExcludedExtensionsConfig.get_excluded_extensions(
)
url = StaticContent.get_canonicalized_asset_path(
course_id, rest, base_url, excluded_exts)
if AssetLocator.CANONICAL_NAMESPACE in url:
url = url.replace('block@', 'block/', 1)
# Otherwise, look the file up in staticfiles_storage, and append the data directory if needed
else:
course_path = "/".join((static_asset_path or data_directory, rest))
try:
if staticfiles_storage.exists(rest):
url = staticfiles_storage.url(rest)
else:
url = staticfiles_storage.url(course_path)
# And if that fails, assume that it's course content, and add manually data directory
except Exception as err:
log.warning(
"staticfiles_storage couldn't find path {0}: {1}".format(
rest, str(err)))
url = "".join([prefix, course_path])
static_paths_out.append((original_uri, url))
return "".join([quote, url, quote])
def test_serving_static_files(self):
# If using static media properly result is not NONE once it finds rango.jpg
result = finders.find('images/rango.jpg')
self.assertIsNotNone(result)
def global_settings(request):
last_instance = get_last_visited_instance(request)
if hasattr(request, 'user') and request.user.is_authenticated():
last_effective_instance_user =\
request.user.get_effective_instance_user(last_instance)
_update_last_seen(last_effective_instance_user)
else:
if hasattr(request, 'instance'):
instance = request.instance
default_role = instance.default_role
last_effective_instance_user = InstanceUser(
role=default_role, instance=instance)
else:
last_effective_instance_user = None
if hasattr(request, 'instance') and request.instance.logo:
logo_url = request.instance.logo.url
else:
logo_url = settings.STATIC_URL + "img/logo.png"
try:
comment_file_path = finders.find('version.txt')
with open(comment_file_path, 'r') as f:
header_comment = f.read()
except:
header_comment = "Version information not available\n"
term = copy.copy(REPLACEABLE_TERMS)
if hasattr(request, 'instance'):
term.update(request.instance.config.get('terms', {}))
# config.get('terms') above populates the term context variable with
# model terminology provided it has been customized for the treemap
# instance, but fails to populate it with the default terminology. The
# for loop below ensures that term is populated with model terminology
# whether it has been customized or not.
# Convertible is the base class where the terminology class property is
# defined, so its leaf subclasses are the ones with default terminology
# we might care about.
# leaf_models_of_class uses recursive descent through the
# clz.__subclasses__ attributes, but it only iterates through a total
# of around ten nodes at present, so it is unlikely to be a performance
# problem.
for clz in leaf_models_of_class(Convertible):
term.update({
clz.__name__: clz.terminology(request.instance)})
ctx = {
'SITE_ROOT': settings.SITE_ROOT,
'settings': settings,
'last_instance': last_instance,
'last_effective_instance_user': last_effective_instance_user,
'logo_url': logo_url,
'header_comment': header_comment,
'term': term,
'embed': request_is_embedded(request),
'datepicker_start_date': datetime.min.replace(year=1900),
}
return ctx
def test_static_files(self):
# If using static media correctly the result is not NONE
result = finders.find('img/logo.jpg')
self.assertIsNotNone(result)
from django.conf import settings
from django.core.exceptions import AppRegistryNotReady
DEFAULT_CONFIG = getattr(
settings, "TINYMCE_DEFAULT_CONFIG", {"theme": "silver", "relative_urls": False}
)
USE_SPELLCHECKER = getattr(settings, "TINYMCE_SPELLCHECKER", False)
USE_COMPRESSOR = getattr(settings, "TINYMCE_COMPRESSOR", False)
INCLUDE_JQUERY = getattr(settings, "TINYMCE_INCLUDE_JQUERY", True)
USE_EXTRA_MEDIA = getattr(settings, "TINYMCE_EXTRA_MEDIA", None)
USE_FILEBROWSER = getattr(
settings, "TINYMCE_FILEBROWSER", "filebrowser" in settings.INSTALLED_APPS
)
JS_URL = getattr(
settings, "TINYMCE_JS_URL", os.path.join(settings.STATIC_URL, "tinymce/tinymce.min.js"),
)
try:
from django.contrib.staticfiles import finders
JS_ROOT = getattr(settings, "TINYMCE_JS_ROOT", finders.find("tinymce", all=False))
except AppRegistryNotReady:
JS_ROOT = getattr(settings, "TINYMCE_JS_ROOT", os.path.join(settings.STATIC_ROOT, "tinymce"))
JS_BASE_URL = JS_URL[: JS_URL.rfind("/")]
def get_rand_photo(width=400):
with open(find("animal_photo_urls.txt")) as f:
urls = f.readlines()
return urls[randint(0, len(urls) - 1)].strip() + "?w=" + str(width)
def animation_view(request):
if request.method == 'POST':
text = request.POST.get('sen')
#tokenizing the sentence
text.lower()
#tokenizing the sentence
words = word_tokenize(text)
tagged = nltk.pos_tag(words)
tense = {}
tense["future"] = len([word for word in tagged if word[1] == "MD"])
tense["present"] = len(
[word for word in tagged if word[1] in ["VBP", "VBZ", "VBG"]])
tense["past"] = len(
[word for word in tagged if word[1] in ["VBD", "VBN"]])
tense["present_continuous"] = len(
[word for word in tagged if word[1] in ["VBG"]])
#stopwords that will be removed
stop_words = set([
"mightn't", 're', 'wasn', 'wouldn', 'be', 'has', 'that', 'does',
'shouldn', 'do', "you've", 'off', 'for', "didn't", 'm', 'ain',
'haven', "weren't", 'are', "she's", "wasn't", 'its', "haven't",
"wouldn't", 'don', 'weren', 's', "you'd", "don't", 'doesn',
"hadn't", 'is', 'was', "that'll", "should've", 'a', 'then', 'the',
'mustn', 'i', 'nor', 'as', "it's", "needn't", 'd', 'am', 'have',
'hasn', 'o', "aren't", "you'll", "couldn't", "you're", "mustn't",
'didn', "doesn't", 'll', 'an', 'hadn', 'whom', 'y', "hasn't",
'itself', 'couldn', 'needn', "shan't", 'isn', 'been', 'such',
'shan', "shouldn't", 'aren', 'being', 'were', 'did', 'ma', 't',
'having', 'mightn', 've', "isn't", "won't"
])
#removing stopwords and applying lemmatizing nlp process to words
lr = WordNetLemmatizer()
filtered_text = []
for w, p in zip(words, tagged):
if w not in stop_words:
if p[1] == 'VBG' or p[1] == 'VBD' or p[1] == 'VBZ' or p[
1] == 'VBN' or p[1] == 'NN':
filtered_text.append(lr.lemmatize(w, pos='v'))
elif p[1] == 'JJ' or p[1] == 'JJR' or p[1] == 'JJS' or p[
1] == 'RBR' or p[1] == 'RBS':
filtered_text.append(lr.lemmatize(w, pos='a'))
else:
filtered_text.append(lr.lemmatize(w))
#adding the specific word to specify tense
words = filtered_text
temp = []
for w in words:
if w == 'I':
temp.append('Me')
else:
temp.append(w)
words = temp
probable_tense = max(tense, key=tense.get)
if probable_tense == "past" and tense["past"] >= 1:
temp = ["Before"]
temp = temp + words
words = temp
elif probable_tense == "future" and tense["future"] >= 1:
if "Will" not in words:
temp = ["Will"]
temp = temp + words
words = temp
else:
pass
elif probable_tense == "present":
if tense["present_continuous"] >= 1:
temp = ["Now"]
temp = temp + words
words = temp
filtered_text = []
for w in words:
path = w + ".mp4"
f = finders.find(path)
#splitting the word if its animation is not present in database
if not f:
for c in w:
filtered_text.append(c)
#otherwise animation of word
else:
filtered_text.append(w)
words = filtered_text
return render(request, 'animation.html', {
'words': words,
'text': text
})
else:
return render(request, 'animation.html')
def _get_default_background(self):
return open(finders.find('pretixpresale/pdf/ticket_default_a4.pdf'), "rb")
# Copyright (C) 2017-2019 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
import functools
import json
from typing import Dict
from pygments.lexers import get_all_lexers, get_lexer_for_filename
import sentry_sdk
from django.contrib.staticfiles.finders import find
with open(str(find("json/highlightjs-languages.json")),
"r") as _hljs_languages_file:
_hljs_languages_data = json.load(_hljs_languages_file)
# set of languages ids that can be highlighted by highlight.js library
_hljs_languages = set(_hljs_languages_data["languages"])
# languages aliases defined in highlight.js
_hljs_languages_aliases = {
**_hljs_languages_data["languages_aliases"],
"ml": "ocaml",
"bsl": "1c",
"ep": "mojolicious",
"lc": "livecode",
"p": "parser3",
"pde": "processing",
"rsc": "routeros",
def serve(request,
path,
document_root=None,
show_indexes=False,
insecure=False):
"""
Serve static files below a given point in the directory structure or
from locations inferred from the static files finders.
To use, put a URL pattern such as::
(r'^(?P<path>.*)$', 'django.contrib.staticfiles.views.serve')
in your URLconf.
If you provide the ``document_root`` parameter, the file won't be looked
up with the staticfiles finders, but in the given filesystem path, e.g.::
(r'^(?P<path>.*)$', 'django.contrib.staticfiles.views.serve', {'document_root' : '/path/to/my/files/'})
You may also set ``show_indexes`` to ``True`` if you'd like to serve a
basic index of the directory. This index view will use the
template hardcoded below, but if you'd like to override it, you can create
a template called ``static/directory_index.html``.
"""
if not settings.DEBUG and not insecure:
raise ImproperlyConfigured("The view to serve static files can only "
"be used if the DEBUG setting is True or "
"the --insecure option of 'runserver' is "
"used")
if not document_root:
absolute_path = finders.find(path)
if not absolute_path:
raise Http404('"%s" could not be found' % path)
document_root, path = os.path.split(absolute_path)
# Clean up given path to only allow serving files below document_root.
path = posixpath.normpath(urllib.unquote(path))
path = path.lstrip('/')
newpath = ''
for part in path.split('/'):
if not part:
# Strip empty path components.
continue
drive, part = os.path.splitdrive(part)
head, part = os.path.split(part)
if part in (os.curdir, os.pardir):
# Strip '.' and '..' in path.
continue
newpath = os.path.join(newpath, part).replace('\\', '/')
if newpath and path != newpath:
return HttpResponseRedirect(newpath)
fullpath = os.path.join(document_root, newpath)
if os.path.isdir(fullpath):
if show_indexes:
return directory_index(newpath, fullpath)
raise Http404("Directory indexes are not allowed here.")
if not os.path.exists(fullpath):
raise Http404('"%s" does not exist' % fullpath)
# Respect the If-Modified-Since header.
statobj = os.stat(fullpath)
mimetype, encoding = mimetypes.guess_type(fullpath)
mimetype = mimetype or 'application/octet-stream'
if not was_modified_since(request.META.get('HTTP_IF_MODIFIED_SINCE'),
statobj[stat.ST_MTIME], statobj[stat.ST_SIZE]):
return HttpResponseNotModified(mimetype=mimetype)
contents = open(fullpath, 'rb').read()
response = HttpResponse(contents, mimetype=mimetype)
response["Last-Modified"] = http_date(statobj[stat.ST_MTIME])
response["Content-Length"] = len(contents)
if encoding:
response["Content-Encoding"] = encoding
return response
def get_fallback_avatar(size):
"""Return fallback avatar."""
filename = finders.find('weblate-{0}.png'.format(size))
with open(filename, 'rb') as handle:
return handle.read()
def test_static_finder(self):
'''Gets correctly the static files'''
result = finders.find('images/favicon.ico')
self.assertIsNotNone(result)
def find(path, *args, **kwargs):
if DJANGO_CONFIGURED:
return finders.find(path, *args, **kwargs)
if path and os.path.isabs(path) and os.path.exists(path):
return path
def real_path(self):
return finders.find(self.path)
def get(self, path, include_body=True):
from django.contrib.staticfiles import finders
normalized_path = posixpath.normpath(unquote(path)).lstrip('/')
absolute_path = finders.find(normalized_path)
return super(DjangoStaticFileHandler,
self).get(absolute_path, include_body)
def find_placeholder(self):
placeholder = 'documents/{0}-placeholder.png'
return finders.find(placeholder.format(self.extension), False) or \
finders.find(placeholder.format('generic'), False)