def blurthday():
from imread import imread
from pprint import pprint
imfuckingshowalready = lambda mx: Image.fromarray(mx).show()
identity = LUT()
amatorka = LUT('amatorka')
#miss_etikate = LUT('miss_etikate')
#soft_elegance_1 = LUT('soft_elegance_1')
#soft_elegance_2 = LUT('soft_elegance_2')
im1 = imread(
AppDirectoriesFinder().storages.get(
'django_instakit').path(join(
'django_instakit', 'img', '06-DSCN4771.JPG')))
im2 = imread(
AppDirectoriesFinder().storages.get(
'django_instakit').path(join(
'django_instakit', 'img',
'430023_3625646599363_1219964362_3676052_834528487_n.jpg')))
pprint(identity)
pprint(amatorka)
im9 = amatorka.transform(im1)
pprint(im9)
imfuckingshowalready(im9)
print im1
print im2
def _load_map(map_name):
finder = AppDirectoriesFinder(app_names=['insoft'])
map_file = finder.find('insoft/maps/%s.json' % map_name)
with open(map_file) as f:
data = json.loads(f.read())
paths = sorted(data['pathes'].iteritems(), key=lambda l: l[1]['name'])
locations = tuple([Location(key, val['name']) for key, val in paths])
setattr(_cache, map_name, locations)
def handle(self, *args, **options):
self.with_version = options.get("with_version")
self.keep_packages = options.get("keep_packages")
temp_dir = getattr(settings, 'BWR_APP_TMP_FOLDER', 'tmp')
temp_dir = os.path.abspath(temp_dir)
# finders
basefinder = BaseDirectoryFinder()
appfinder = AppDirectoriesFinder()
# Assume bower.json files are to be found in each app directory,
# rather than in the app's static/ subdirectory:
appfinder.source_dir = '.'
finders = (
basefinder,
appfinder,
)
if os.path.exists(temp_dir):
if not self.keep_packages:
sys.stderr.write(
"\nWARNING:\n\n"
" The temporary package installation directory exists, but the --keep-packages\n"
" option has not been given. In order to not delete anything which should be\n"
" kept, %s will not be removed.\n\n"
" Please remove it manually, or use the --keep-packages option to avoid this\n"
" message.\n\n" % (temp_dir, ))
self.keep_packages = True
else:
os.makedirs(temp_dir)
for finder in finders:
for path in finder.find('package.json', all=True):
self.npm_install(path)
for finder in finders:
for path in finder.find('Gruntfile.json', all=True):
self.grunt_default(path)
for finder in finders:
for path in finder.find('bower.json', all=True):
self.get_bower_info(path)
self.bower_install(path, temp_dir)
bower_dir = os.path.join(temp_dir, 'bower_components')
# nothing to clean
if not os.path.exists(bower_dir):
print('No components seems to have been found by bower, exiting.')
sys.exit(0)
self.clean_components_to_static_dir(bower_dir, path)
if not self.keep_packages:
shutil.rmtree(temp_dir)
def get_value(self, context, **kwargs):
appdirs = AppDirectoriesFinder()
targets = []
for app_name in appdirs.apps:
app = app_name
if '.' in app_name:
oldpath, app = app_name.rsplit('.', 1)
target = '%s/css/thadminjones.css' % app
if appdirs.find_in_app(app_name, target):
targets.append(target)
return targets
def get_value(self, context, **kwargs):
appdirs = AppDirectoriesFinder()
targets = []
for app_name in appdirs.apps:
app = app_name
if '.' in app_name:
oldpath, app = app_name.rsplit('.', 1)
target = '%s/css/thadminjones.css' % app
if appdirs.find_in_app(app_name, target):
targets.append(target)
return targets
def handle(self, *args, **options):
self.with_version = options.get("with_version")
self.keep_packages = options.get("keep_packages")
temp_dir = getattr(settings, 'BWR_APP_TMP_FOLDER', 'tmp')
temp_dir = os.path.abspath(temp_dir)
# finders
basefinder = BaseDirectoryFinder()
appfinder = AppDirectoriesFinder()
# Assume bower.json files are to be found in each app directory,
# rather than in the app's static/ subdirectory:
appfinder.source_dir = '.'
finders = (basefinder, appfinder, )
if os.path.exists(temp_dir):
if not self.keep_packages:
sys.stderr.write(
"\nWARNING:\n\n"
" The temporary package installation directory exists, but the --keep-packages\n"
" option has not been given. In order to not delete anything which should be\n"
" kept, %s will not be removed.\n\n"
" Please remove it manually, or use the --keep-packages option to avoid this\n"
" message.\n\n" % (temp_dir,))
self.keep_packages = True
else:
os.makedirs(temp_dir)
for finder in finders:
for path in finder.find('package.json', all=True):
self.npm_install(path)
for finder in finders:
for path in finder.find('Gruntfile.json', all=True):
self.grunt_default(path)
for finder in finders:
for path in finder.find('bower.json', all=True):
self.get_bower_info(path)
self.bower_install(path, temp_dir)
bower_dir = os.path.join(temp_dir, 'bower_components')
# nothing to clean
if not os.path.exists(bower_dir):
print('No components seems to have been found by bower, exiting.')
sys.exit(0)
self.clean_components_to_static_dir(bower_dir, path)
if not self.keep_packages:
shutil.rmtree(temp_dir)
def _can_symlink_static_files():
from django.conf import settings
finder = AppDirectoriesFinder()
for path, storage in finder.list([]):
# Get the first static file and use that as our source
source_path = storage.path(path)
break
# Check that we can make a symlink between this file, and the static root
# directory we are using.
return symlink_capability_check(source_path, settings.STATIC_ROOT)
def list(self, ignore_patterns):
"""
List all files in all app storages.
"""
for path, storage in AppDirectoriesFinder.list(self, ignore_patterns):
if self.is_dependency(path, storage):
yield path, storage
def _read_png_matrix(cls, name):
print "Reading LUT image: %s" % name
return imread.imread(
AppDirectoriesFinder().storages.get(
'django_instakit').path(join(
'django_instakit', 'lut',
"%s.png" % name)))
def walk_finders(path):
"""Find all qunit related files given the path component that comes
after '/qunit/'
Works similarly to 'os.walk' but returns just files and directories
by surfing over all possible files.
"""
# Get a file system path from url path
path_comps = [c for c in path.split('/') if c != u'']
tmp = os.sep.join(path_comps)
file_path = os.path.join(settings.QUNIT_TEST_PATH, tmp)
finder_files = []
# Get list of files from app directories from app file finder
adf = AppDirectoriesFinder()
for fpath, filestorageobj in adf.list(''):
if settings.QUNIT_TEST_PATH in fpath:
finder_files.append((fpath, filestorageobj))
# Get list of files from app directories from file system file finder
# By adding this second, files in the project base override app specific files
fsf = FileSystemFinder()
for fpath, filestorageobj in fsf.list(''):
if settings.QUNIT_TEST_PATH in fpath:
finder_files.append((fpath, filestorageobj))
# Form arrays of files in this directory and sub directories
matchfiles = []
subdirectories = []
for ffile_path, fso in finder_files:
split = ffile_path.split(file_path)
if len(split) > 1:
# Check to see if sub-directories exist
path_split = split[1].split(os.sep)
if len(path_split) > 1 and path_split[0] != u'':
# this file indicates a sub directory
subdirectories.append(path_split[0])
else:
# this is a file in this directory
matchfiles.append((ffile_path, fso))
# Get rid of duplicates
subdirectories = list(set(subdirectories)) # array of strings
matchfiles = list(set(matchfiles)) # array of tuples
return (subdirectories, matchfiles)
def tango_admin_css():
"""
Inserts tango_admin css links.
"""
appdirs = AppDirectoriesFinder()
targets = []
csslink = '<link rel="stylesheet" type="text/css" href="%s">'
for app_name in appdirs.apps:
app = app_name
if '.' in app_name:
oldpath, app = app_name.rsplit('.', 1)
target = '%s/css/tango_admin.css' % app
if appdirs.find_in_app(app_name, target):
targets.append(target)
return "\n".join(csslink % staticfiles_storage.url(x) for x in targets)
def handle(self, **options):
default_static_dir = os.path.join(settings.WORKING_DIR, 'static')
custom_static_dirs = filter(lambda x: x != default_static_dir,
settings.STATICFILES_DIRS)
finder = AppDirectoriesFinder()
for app_name in finder.storages:
location = finder.storages[app_name].location
add_new_custom_dir = (location != default_static_dir
and location not in custom_static_dirs)
if add_new_custom_dir:
custom_static_dirs.append(location)
default_js_dir = os.path.join(default_static_dir, 'js')
webpack_config_file = os.path.join(default_js_dir, 'webpack.config.js')
webpack_bin = os.path.join(default_js_dir, 'node_modules/.bin/webpack')
if os.name == 'nt':
webpack_bin = '%s.cmd' % webpack_bin
webpack_progress = ('--progress'
if options['progress'] or options['dev'] else '')
webpack_colors = '--colors' if not options['no_color'] else ''
webpack_args = [webpack_bin, '--config=%s' % webpack_config_file]
if webpack_progress:
webpack_args.append(webpack_progress)
if webpack_colors:
webpack_args.append(webpack_colors)
if options['dev']:
watch = '--watch' if options['watch'] else ''
webpack_args.extend([watch, '--display-error-details'])
else:
os.environ['NODE_ENV'] = 'production'
webpack_args.append("--bail")
webpack_args.extend(options['extra'])
static_base = link(settings.STATIC_URL)
suffix = 'js/' if static_base.endswith('/') else '/js/'
os.environ['WEBPACK_PUBLIC_PATH'] = static_base + suffix
if custom_static_dirs:
# XXX: review this for css
# Append `js/` so that it's not necessary to reference it from the
# `webpack.config.js` file
custom_static_dirs = map(lambda x: os.path.join(x, 'js/'),
custom_static_dirs)
os.environ['WEBPACK_ROOT'] = ':'.join(custom_static_dirs)
try:
subprocess.call(webpack_args)
except OSError:
raise CommandError('webpack executable not found.\n'
'Make sure to install it by running '
'`cd %s && npm install`' % default_js_dir)
def handle(self, *args, **options):
a = AppDirectoriesFinder()
f = FileSystemFinder()
print(f'Found installed apps : {a.apps}')
print('Static localisations :')
for key, dirs in a.storages.items():
print(f'{key} ==> {dirs._location}')
for key, dirs in f.storages.items():
print(f'{key} ==> {dirs._location}')
def _check_template_exists(self, path):
template = FileSystemFinder().find(path)
if not template:
template = AppDirectoriesFinder().find(path)
if not template:
raise InvalidTemplateError("%s is not a known template" % path)
return template
def read_acv(self, name):
print "Reading curves from %s.acv" % name
acv_path = AppDirectoriesFinder().storages.get('django_instakit').path(
join('django_instakit', 'acv', "%s.acv" % name))
with open(acv_path, "rb") as acv_file:
_, self.count = unpack("!hh", acv_file.read(4))
for i in xrange(self.count):
self.curves.append(
self.read_one_curve(acv_file, self.channel_name(i)))
def test_staticfiles(self):
"""
Test whether django-staticfiles is properly configured.
There are various reasons why this could fail:
* App not loaded (not in get_apps())
* models.py missing
* Addon not appended to STATICFILES_PREPEND_LABEL_APPS
* STATIC_ROOT is not absolute path
* STATICFILES_MEDIA_DIRNAMES doesn't include 'media'
"""
suffix = 'css/icons.css'
for addons_root in settings.ADDONS_ROOTS:
ref = os.path.realpath('%s/locks/static/locks/%s' % (addons_root, suffix))
if os.path.exists(ref):
break
path = 'locks/%s' % suffix
r = AppDirectoriesFinder()
self.assertEqual(ref, r.find(path))
def coffeescript(path):
try:
STATIC_ROOT = settings.STATIC_ROOT
except AttributeError:
STATIC_ROOT = settings.MEDIA_ROOT
filename = os.path.split(path)[-1]
try:
from django.contrib.staticfiles.finders import \
FileSystemFinder, AppDirectoriesFinder
full_path = AppDirectoriesFinder().find(path)
if not full_path:
full_path = FileSystemFinder().find(path)
except ImportError:
# normal, non-statcfiles-enabled way:
full_path = os.path.join(STATIC_ROOT, path)
output_directory = os.path.join(STATIC_ROOT, COFFEESCRIPT_OUTPUT_DIR, os.path.dirname(path))
hashed_mtime = get_hashed_mtime(full_path)
if filename.endswith(".coffee"):
base_filename = filename[:-7]
else:
base_filename = filename
output_path = os.path.join(output_directory, "%s-%s.js" % (base_filename, hashed_mtime))
if not os.path.exists(output_path):
source_file = open(full_path)
source = source_file.read()
source_file.close()
args = shlex.split("%s -c -s -p" % COFFEESCRIPT_EXECUTABLE, posix=POSIX_COMPATIBLE)
p = subprocess.Popen(args, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, errors = p.communicate(source)
if out:
if not os.path.exists(output_directory):
os.makedirs(output_directory)
compiled_file = open(output_path, "w+")
compiled_file.write(out)
compiled_file.close()
# Remove old files
compiled_filename = os.path.split(output_path)[-1]
for filename in os.listdir(output_directory):
if filename.startswith(base_filename) and filename != compiled_filename:
os.remove(os.path.join(output_directory, filename))
elif errors:
logger.error(errors)
return path
return output_path[len(STATIC_ROOT):].replace(os.sep, '/').lstrip("/")
def test_staticfiles(self):
"""
Test whether django-staticfiles is properly configured.
There are various reasons why this could fail:
* App not loaded (not in get_apps())
* models.py missing
* Addon not appended to STATICFILES_PREPEND_LABEL_APPS
* STATIC_ROOT is not absolute path
* STATICFILES_MEDIA_DIRNAMES doesn't include 'media'
"""
suffix = 'css/icons.css'
for addons_root in settings.ADDONS_ROOTS:
ref = os.path.realpath('%s/locks/static/locks/%s' %
(addons_root, suffix))
if os.path.exists(ref):
break
path = 'locks/%s' % suffix
r = AppDirectoriesFinder()
self.assertEqual(ref, r.find(path))
def old_main():
#imfuckingshowalready = lambda mx: Image.fromarray(mx).show()
old_identity = AppDirectoriesFinder().storages.get(
'django_instakit').path(join(
'django_instakit', 'lut', 'identity.png'))
im_old_identity = imread.imread(old_identity)
im_identity = numpy.zeros_like(im_old_identity)
for bx in xrange(0, 8):
for by in xrange(0, 8):
for r in xrange(0, 64):
for g in xrange(0, 64):
im_identity[
int(g + by * 64),
int(r + bx * 64)] = numpy.array((
int(r * 255.0 / 63.0 + 0.5),
int(g * 255.0 / 63.0 + 0.5),
int((bx + by * 8.0) * 255.0 / 63.0 + 0.5)),
dtype=numpy.uint8)
print "THE OLD: %s, %s, %s" % (
im_old_identity.size, im_old_identity.shape,
str(im_old_identity.dtype))
#print im_old_identity
print ""
print "THE NEW: %s, %s, %s" % (
im_identity.size, im_identity.shape,
str(im_identity.dtype))
#print im_identity
print ""
print "THE END: %s" % bool(im_old_identity.shape == im_identity.shape)
#print im_old_identity == im_identity
#imfuckingshowalready(im_identity)
#imfuckingshowalready(im_old_identity)
pil_im_old_identity = Image.fromarray(im_old_identity)
pil_im_old_identity.save('/tmp/im_old_identity.jpg',
format="JPEG")
pil_im_identity = Image.fromarray(im_identity)
pil_im_identity.save('/tmp/im_identity.jpg',
format="JPEG")
def start_server_servestatic(self, options):
"""
Start CherryPy server AND serve default static files
Want SSL support?
a. The new (3.1 or 3.2) way: Just set server.ssl_adapter to an SSLAdapter instance.
b. The old way (deprecated way) is to set these attributes:
server.ssl_certificate = <filename>
server.ssl_private_key = <filename>
But this is the only way from the management command line
in the future I may need to adapt this to use a server.ssl_adapter
"""
# debug?
# print "options:"
from django.conf import settings
quit_command = (sys.platform
== 'win32') and 'CTRL-BREAK' or 'CONTROL-C'
self.stdout.write("Validating models..")
self.validate(display_num_errors=True)
self.stdout.write(
("%(started_at)s\n"
"Django version %(version)s, using settings %(settings)r\n"
"cherrypy django_wsgiserver is running at http://%(addr)s:%(port)s/\n"
"Quit the server with %(quit_command)s.\n") %
{
"started_at": datetime.now().strftime('%B %d, %Y - %X'),
"version": self.get_version(),
"settings": settings.SETTINGS_MODULE,
"addr": options[
'host'], # self._raw_ipv6 and '[%s]' % self.addr or self.addr,
"port": options['port'],
"quit_command": quit_command,
})
#logger.info("launching wsgiserver with the following options")
#logger.info(pformat(options))
if int(options['verbose']) >= 2:
self.stdout.write("launching with the following options:\n")
self.stdout.write(pformat(options))
if options['daemonize'] and options['server_user'] and options[
'server_group']:
#ensure the that the daemon runs as specified user
change_uid_gid(options['server_user'], options['server_group'])
from django_wsgiserver.wsgiserver import CherryPyWSGIServer, WSGIPathInfoDispatcher
#from cherrypy.wsgiserver import CherryPyWSGIServer, WSGIPathInfoDispatcher
from django.core.handlers.wsgi import WSGIHandler
from django.conf import settings
app = WSGIHandler() # serve the django content
path = {
'/': app
} # well will build up the serving url routing path below
# Now work on serving the static content
# note as of django 1.4, ADMIN_MEDIA_PREFIX is depreciated and instead uses django.contrib.staticfiles
# so it is not an error for ADMIN_MEDIA_PREFIX to not be defined, I will test to see if exists
# and print a warning that adminserve is activated but it's not defined.
# so for django 1.4 (or 1.5 ?) staticserve=True => adminserve=True
# so the choices
# There are basically two ways for statics to be served
# 1. in development, one often wants each application's static files to be served from within its file structure
# this is what the django runserver dose
# 2. in production usually, all the static files are collected into a common storage region (files, S3, CDN) and a good webserver
# serve them from there
# deprecated
# if options['adminserve']: # serve the admin media too
# # AdminMediaHandler is middleware for local use
# #import django.core.servers.basehttp
# #adminapp = django.core.servers.basehttp.AdminMediaHandler(app)
# # another way to serve the admin media three application
# if settings.__dict__.has_key('ADMIN_MEDIA_PREFIX'):
# import django.contrib.admin
# path[settings.ADMIN_MEDIA_PREFIX] = django_wsgiserver.mediahandler.StaticFileWSGIApplication(
# os.path.join( django.contrib.admin.__path__[0], 'media'))
# else:
# print "Warning adminserve was selected BUT ADMIN_MEDIA_PREFIX was not defined"
if options['staticserve']:
try:
if not settings.STATIC_URL or not settings.STATIC_ROOT:
# could use misconfigured exception (what is this in django) instead of AttributeError
raise AttributeError, "settings.STATIC_URL = %s, settings.STATIC_ROOT=%s" % (
repr(settings.STATIC_URL), repr(settings.STATIC_ROOT))
except AttributeError, msg:
logger.error(msg)
logger.error("****")
logger.error(
"STATIC_URL and STATIC_ROOT must be set in settings file for staticserve option to work in django_wsgiserver"
)
logger.error("****")
raise
if options['staticserve'] != 'collectstatic':
if settings.STATICFILES_FINDERS: # find the apps' static files and add them to the path
logger.debug("see settings.STATICFILES_FINDERS")
logger.debug(pformat(settings.STATICFILES_FINDERS))
from django.contrib.staticfiles.finders import AppDirectoriesFinder
app_static_finder = AppDirectoriesFinder(
settings.INSTALLED_APPS)
logger.debug("app_static_finder.storages:")
logger.debug(pformat(app_static_finder.storages))
for key, val in app_static_finder.storages.items():
logger.debug(key, " static location:", val.location)
# need to decide what to do with this in terms of the fusion of the app static directories
app_url = key.split('.')[
-1] + r'/' # I'm not sure if it needs the end '/'
full_static_url = os.path.join(settings.STATIC_URL,
app_url)
full_dir_location = os.path.join(val.location, app_url)
logger.debug(full_static_url, full_dir_location)
path[
full_static_url] = django_wsgiserver.wsgiutil.StaticFileWSGIApplication(
full_dir_location)
if options['servestaticdirs'] and hasattr(settings,
'STATICFILES_DIRS'):
staticlocations = process_staticfiles_dirs(
settings.STATICFILES_DIRS)
# debug !!!
logger.debug("staticlocations::")
logger.debug(pformat(staticlocations))
for urlprefix, root in staticlocations:
path[os.path.join(
settings.STATIC_URL, urlprefix
)] = django_wsgiserver.wsgiutil.StaticFileWSGIApplication(
root)
# One important thing is that there are two different ways to serve the static files
# 1. convenient: serve each app's static files (assuming they follow convention)
# 2. do a collectstatic and serve from that node -- likely this would be done more in a "production" scenario
if options['staticserve'] == 'collectstatic':
# and serve the root of the STATIC_URL ? hmm !!!
path[
settings.
STATIC_URL] = django_wsgiserver.wsgiutil.StaticFileWSGIApplication(
settings.STATIC_ROOT)
logger.warning(
"serving all static files from %s. *** Make sure you have done a fresh collectstatic operation ***"
% settings.STATIC_ROOT)
from django.template.context import RequestContext
from django.utils.translation import ugettext as _
from django.conf import settings
import os, shutil
from django.core.files import File
from django.core.management import call_command
from django_ace import AceWidget
from django.contrib.staticfiles.finders import AppDirectoriesFinder
try:
from django.conf.urls import patterns, url
except ImportError: # Django < 1.4
from django.conf.urls.defaults import patterns, url
finder = AppDirectoriesFinder()
LESS_FILES = {
'custom_less': finder.find('src/less/custom.less'),
}
if (not settings.DEBUG):
for less_file in LESS_FILES:
less_file_name = LESS_FILES.get(less_file)
old_less_file_name = less_file_name + '.bak'
if not os.access(old_less_file_name, os.R_OK):
shutil.copy(less_file_name, old_less_file_name)
class StylesLessForm(forms.Form):
custom_less = forms.CharField(
img.convert('RGB')
if img.mode is '1':
img.convert('L')
if img.mode is 'L':
return Image.eval(img, self.curves[0])
# has to be RGB at this point
img_channels = img.split()
img_adjusted_channels = []
for i in xrange(len(img_channels)):
img_adjusted_channels.append(
Image.eval(img_channels[i], lambda v: self.curves[i + 1](v)))
return Image.merge('RGB', img_adjusted_channels)
if __name__ == '__main__':
curve_files = AppDirectoriesFinder().storages.get(
'django_instakit').listdir(join('django_instakit', 'acv'))[-1]
curve_names = [curve_file.rstrip('.acv') for curve_file in curve_files]
curve_sets = [
CurveSet(name) for name in curve_names
if not name.lower() == '.ds_store'
]
image_files = AppDirectoriesFinder().storages.get(
'django_instakit').listdir(join('django_instakit', 'img'))[-1]
image_paths = map(
lambda image_file: AppDirectoriesFinder().
storages.get('django_instakit').path(
join('django_instakit', 'img', image_file)), image_files)
image_inputs = map(
lambda image_path: Image.open(image_path).convert('RGB'), image_paths)
