@@ -68,21 +66,22 @@ ImageMetaTag.ImageDict¶
-This submodule contains the ImageMetaTag.ImageDict class, and functions for preparing them.
The purpose of an ImageMetaTag.ImageDict is to sort the image metadata, supplied to
-ImageMetaTag.savefig() and usually stored in a database file, into a useful form that
-can quickly and easily be presented as a webpage by ImageMetaTag.webpage.write_full_page().
This submodule contains the ImageMetaTag.ImageDict class, and functions for +preparing instances of it.
+The purpose of an ImageMetaTag.ImageDict is to sort the image metadata, supplied to +ImageMetaTag.savefig() and usually stored in a database file, into a useful form that +can quickly and easily be presented as a webpage by ImageMetaTag.webpage.write_full_page().
An easy example of creating a webpage, using an ImageDict is shown in simplest_image_dict.py
The ImageDict Class¶
-
-class
ImageMetaTag.ImageDict(input_dict, level_names=None, selector_widths=None, selector_animated=None, animation_direction=None)[source]¶
+class ImageMetaTag.ImageDict(input_dict, level_names=None, selector_widths=None, selector_animated=None, animation_direction=None)¶
A class which holds a heirachical dictionary of dictionaries, and the associated methods for appending/removing dictionaries from it.
The expected use case for the dictionary is to represent a large set of images, @@ -114,7 +114,7 @@
The ImageDict Class
ImageMetaTag.dict_heirachy_from_list()+of metadata items, use ImageMetaTag.dict_heirachy_from_list()- Options:
-
@@ -137,33 +137,33 @@
-
-
append(new_dict, devmode=False, skip_key_relist=False)[source]¶
+append(new_dict, devmode=False, skip_key_relist=False)¶
appends a new dictionary (with a single element in each layer!) into a current ImageDict.
The skip_key_relist option can be set to True to stop the regeneration of key lists.
The ImageDict Class
-
-
-
-
copy_except_dict_and_keys()[source]¶
+copy_except_dict_and_keys()¶
returns a copy of an ImageDict except it will have null values for the dict and keys
-
-
dict_depth(uniform_depth=False)[source]¶
+dict_depth(uniform_depth=False)¶
Uses dict_depths to get the depth of all branches of the plot_dict and, if required, checks they all equal the max
-
-
dict_depths(in_dict, depth=0)[source]¶
+dict_depths(in_dict, depth=0)¶
Recursively finds the depth of a ImageDict and returns a list of lists
-
-
dict_index_array(devmode=False, maxdepth=None, verbose=False)[source]¶
+dict_index_array(devmode=False, maxdepth=None, verbose=False)¶
Using the list of dictionary keys (at each level of a uniform_depth dictionary of dictionaries), this produces a list of the indices that can be used to reference the keys to get the result for each element.
@@ -178,13 +178,13 @@The ImageDict Class
- -
+dict_print(in_dict, indent=0, outstr='')¶dict_print(in_dict, indent=0, outstr='')[source]¶recursively details a dictionary of dictionaries, with indentation, to a string
- -
-
-
dict_prune(in_dict, dicts_pruned=False)[source]¶
+dict_prune(in_dict, dicts_pruned=False)¶
Prunes the ImageDict of empty, unterminated, branches (which occur after parts have been removed). Returns True if a dict was pruned, False if not.
@@ -192,7 +192,7 @@The ImageDict Class
- -
+dict_remove(in_dict, rm_dict)¶dict_remove(in_dict, rm_dict)[source]¶removes a dictionary of dictionaries from another, larger, one. This can leave empty branches, at multiple levels of the dict, so needs cleaning up afterwards.
@@ -200,25 +200,25 @@The ImageDict Class
- -
+dict_union(in_dict, new_dict)¶dict_union(in_dict, new_dict)[source]¶produces the union of a dictionary of dictionaries
- -
-
-
key_at_depth(in_dict, depth)[source]¶
+key_at_depth(in_dict, depth)¶
returns the keys of a dictionary, at a given depth
-
-
keys_by_depth(in_dict, depth=0, keys=None, subdirs=None)[source]¶
+keys_by_depth(in_dict, depth=0, keys=None, subdirs=None)¶
Returns:
- a dictionary of sets, containing the keys at each level of the dictionary (keyed by the level number). @@ -228,7 +228,7 @@
-
-
list_keys_by_depth(devmode=False)[source]¶
+list_keys_by_depth(devmode=False)¶
Lists the keys of the dictionary to create a list of keys, for each level of the dictionary, up to its depth.
It is usually much faster to create an ImageDict by appending images to it, @@ -242,7 +242,7 @@
The ImageDict Class
- -
+mergedicts(dict1, dict2)¶mergedicts(dict1, dict2)[source]¶Alternative version of dict_union using generators which is much faster for large dicts but needs to be converted to a dict when it’s called: new_dict = dict(mergdicts(dict1,dict))
@@ -250,7 +250,7 @@The ImageDict Class
- -
+remove(rm_dict, skip_key_relist=False)¶remove(rm_dict, skip_key_relist=False)[source]¶removes a dictionary from within an ImageDict. The skip_key_relist option can be set to True to stop the regeneration of key lists.
TIP: Because the remove process needs to prune empty sections afterwards, @@ -261,7 +261,7 @@
The ImageDict Class
- -
+return_from_list(vals_at_depth)¶return_from_list(vals_at_depth)[source]¶Returns the end values of ImageDict, when given a list of values for the keys at different depths. Returns None if the set of values is not contained in the ImageDict.
@@ -272,7 +272,7 @@The ImageDict Class
- -
+return_key_inds(in_dict, out_array=None, this_set_of_inds=None, depth=None, level=None, verbose=False, devmode=False)¶return_key_inds(in_dict, out_array=None, this_set_of_inds=None, depth=None, level=None, verbose=False, devmode=False)[source]¶Does the work for dict_index_array, by recursively adding indices to the keys to a current list, and branching where required, and adding compelted lists to the out_array
@@ -280,7 +280,7 @@The ImageDict Class
- -
+sort_keys(sort_methods, devmode=False)¶sort_keys(sort_methods, devmode=False)[source]¶Sorts the keys of a plot dictionary, according to a particular sort method (or a list of sort methods that matches the number of keys).
-
@@ -304,18 +304,18 @@
-
-
ImageMetaTag.readmeta_from_image(img_file, img_format=None)[source]¶
+ImageMetaTag.readmeta_from_image(img_file, img_format=None)¶
Reads the metadata added by the ImageMetaTag savefig, from an image file, and returns a dictionary of tagname: value pairs
-
-
ImageMetaTag.dict_heirachy_from_list(in_dict, payload, heirachy)[source]¶
+ImageMetaTag.dict_heirachy_from_list(in_dict, payload, heirachy)¶
Converts a flat dictionary of tagname: value pairs, into an ordered dictionary of dictionaries according to the input heirachy (which is a list of tagnames).
The output dictionary will only have one element per level, but can be used to create or -append into an
@@ -324,7 +324,7 @@ImageMetaTag.ImageDict. +append into an ImageMetaTag.ImageDict. The final level will be the ‘payload’ input, which is the object the dictionary, with all it’s levels, is describing. The payload would usually be the full/relative path of the image file, or list of image files.Functions useful in preparing ImageDicts
- -
+ImageMetaTag.dict_split(in_dict, n_split=None, size_split=None, extra_opts=None)¶ImageMetaTag.dict_split(in_dict, n_split=None, size_split=None, extra_opts=None)[source]¶Generator that breaks up a flat dictionary and yields a set of sub-dictionaries in n_split chunks, or size_split in size. It is split on it’s first level, not recursively.
It is very useful for splitting large dictionaries of image metadata @@ -345,7 +345,7 @@
Functions useful in preparing ImageDicts
- -
+ImageMetaTag.simple_dict_filter(simple_dict, tests, raise_key_mismatch=False)¶ImageMetaTag.simple_dict_filter(simple_dict, tests, raise_key_mismatch=False)[source]¶Tests the contents of a simple, un-heirachical dict (properties an image) against a set of tests.
An example set of tests: @@ -368,7 +368,7 @@
Functions useful in preparing ImageDicts
- -
+ImageMetaTag.check_for_required_keys(img_info, req_keys)¶ImageMetaTag.check_for_required_keys(img_info, req_keys)[source]¶Checks an img_info dictionary has a set of required keys, specifed as a list of strings
Returns True or False accordingly.
- -
The ImageDict Class¶
Functions useful in preparing ImageDicts
- -
The ImageDict Class
+
-
- © Copyright 2015-2017, British Crown Copyright.
- Created using Sphinx 1.4.8.
+
\ No newline at end of file
diff --git a/docs/build/html/_modules/ImageMetaTag.html b/docs/build/html/_modules/ImageMetaTag.html
new file mode 100644
index 0000000..349bcb2
--- /dev/null
+++ b/docs/build/html/_modules/ImageMetaTag.html
@@ -0,0 +1,139 @@
+
+
+
+
+
+
+
+ ImageMetaTag — ImageMetaTag 0.6.5 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ImageMetaTag.db — ImageMetaTag 0.6.4 documentation
+ ImageMetaTag.db — ImageMetaTag 0.6.5 documentation
@@ -14,7 +14,7 @@
-
-
-
-
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/build/html/_modules/ImageMetaTag/db.html b/docs/build/html/_modules/ImageMetaTag/db.html
index 7a9a104..d0cc15d 100644
--- a/docs/build/html/_modules/ImageMetaTag/db.html
+++ b/docs/build/html/_modules/ImageMetaTag/db.html
@@ -6,7 +6,7 @@
-
+
+
+
+
+
+
+
+
+
+ Source code for ImageMetaTag
+'''
+ImageMetaTag is a python package built around a wrapper for
+`savefig <http://matplotlib.org/api/pyplot_api.html?highlight=savefig#matplotlib.pyplot.savefig>`_
+in
+`matplotlib <http://matplotlib.org/>`_, which adds metadata tags to supported image file formats.
+
+Once the images have been tagged, it can also be used to manage an
+`SQL database <https://docs.python.org/2/library/sqlite3.html>`_ of images and their metadata.
+The image metadata can be used to produce an
+:class:`ImageMetaTag.ImageDict` object: a structured/heirachical dictionary of dictionaries
+which can be used to easily create web pages to present large numbers of images.
+
+As the image metadata tagging process involves reading the image using the Image library,
+a few common image post-processing options are included such as cropping, logo addition and
+colour palette manipulation to reduce filesizes.
+
+.. moduleauthor:: Malcolm Brooks https://github.com/malcolmbrooks
+
+(C) Crown copyright Met Office. All rights reserved.
+Released under BSD 3-Clause License. See LICENSE for more details.
+'''
+
+__version__ = '0.6.5'
+# for consistency, the version here should match:
+# ImageMetaTag/__init__.py
+# ImageMetaTag/javascript/imt_dropdown.js
+# docs/source/conf.py
+# setup.py
+__documentation__ = 'http://scitools-incubator.github.io/image-meta-tag/build/html/'
+
+# list fo file formats which are valid for saving metadata to:
+META_IMG_FORMATS = ['png']
+# and which can do image post-processing
+POSTPROC_IMG_FORMATS = ['png']
+
+# default timeout and retries for database access:
+DEFAULT_DB_TIMEOUT = 6
+DEFAULT_DB_ATTEMPTS = 20
+
+from ImageMetaTag.savefig import savefig, image_file_postproc
+from ImageMetaTag.img_dict import ImageDict, readmeta_from_image, dict_heirachy_from_list, \
+ dict_split, simple_dict_filter, check_for_required_keys
+# we want all of the functions in webpage and db, as a separate level
+import ImageMetaTag.webpage, ImageMetaTag.db
+
+
+
-
+
Quick search
-
+
Source code for ImageMetaTag.db
-'''
+'''
This module contains a set of functions to create/write to/read
and maintain an sqlite3 database of image files and their associated metadata.
@@ -77,26 +79,26 @@ Source code for ImageMetaTag.db
import os, sqlite3, fnmatch, time, errno, pdb
-from ImageMetaTag import META_IMG_FORMATS, DEFAULT_DB_TIMEOUT, DEFAULT_DB_ATTEMPTS
-from ImageMetaTag.img_dict import readmeta_from_image, check_for_required_keys
+from ImageMetaTag import META_IMG_FORMATS, DEFAULT_DB_TIMEOUT, DEFAULT_DB_ATTEMPTS
+from ImageMetaTag.img_dict import readmeta_from_image, check_for_required_keys
-from datetime import datetime
-import numpy as np
-from cStringIO import StringIO
+from datetime import datetime
+import numpy as np
+from cStringIO import StringIO
-# the name of the database table that holds the sqlite database of plot metadata
-SQLITE_IMG_INFO_TABLE = 'img_info'
+# the name of the database table that holds the sqlite database of plot metadata
+SQLITE_IMG_INFO_TABLE = 'img_info'
[docs]def info_key_to_db_name(in_str):
- 'Consistently convert a name in the img_info dict to something to be used in the database'
- return in_str.replace(' ', '__')
-
+ 'Consistently convert a name in the img_info dict to something to be used in the database'
+ return in_str.replace(' ', '__')
+
[docs]def db_name_to_info_key(in_str):
- 'Inverse of info_key_to_db_name'
- # convert to string, to remove unicode string
- return str(in_str).replace('__', ' ')
-
-[docs]def write_img_to_dbfile(db_file, img_filename, img_info, add_strict=False,
+ 'Inverse of info_key_to_db_name'
+ # convert to string, to remove unicode string
+ return str(in_str).replace('__', ' ')
+
+[docs]def write_img_to_dbfile(db_file, img_filename, img_info, add_strict=False,
timeout=DEFAULT_DB_TIMEOUT):
'''
Writes image metadata to a database.
@@ -119,19 +121,19 @@ Source code for ImageMetaTag.db
'''
if len(img_info) == 0:
- raise ValueError('Size of image info dict is zero')
- if db_file is None:
+ raise ValueError('Size of image info dict is zero')
+ if db_file is None:
pass
else:
- # open the database:
+ # open the database:
dbcn, dbcr = open_or_create_db_file(db_file, img_info, timeout=timeout)
- # now write:
+ # now write:
write_img_to_open_db(dbcr, img_filename, img_info, add_strict=add_strict)
- # now commit that databasde entry and close:
+ # now commit that databasde entry and close:
dbcn.commit()
- dbcn.close()
-
-
+[docs]def read(db_file, required_tags=None, tag_strings=None,
db_timeout=DEFAULT_DB_TIMEOUT,
db_attempts=DEFAULT_DB_ATTEMPTS):
'''
@@ -160,52 +162,52 @@ Source code for ImageMetaTag.db
In older versions, this was named read_img_info_from_dbfile which will still work.
'''
- if db_file is None:
- return None, None
+ if db_file is None:
+ return None, None
else:
if not os.path.isfile(db_file):
- return None, None
+ return None, None
else:
n_tries = 1
- read_db = False
+ read_db = False
while not read_db and n_tries <= db_attempts:
try:
- # open the connection and the cursor:
+ # open the connection and the cursor:
dbcn, dbcr = open_db_file(db_file, timeout=db_timeout)
- # read it:
+ # read it:
f_list, out_dict = read_img_info_from_dbcursor(dbcr,
required_tags=required_tags,
tag_strings=tag_strings)
- # close connection:
+ # close connection:
dbcn.close()
- read_db = True
+ read_db = True
except sqlite3.OperationalError as OpErr:
- if 'database is locked' in OpErr.message:
- # database being locked is what the retries and timeouts are for:
- print '%s database timeout reading from file "%s", %s s' \
+ if 'database is locked' in OpErr.message:
+ # database being locked is what the retries and timeouts are for:
+ print '%s database timeout reading from file "%s", %s s' \
% (dt_now_str(), db_file, n_tries * db_timeout)
n_tries += 1
- elif OpErr.message == 'no such table: {}'.format(SQLITE_IMG_INFO_TABLE):
- # the db file exists, but it doesn't have anything in it:
- return None, None
+ elif OpErr.message == 'no such table: {}'.format(SQLITE_IMG_INFO_TABLE):
+ # the db file exists, but it doesn't have anything in it:
+ return None, None
else:
- # everything else needs to be reported and raised immediately:
- msg = '{} for file {}'.format(OpErr.message, db_file)
+ # everything else needs to be reported and raised immediately:
+ msg = '{} for file {}'.format(OpErr.message, db_file)
raise sqlite3.OperationalError(msg)
- # if we went through all the attempts then it is time to raise the error:
+ # if we went through all the attempts then it is time to raise the error:
if n_tries > db_attempts:
- msg = '{} for file {}'.format(OpErr.message, db_file)
+ msg = '{} for file {}'.format(OpErr.message, db_file)
raise sqlite3.OperationalError(msg)
- # close connection:
+ # close connection:
dbcn.close()
- return f_list, out_dict
-
+ return f_list, out_dict
+
read_img_info_from_dbfile = read
-[docs]def merge_db_files(main_db_file, add_db_file, delete_add_db=False,
- delete_added_entries=False,
+[docs]def merge_db_files(main_db_file, add_db_file, delete_add_db=False,
+ delete_added_entries=False,
db_timeout=DEFAULT_DB_TIMEOUT, db_attempts=DEFAULT_DB_ATTEMPTS):
'''
Merges two ImageMetaTag database files, with the contents of add_db_file added
@@ -222,48 +224,48 @@ Source code for ImageMetaTag.db
databases. It does nothing if delete_add_db is True.
'''
- # read what we want to add in:
+ # read what we want to add in:
add_filelist, add_tags = read(add_db_file, db_timeout=db_timeout, db_attempts=db_attempts)
- if add_filelist is not None:
+ if add_filelist is not None:
if len(add_filelist) > 0:
n_tries = 1
- wrote_db = False
+ wrote_db = False
while not wrote_db and n_tries <= db_attempts:
try:
- # open the main database
+ # open the main database
dbcn, dbcr = open_db_file(main_db_file, timeout=db_timeout)
- # and add in the new contents:
+ # and add in the new contents:
for add_file, add_info in add_tags.iteritems():
write_img_to_open_db(dbcr, add_file, add_info)
dbcn.commit()
- # if we got here, then we're good!
- wrote_db = True
- # finally close:
+ # if we got here, then we're good!
+ wrote_db = True
+ # finally close:
dbcn.close()
except sqlite3.OperationalError as OpErr:
- if 'database is locked' in OpErr.message:
- # database being locked is what the retries and timeouts are for:
- print '%s database timeout writing to file "%s", %s s' \
+ if 'database is locked' in OpErr.message:
+ # database being locked is what the retries and timeouts are for:
+ print '%s database timeout writing to file "%s", %s s' \
% (dt_now_str(), main_db_file, n_tries * db_timeout)
n_tries += 1
else:
- # everything else needs to be reported and raised immediately:
- msg = '{} for file {}'.format(OpErr.message, main_db_file)
+ # everything else needs to be reported and raised immediately:
+ msg = '{} for file {}'.format(OpErr.message, main_db_file)
raise sqlite3.OperationalError(msg)
- # if we went through all the attempts then it is time to raise the error:
+ # if we went through all the attempts then it is time to raise the error:
if n_tries > db_attempts:
- msg = '{} for file {}'.format(OpErr.message, main_db_file)
+ msg = '{} for file {}'.format(OpErr.message, main_db_file)
raise sqlite3.OperationalError(msg)
- # delete or tidy:
+ # delete or tidy:
if delete_add_db:
rmfile(add_db_file)
elif delete_added_entries:
- del_plots_from_dbfile(add_db_file, add_filelist, do_vacuum=False,
- allow_retries=True, skip_warning=True)
-
-[docs]def open_or_create_db_file(db_file, img_info, restart_db=False, timeout=DEFAULT_DB_TIMEOUT):
+ del_plots_from_dbfile(add_db_file, add_filelist, do_vacuum=False,
+ allow_retries=True, skip_warning=True)
+
+[docs]def open_or_create_db_file(db_file, img_info, restart_db=False, timeout=DEFAULT_DB_TIMEOUT):
'''
Opens a database file and sets up initial tables, then returns the connection and cursor.
@@ -281,27 +283,27 @@ Source code for ImageMetaTag.db
if not os.path.isfile(db_file) or restart_db:
if os.path.isfile(db_file):
os.remove(db_file)
- # create a new database file:
+ # create a new database file:
dbcn = sqlite3.connect(db_file)
dbcr = dbcn.cursor()
- # and create the table:
+ # and create the table:
create_table_for_img_info(dbcr, img_info)
else:
- # open the database file:
+ # open the database file:
dbcn, dbcr = open_db_file(db_file, timeout=timeout)
- # check for the required table:
+ # check for the required table:
table_names = list_tables(dbcr)
if SQLITE_IMG_INFO_TABLE not in table_names:
- # create it if required:
+ # create it if required:
create_table_for_img_info(dbcr, img_info)
- return dbcn, dbcr
-
+ return dbcn, dbcr
+
def create_table_for_img_info(dbcr, img_info):
- 'Creates a database table, in a database cursor, to store for the input img_info'
- create_command = 'CREATE TABLE {}(fname TEXT PRIMARY KEY,'.format(SQLITE_IMG_INFO_TABLE)
+ 'Creates a database table, in a database cursor, to store for the input img_info'
+ create_command = 'CREATE TABLE {}(fname TEXT PRIMARY KEY,'.format(SQLITE_IMG_INFO_TABLE)
for key in img_info.keys():
- create_command += ' "{}" TEXT,'.format(info_key_to_db_name(key))
- create_command = create_command[0:-1] + ')'
+ create_command += ' "{}" TEXT,'.format(info_key_to_db_name(key))
+ create_command = create_command[0:-1] + ')'
dbcr.execute(create_command)
[docs]def open_db_file(db_file, timeout=DEFAULT_DB_TIMEOUT):
@@ -314,8 +316,8 @@ Source code for ImageMetaTag.db
dbcn = sqlite3.connect(db_file, timeout=timeout)
dbcr = dbcn.cursor()
- return dbcn, dbcr
-
+ return dbcn, dbcr
+
[docs]def read_db_file_to_mem(db_file, timeout=DEFAULT_DB_TIMEOUT):
'''
Opens a pre-existing database file into a copy held in memory. This can be accessed much
@@ -330,24 +332,24 @@ Source code for ImageMetaTag.db
Returns an open database connection (dbcn) and cursor (dbcr)
'''
- # read the database into an in-memory file object:
- #dbcn = sqlite3.connect(db_file)
+ # read the database into an in-memory file object:
+ #dbcn = sqlite3.connect(db_file)
dbcn, _ = open_db_file(db_file, timeout=timeout)
memfile = StringIO()
for line in dbcn.iterdump():
- memfile.write('%s\n' % line)
+ memfile.write('%s\n' % line)
dbcn.close()
memfile.seek(0)
- # Create a database in memory and import from memfile
- dbcn = sqlite3.connect(":memory:")
+ # Create a database in memory and import from memfile
+ dbcn = sqlite3.connect(":memory:")
dbcn.cursor().executescript(memfile.read())
dbcn.commit()
dbcr = dbcn.cursor()
- return dbcn, dbcr
-
-[docs]def write_img_to_open_db(dbcr, filename, img_info, add_strict=False, attempt_replace=False):
+ return dbcn, dbcr
+
+[docs]def write_img_to_open_db(dbcr, filename, img_info, add_strict=False, attempt_replace=False):
'''
Does the work for write_img_to_dbfile to add an image to the open database cursor (dbcr)
@@ -357,44 +359,44 @@ Source code for ImageMetaTag.db
entry if the image is already present. Otherwise it will ignore it.
'''
- # now add in the information:
- # get the name of the fields from the cursor descripton:
- _ = dbcr.execute('select * from %s' % SQLITE_IMG_INFO_TABLE).fetchone()
+ # now add in the information:
+ # get the name of the fields from the cursor descripton:
+ _ = dbcr.execute('select * from %s' % SQLITE_IMG_INFO_TABLE).fetchone()
field_names = [r[0] for r in dbcr.description]
- # convert these to keys:
+ # convert these to keys:
field_names = [db_name_to_info_key(x) for x in field_names]
- # now build the command
- add_command = 'INSERT INTO {}(fname,'.format(SQLITE_IMG_INFO_TABLE)
+ # now build the command
+ add_command = 'INSERT INTO {}(fname,'.format(SQLITE_IMG_INFO_TABLE)
add_list = [filename]
for key, item in img_info.iteritems():
if key in field_names:
- add_command += ' "{}",'.format(info_key_to_db_name(key))
+ add_command += ' "{}",'.format(info_key_to_db_name(key))
add_list.append(item)
elif add_strict:
- raise ValueError('Attempting to add a line to the database that include invalid fields')
- # add in the right number of ?
- add_command = add_command[0:-1] + ') VALUES(' + '?,'*(len(add_list)-1) + '?)'
+ raise ValueError('Attempting to add a line to the database that include invalid fields')
+ # add in the right number of ?
+ add_command = add_command[0:-1] + ') VALUES(' + '?,'*(len(add_list)-1) + '?)'
try:
dbcr.execute(add_command, add_list)
except sqlite3.IntegrityError:
if attempt_replace:
- # try an INSERT OR REPLACE
- add_command.replace('INSERT ', 'INSERT OR REPLACE ')
- # if this fails, want it to report it's error message as is, so no 'try':
+ # try an INSERT OR REPLACE
+ add_command.replace('INSERT ', 'INSERT OR REPLACE ')
+ # if this fails, want it to report it's error message as is, so no 'try':
dbcr.execute(add_command, add_list)
else:
- # this file is already in the database (as the primary key, so do nothing...)
+ # this file is already in the database (as the primary key, so do nothing...)
pass
finally:
- pass
-
+ pass
+
def list_tables(dbcr):
- 'lists the tables present, from a database cursor'
- result = dbcr.execute("SELECT name FROM sqlite_master WHERE type='table';").fetchall()
+ 'lists the tables present, from a database cursor'
+ result = dbcr.execute("SELECT name FROM sqlite_master WHERE type='table';").fetchall()
table_names = sorted(zip(*result)[0])
return table_names
-[docs]def read_img_info_from_dbcursor(dbcr, required_tags=None, tag_strings=None):
+[docs]def read_img_info_from_dbcursor(dbcr, required_tags=None, tag_strings=None):
'''
Reads from an open database cursor (dbcr) for :func:`ImageMetaTag.db.read` and other routines.
@@ -402,15 +404,15 @@ Source code for ImageMetaTag.db
* required_tags - a list of image tags to return, and to fail if not all are present
* tag_strings - an input list that will be populated with the unique values of the image tags
'''
- # read in the data from the database:
- db_contents = dbcr.execute('select * from %s' % SQLITE_IMG_INFO_TABLE).fetchall()
- # and convert that to a useful dict/list combo:
+ # read in the data from the database:
+ db_contents = dbcr.execute('select * from %s' % SQLITE_IMG_INFO_TABLE).fetchall()
+ # and convert that to a useful dict/list combo:
filename_list, out_dict = process_select_star_from(db_contents, dbcr,
required_tags=required_tags,
tag_strings=tag_strings)
- return filename_list, out_dict
-
-[docs]def process_select_star_from(db_contents, dbcr, required_tags=None, tag_strings=None):
+ return filename_list, out_dict
+
+[docs]def process_select_star_from(db_contents, dbcr, required_tags=None, tag_strings=None):
'''
Converts the output from a select * from .... command into a standard output format
Requires a database cursor (dbcr) to identify the field names.
@@ -425,28 +427,28 @@ Source code for ImageMetaTag.db
* a dictionary, by filename, containing a dictionary of the image metadata \
as tagname: value
'''
- # get the name of the fields from the cursor descripton:
+ # get the name of the fields from the cursor descripton:
out_dict = {}
filename_list = []
- # get the name of the fields from the cursor descripton:
+ # get the name of the fields from the cursor descripton:
field_names = [r[0] for r in dbcr.description]
- # the required_tags input is a list of tag names (as strings):
- if required_tags is not None:
+ # the required_tags input is a list of tag names (as strings):
+ if required_tags is not None:
if not isinstance(required_tags, list):
- raise ValueError('Input required_tags should be a list of strings')
+ raise ValueError('Input required_tags should be a list of strings')
else:
for test_str in required_tags:
if not isinstance(test_str, str):
- raise ValueError('Input required_tags should be a list of strings')
+ raise ValueError('Input required_tags should be a list of strings')
- if tag_strings is not None:
+ if tag_strings is not None:
if not isinstance(tag_strings, list):
- raise ValueError('Input tag_strings should be a list')
+ raise ValueError('Input tag_strings should be a list')
- # now iterate and make a dictionary to return,
- # with the tests outside the loops so they're not tested for every row and element:
- if required_tags is None and tag_strings is None:
+ # now iterate and make a dictionary to return,
+ # with the tests outside the loops so they're not tested for every row and element:
+ if required_tags is None and tag_strings is None:
for row in db_contents:
fname = str(row[0])
filename_list.append(fname)
@@ -454,10 +456,10 @@ Source code for ImageMetaTag.db
for tag_name, tag_val in zip(field_names[1:], row[1:]):
img_info[db_name_to_info_key(tag_name)] = str(tag_val)
out_dict[fname] = img_info
- # return None, None if the contents are empty:
+ # return None, None if the contents are empty:
if len(filename_list) == 0 and len(out_dict) == 0:
- return None, None
- elif required_tags is not None and tag_strings is None:
+ return None, None
+ elif required_tags is not None and tag_strings is None:
for row in db_contents:
fname = str(row[0])
filename_list.append(fname)
@@ -467,14 +469,14 @@ Source code for ImageMetaTag.db
if tag_name_full in required_tags:
img_info[tag_name_full] = str(tag_val)
if len(img_info) != len(required_tags):
- raise ValueError('Database entry does not contain all of the required_tags')
+ raise ValueError('Database entry does not contain all of the required_tags')
out_dict[fname] = img_info
- # return None, None if the contents are empty:
+ # return None, None if the contents are empty:
if len(filename_list) == 0 and len(out_dict) == 0:
- return None, None
- elif required_tags is None and tag_strings is not None:
- # we want all tags, but we want them as referneces to a common list:
+ return None, None
+ elif required_tags is None and tag_strings is not None:
+ # we want all tags, but we want them as referneces to a common list:
for row in db_contents:
fname = str(row[0])
filename_list.append(fname)
@@ -482,54 +484,54 @@ Source code for ImageMetaTag.db
for tag_name, tag_val in zip(field_names[1:], row[1:]):
str_tag_val = str(tag_val)
try:
- # loacate the tag_string in the list:
+ # loacate the tag_string in the list:
tag_index = tag_strings.index(str_tag_val)
- # and refernece it:
+ # and refernece it:
img_info[db_name_to_info_key(tag_name)] = tag_strings[tag_index]
except ValueError:
- # tag not yet in the tag_strings list, so
- # add the new string onto the end:
+ # tag not yet in the tag_strings list, so
+ # add the new string onto the end:
tag_strings.append(str_tag_val)
- # and reference it:
+ # and reference it:
img_info[db_name_to_info_key(tag_name)] = tag_strings[-1]
out_dict[fname] = img_info
- # return None, None if the contents are empty:
+ # return None, None if the contents are empty:
if len(filename_list) == 0 and len(out_dict) == 0:
- return None, None
+ return None, None
else:
- # we want to filter the tags, and we want them as referneces to a common list:
+ # we want to filter the tags, and we want them as referneces to a common list:
for row in db_contents:
fname = str(row[0])
filename_list.append(fname)
img_info = {}
for tag_name, tag_val in zip(field_names[1:], row[1:]):
- # test to see if the tag name is required:
+ # test to see if the tag name is required:
tag_name_full = db_name_to_info_key(tag_name)
if tag_name_full in required_tags:
str_tag_val = str(tag_val)
try:
- # loacate the tag_string in the list:
+ # loacate the tag_string in the list:
tag_index = tag_strings.index(str_tag_val)
- # and refernece it:
+ # and refernece it:
img_info[tag_name_full] = tag_strings[tag_index]
except ValueError:
- # tag not yet in the tag_strings list, so
- # add the new string onto the end:
+ # tag not yet in the tag_strings list, so
+ # add the new string onto the end:
tag_strings.append(str_tag_val)
- # and reference it:
+ # and reference it:
img_info[tag_name_full] = tag_strings[-1]
out_dict[fname] = img_info
- # return None, None if the contents are empty:
+ # return None, None if the contents are empty:
if len(filename_list) == 0 and len(out_dict) == 0:
- return None, None
-
+ return None, None
- # we're good, return the data:
- return filename_list, out_dict
-[docs]def del_plots_from_dbfile(db_file, filenames, do_vacuum=True, allow_retries=True,
+ # we're good, return the data:
+ return filename_list, out_dict
+
+[docs]def del_plots_from_dbfile(db_file, filenames, do_vacuum=True, allow_retries=True,
db_timeout=DEFAULT_DB_TIMEOUT, db_attempts=DEFAULT_DB_ATTEMPTS,
- skip_warning=False):
+ skip_warning=False):
'''
deletes a list of files from a database file created by :mod:`ImageMetaTag.db`
@@ -547,97 +549,97 @@ Source code for ImageMetaTag.db
else:
fn_list = filenames
- if db_file is None:
+ if db_file is None:
pass
else:
if not os.path.isfile(db_file) or len(fn_list) == 0:
pass
else:
if allow_retries:
- # split the list of filenames up into appropciately sized chunks, so that concurrent
- # delete commands each have a chance to complete:
- # 200 is arbriatily chosen, but seems to work
+ # split the list of filenames up into appropciately sized chunks, so that concurrent
+ # delete commands each have a chance to complete:
+ # 200 is arbriatily chosen, but seems to work
chunk_size = 200
chunks = __gen_chunk_of_list(fn_list, chunk_size)
for chunk_o_filenames in chunks:
- # within each chunk of files, need to open the db, with time out retries etc:
+ # within each chunk of files, need to open the db, with time out retries etc:
n_tries = 1
- wrote_db = False
+ wrote_db = False
while not wrote_db and n_tries <= db_attempts:
try:
- # open the database
+ # open the database
dbcn, dbcr = open_db_file(db_file, timeout=db_timeout)
- # go through the file chunk, one by one, and delete:
+ # go through the file chunk, one by one, and delete:
for fname in chunk_o_filenames:
try:
- dbcr.execute("DELETE FROM %s WHERE fname=?" % SQLITE_IMG_INFO_TABLE, (fname,))
+ dbcr.execute("DELETE FROM %s WHERE fname=?" % SQLITE_IMG_INFO_TABLE, (fname,))
except sqlite3.OperationalError as OpErr_file:
- if OpErr_file.message == 'no such table: {}'.format(SQLITE_IMG_INFO_TABLE):
- # the db file exists, but it doesn't have anything in it:
+ if OpErr_file.message == 'no such table: {}'.format(SQLITE_IMG_INFO_TABLE):
+ # the db file exists, but it doesn't have anything in it:
if not skip_warning:
- msg = ('WARNING: Unable to delete file entry "{}" from'
- ' database "{}" as database table is missing')
- print msg.format(fname, db_file)
+ msg = ('WARNING: Unable to delete file entry "{}" from'
+ ' database "{}" as database table is missing')
+ print msg.format(fname, db_file)
return
else:
if not skip_warning:
- # if this fails, print a warning...
- # need to figure out why this happens
- msg = ('WARNING: unable to delete file entry:'
- ' "{}", type "{}" from database')
- print msg.format(fname, type(fname))
+ # if this fails, print a warning...
+ # need to figure out why this happens
+ msg = ('WARNING: unable to delete file entry:'
+ ' "{}", type "{}" from database')
+ print msg.format(fname, type(fname))
dbcn.commit()
- # if we got here, then we're good!
- wrote_db = True
- # finally close (for this chunk)
+ # if we got here, then we're good!
+ wrote_db = True
+ # finally close (for this chunk)
dbcn.close()
except sqlite3.OperationalError as OpErr:
- if 'database is locked' in OpErr.message:
- # database being locked is what the retries and timeouts are for:
- print '%s database timeout deleting from file "%s", %s s' \
+ if 'database is locked' in OpErr.message:
+ # database being locked is what the retries and timeouts are for:
+ print '%s database timeout deleting from file "%s", %s s' \
% (dt_now_str(), db_file, n_tries * db_timeout)
n_tries += 1
else:
- # everything else needs to be reported and raised immediately:
+ # everything else needs to be reported and raised immediately:
raise ValueError(OpErr.message)
- # if we went through all the attempts then it is time to raise the error:
+ # if we went through all the attempts then it is time to raise the error:
if n_tries > db_attempts:
- msg = '{} for file {}'.format(OpErr.message, db_file)
+ msg = '{} for file {}'.format(OpErr.message, db_file)
raise sqlite3.OperationalError(msg)
else:
- # just open the database:
+ # just open the database:
dbcn, dbcr = open_db_file(db_file)
- # delete the contents:
+ # delete the contents:
for i_fn, fname in enumerate(fn_list):
try:
- dbcr.execute("DELETE FROM %s WHERE fname=?" % SQLITE_IMG_INFO_TABLE, (fname,))
+ dbcr.execute("DELETE FROM %s WHERE fname=?" % SQLITE_IMG_INFO_TABLE, (fname,))
except:
if not skip_warning:
- # if this fails, print a warning...
- # need to figure out why this happens
- msg = ('WARNING: unable to delete file entry:'
- ' "{}", type "{}" from database')
- print msg.format(fname, type(fname))
- # commit every 100 to give other processes a chance:
+ # if this fails, print a warning...
+ # need to figure out why this happens
+ msg = ('WARNING: unable to delete file entry:'
+ ' "{}", type "{}" from database')
+ print msg.format(fname, type(fname))
+ # commit every 100 to give other processes a chance:
if i_fn % 100 == 0:
dbcn.commit()
time.sleep(1)
- # commit, and vacuum if required:
+ # commit, and vacuum if required:
dbcn.commit()
if do_vacuum:
if allow_retries:
- # need to re-open the db, if we allowed retries:
+ # need to re-open the db, if we allowed retries:
dbcn, dbcr = open_db_file(db_file)
- dbcn.execute("VACUUM")
+ dbcn.execute("VACUUM")
dbcn.close()
elif not allow_retries:
- dbcn.close()
-
+ dbcn.close()
+
def __gen_chunk_of_list(in_list, chunk_size):
- 'gnerator that yields a chunk of list, of length chunk size'
+ 'gnerator that yields a chunk of list, of length chunk size'
for ndx in range(0, len(in_list), chunk_size):
yield in_list[ndx:min(ndx + chunk_size, len(in_list))]
@@ -647,19 +649,19 @@ Source code for ImageMetaTag.db
Returns the output, processed by :func:`ImageMetaTag.db.process_select_star_from`
'''
- if db_file is None:
- sel_results = None
+ if db_file is None:
+ sel_results = None
else:
if not os.path.isfile(db_file):
- sel_results = None
+ sel_results = None
else:
- # just open the database:
+ # just open the database:
dbcn, dbcr = open_db_file(db_file)
- # do the select:
+ # do the select:
sel_results = select_dbcr_by_tags(dbcr, select_tags)
dbcn.close()
- return sel_results
-
+ return sel_results
+
[docs]def select_dbcr_by_tags(dbcr, select_tags):
'''
Selects from an open database cursor (dbcr) the entries that match a dict of field
@@ -668,43 +670,43 @@ Source code for ImageMetaTag.db
Returns the output, processed by :func:`ImageMetaTag.db.process_select_star_from`
'''
if len(select_tags) == 0:
- # just read and return the whole thing:
+ # just read and return the whole thing:
return read_img_info_from_dbcursor(dbcr)
else:
- # convert these to lists:
+ # convert these to lists:
tag_names = select_tags.keys()
tag_values = [select_tags[x] for x in tag_names]
- # Right... this is where I need to understand how to do a select!
- #select_command = 'SELECT * FROM %s WHERE symbol=?' % SQLITE_IMG_INFO_TABLE
- select_command = 'SELECT * FROM %s WHERE ' % SQLITE_IMG_INFO_TABLE
+ # Right... this is where I need to understand how to do a select!
+ #select_command = 'SELECT * FROM %s WHERE symbol=?' % SQLITE_IMG_INFO_TABLE
+ select_command = 'SELECT * FROM %s WHERE ' % SQLITE_IMG_INFO_TABLE
n_tags = len(tag_names)
use_tag_values = []
for i_tag, tag_name, tag_val in zip(range(n_tags), tag_names, tag_values):
if isinstance(tag_val, (list, tuple)):
- # if a list or tuple, then use IN:
- select_command += '%s IN (' % info_key_to_db_name(tag_name)
- select_command += ', '.join(['?']*len(tag_val))
- select_command += ')'
+ # if a list or tuple, then use IN:
+ select_command += '%s IN (' % info_key_to_db_name(tag_name)
+ select_command += ', '.join(['?']*len(tag_val))
+ select_command += ')'
if i_tag+1 < n_tags:
- select_command += ' AND '
+ select_command += ' AND '
use_tag_values.extend(tag_val)
else:
- # do an exact match:
+ # do an exact match:
if i_tag+1 < n_tags:
- select_command += '%s = ? AND ' % info_key_to_db_name(tag_name)
+ select_command += '%s = ? AND ' % info_key_to_db_name(tag_name)
else:
- select_command += '%s = ?' % info_key_to_db_name(tag_name)
+ select_command += '%s = ?' % info_key_to_db_name(tag_name)
use_tag_values.append(tag_val)
db_contents = dbcr.execute(select_command, use_tag_values).fetchall()
- # and convert that to a useful dict/list combo:
+ # and convert that to a useful dict/list combo:
filename_list, out_dict = process_select_star_from(db_contents, dbcr)
- return filename_list, out_dict
-
-[docs]def scan_dir_for_db(basedir, db_file, img_tag_req=None, subdir_excl_list=None,
- known_file_tags=None, verbose=False, no_file_ext=False,
- return_timings=False, restart_db=False):
+ return filename_list, out_dict
+
+[docs]def scan_dir_for_db(basedir, db_file, img_tag_req=None, subdir_excl_list=None,
+ known_file_tags=None, verbose=False, no_file_ext=False,
+ return_timings=False, restart_db=False):
'''
A useful utility that scans a directory on disk for images that can go into a database.
This should only be used to build a database from a directory of tagged images that
@@ -734,10 +736,10 @@ Source code for ImageMetaTag.db
'''
if os.path.isfile(db_file) and not restart_db:
- raise ValueError('''scan_dir_for_db will not work on a pre-existing file unless restart_db
-is True, in which case the database file will be restarted as empty. Use with care.''')
+ raise ValueError('''scan_dir_for_db will not work on a pre-existing file unless restart_db
+is True, in which case the database file will be restarted as empty. Use with care.''')
- if known_file_tags is not None:
+ if known_file_tags is not None:
known_files = known_file_tags.keys()
else:
known_files = []
@@ -745,56 +747,56 @@ Source code for ImageMetaTag.db
if return_timings:
prev_time = datetime.now()
add_interval = 1
- # total number of entries added
+ # total number of entries added
n_added = 0
- # number of entries added since last timer
+ # number of entries added since last timer
n_add_this_timer = 0
- # and this is the list to return:
+ # and this is the list to return:
n_adds = []
timings_per_add = []
os.chdir(basedir)
- first_img = True
- for root, dirs, files in os.walk('./', followlinks=True, topdown=True):
- if not subdir_excl_list is None:
+ first_img = True
+ for root, dirs, files in os.walk('./', followlinks=True, topdown=True):
+ if not subdir_excl_list is None:
dirs[:] = [d for d in dirs if not d in subdir_excl_list]
for meta_img_format in META_IMG_FORMATS:
- for filename in fnmatch.filter(files, '*%s' % meta_img_format):
- # append to the list, taking off the preceeding './' and the file extension:
- if root == './':
+ for filename in fnmatch.filter(files, '*%s' % meta_img_format):
+ # append to the list, taking off the preceeding './' and the file extension:
+ if root == './':
img_path = filename
else:
- img_path = '%s/%s' % (root[2:], filename)
+ img_path = '%s/%s' % (root[2:], filename)
if no_file_ext:
img_name = os.path.splitext(img_path)[0]
else:
img_name = img_path
- # read the metadata:
+ # read the metadata:
if img_name in known_files:
- # if we know this file details, then get it:
+ # if we know this file details, then get it:
known_files.remove(img_name)
img_info = known_file_tags.pop(img_name)
- read_ok = True
+ read_ok = True
else:
- # otherwise read from disk:
+ # otherwise read from disk:
(read_ok, img_info) = readmeta_from_image(img_path)
if read_ok:
if img_tag_req:
- # check to see if an image is needed:
+ # check to see if an image is needed:
use_img = check_for_required_keys(img_info, img_tag_req)
else:
- use_img = True
+ use_img = True
if use_img:
if first_img:
db_cn, db_cr = open_or_create_db_file(db_file, img_info,
- restart_db=True)
- first_img = False
+ restart_db=True)
+ first_img = False
write_img_to_open_db(db_cr, img_name, img_info)
if verbose:
- print img_name
+ print img_name
if return_timings:
n_added += 1
@@ -803,23 +805,23 @@ Source code for ImageMetaTag.db
time_interval_s = (datetime.now()- prev_time).total_seconds()
timings_per_add.append(time_interval_s / add_interval)
n_adds.append(n_added)
- # increase the add_interval so we don't swamp
- # the processing with timings!
+ # increase the add_interval so we don't swamp
+ # the processing with timings!
add_interval = np.ceil(np.sqrt(n_added))
n_add_this_timer = 0
if verbose:
- print 'len(n_adds)=%s, currently every %s' \
+ print 'len(n_adds)=%s, currently every %s' \
% (len(n_adds), add_interval)
- # commit and close, and we are done:
+ # commit and close, and we are done:
if not first_img:
db_cn.commit()
db_cn.close()
if return_timings:
- return n_adds, timings_per_add
-
+ return n_adds, timings_per_add
+
def rmfile(path):
"""
os.remove, but does not complain if the file has already been
@@ -833,8 +835,8 @@ Source code for ImageMetaTag.db
else: raise
def dt_now_str():
- 'returns datetime.now(), as a string, in a common format'
- return datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+ 'returns datetime.now(), as a string, in a common format'
+ return datetime.now().strftime('%Y-%m-%d %H:%M:%S')
@@ -842,7 +844,7 @@ Source code for ImageMetaTag.db
-
+
-
- © Copyright 2015-2017, British Crown Copyright.
- Created using Sphinx 1.4.8.
+
\ No newline at end of file
diff --git a/docs/build/html/_modules/ImageMetaTag/img_dict.html b/docs/build/html/_modules/ImageMetaTag/img_dict.html
deleted file mode 100644
index 56be4e4..0000000
--- a/docs/build/html/_modules/ImageMetaTag/img_dict.html
+++ /dev/null
@@ -1,1017 +0,0 @@
-
-
-
-
-
-
-
- ImageMetaTag.img_dict — ImageMetaTag 0.6.4 documentation
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Source code for ImageMetaTag.img_dict
-'''
-This submodule contains the :class:`ImageMetaTag.ImageDict` class, and functions for preparing them.
-
-The purpose of an :class:`ImageMetaTag.ImageDict` is to sort the image metadata, supplied to
-:func:`ImageMetaTag.savefig` and usually stored in a database file, into a useful form that
-can quickly and easily be presented as a webpage by :func:`ImageMetaTag.webpage.write_full_page`.
-
-An easy example of creating a webpage, using an ImageDict is shown in
-`simplest_image_dict.py <simple.html>`_
-
-.. moduleauthor:: Malcolm Brooks https://github.com/malcolmbrooks
-'''
-# required imports
-import os, re, collections, inspect, copy
-from PIL import Image
-# useful for debugging
-import pdb
-
-from copy import deepcopy
-from itertools import islice, compress
-from math import ceil
-
-[docs]class ImageDict(object):
- '''
- A class which holds a heirachical dictionary of dictionaries, and the associated
- methods for appending/removing dictionaries from it.
-
- The expected use case for the dictionary is to represent a large set of images,
- which can be organised by their metadata tags.
-
- When used in this way, the ImageDict module contains functions to produce web
- pages for browsing the images.
-
- The input_dict should be a heirachical dictionary of dictionaries, containing
- the image metadata, in the required order. In order to convert a flat dictionary
- of metadata items, use :func:`ImageMetaTag.dict_heirachy_from_list`
-
- Options:
- * level_names - a list of the tagnames, in full, giving a name/description of what \
- the metadata item means. Ordered by level of the input dict.
- * selector_widths - a list of html strings giving the widths of each selector in the \
- output webpage. CURRENTLY UNUSED!
- * selector_animated - an integer indicating which selector on the output webpage is \
- to be animated.
- * animation_dicrection - +1 indicates the animation moves forwards, -1 indicates it \
- moves backwards.
-
- Objects:
- * dict - the heirachical dictionary of dictionaries containing the image structure.
- * keys - a list of keys for each level of the dict, within a dictionary using the level \
- number as the keys.
- * level_names - If supplied, this stores the full names of the items in keys.
- * selector_animated - the level index which will be animated on the output webpage.
- * animation_direction - the direction of animation (+1 for forward, -1 for backward).
- * selector_widths - a list of desired widths on the output web page (CURRENTLY UNUSED).
- '''
- def __init__(self, input_dict, level_names=None,
- selector_widths=None, selector_animated=None,
- animation_direction=None):
-
- if level_names is None:
- self.level_names = None
- else:
- if not isinstance(level_names, list):
- msg = 'A mapping of key names to full names has been supplied, but it is not a list'
- raise ValueError(msg)
- else:
- self.level_names = level_names
-
- # set the dictionary:
- self.dict = input_dict
- # now list the keys, at each level, as lists. These can be reorderd by the calling routine,
- # so when the dictionary is written out, they can be in the desired order:
- self.list_keys_by_depth()
-
- dict_depth = self.dict_depth()
- if self.level_names is not None:
- if dict_depth != len(self.level_names):
- raise ValueError('Mismatch between depth of dictionary and level_names')
-
- # this controls the width of the selector, on the resultant webpage:
- if selector_widths is None:
- self.selector_widths = [""] * dict_depth
- else:
- if not isinstance(selector_widths, list):
- msg = 'Specified selector_widths should be a list, but it is '
- msg += '"%s" instead' % selector_widths
- raise ValueError(msg)
- if len(selector_widths) != self.dict_depth():
- msg = 'Specified selector_widths length disagrees with the dictionary depth'
- raise ValueError(msg)
-
- self.selector_widths = selector_widths
- # this controls whether or not a particualr selector uses the animation controls or not.
- # There can be only one per page, default is that none use it...
- if selector_animated is None:
- self.selector_animated = -1
- else:
- if not isinstance(selector_animated, int):
- msg = 'Specified selector_animated should be a single integer'
- raise ValueError(msg)
- if selector_animated < -1 or selector_animated >= self.dict_depth():
- msg = 'selector_animated (%s)' % selector_animated
- msg += ' is out of range of the plot dictionary depth.'
- raise ValueError(msg)
- # that passes, so store it:
- self.selector_animated = selector_animated
-
- if animation_direction is None:
- self.animation_direction = 1
- else:
- if not isinstance(animation_direction, int) or \
- (animation_direction != 1 and animation_direction != -1):
- msg = 'Specified animation_direction should be a single integer with values'
- msg += ' +1 or -1, but it is "%s" instead' % animation_direction
- raise ValueError(msg)
- self.animation_direction = animation_direction
-
- def __repr__(self):
- outstr = 'ImageMetaTag ImageDict:\n'
- outstr = self.dict_print(self.dict, indent=1, outstr=outstr)
- return outstr
-
-[docs] def append(self, new_dict, devmode=False, skip_key_relist=False):
- '''
- appends a new dictionary (with a single element in each layer!) into a current ImageDict.
-
- The skip_key_relist option can be set to True to stop the regeneration of key lists.
- '''
- if isinstance(new_dict, ImageDict):
- merged_dict = dict(self.mergedicts(self.dict, new_dict.dict))
- self.dict = merged_dict
- elif isinstance(new_dict, dict):
- merged_dict = dict(self.mergedicts(self.dict, new_dict))
- self.dict = merged_dict
- else:
- raise ValueError('Cannot append data type %s to a ImageDict' % type(new_dict))
-
- if not skip_key_relist:
- self.list_keys_by_depth(devmode=devmode)
-
- # if there is a level_names, check that the
- # new dict is consistent:
- if isinstance(new_dict, ImageDict) and self.level_names is not None:
- if new_dict.level_names is not None:
- if self.level_names != new_dict.level_names:
- raise ValueError('Attempting to append two ImageDict objects with'
- ' different level_names')
-
-[docs] def dict_union(self, in_dict, new_dict):
- 'produces the union of a dictionary of dictionaries'
- for key, val in new_dict.iteritems():
- if not isinstance(val, dict):
- in_dict[key] = val
- else:
- subdict = in_dict.setdefault(key, {})
- self.dict_union(subdict, val)
-
-[docs] def mergedicts(self, dict1, dict2):
- '''
- Alternative version of dict_union using generators which is much faster for large dicts
- but needs to be converted to a dict when it's called:
- new_dict = dict(mergdicts(dict1,dict))
- '''
- for k in set(dict1.keys()).union(dict2.keys()):
- if k in dict1 and k in dict2:
- if isinstance(dict1[k], dict) and isinstance(dict2[k], dict):
- yield (k, dict(self.mergedicts(dict1[k], dict2[k])))
- else:
- # If one of the values is not a dict, you can't continue merging it.
- # Value from second dict overrides one in first and we move on.
- yield (k, dict2[k])
- # Alternatively, replace this with exception raise
- # to alert you of value conflicts
- elif k in dict1:
- yield (k, dict1[k])
- else:
- yield (k, dict2[k])
-
-[docs] def remove(self, rm_dict, skip_key_relist=False):
- '''
- removes a dictionary from within an ImageDict.
- The skip_key_relist option can be set to True to stop the regeneration of key lists.
-
- TIP: Because the remove process needs to prune empty sections afterwards,
- it can be slow. When working with large dictionaries, and removing a large number
- of elements from it, is often faster to build up a dictionary of things you want to
- remove, and then do one remove at the end.
- '''
- # delete the items in question from the dictionary - this can leave
- # empty branches of the dictionary though:
- if isinstance(rm_dict, ImageDict):
- self.dict_remove(self.dict, rm_dict.dict)
- elif isinstance(rm_dict, dict):
- self.dict_remove(self.dict, rm_dict)
- else:
- raise ValueError('Cannot remove data type %s from a ImageDict' % type(rm_dict))
- # now prune empty branches away:
- dicts_to_prune = True
- while dicts_to_prune:
- dicts_to_prune = self.dict_prune(self.dict)
- # relist the keys:
- if not skip_key_relist:
- self.list_keys_by_depth()
-
-[docs] def dict_remove(self, in_dict, rm_dict):
- '''
- removes a dictionary of dictionaries from another, larger, one.
- This can leave empty branches, at multiple levels of the dict,
- so needs cleaning up afterwards.
- '''
- for key, val in rm_dict.iteritems():
- if isinstance(val, dict):
- # descend further up into the dictionary tree structure:
- self.dict_remove(in_dict.setdefault(key, {}), val)
- else:
- # if the key is in the in_dict at this level, remove it:
- if key in in_dict.keys():
- in_dict.pop(key)
-
-[docs] def dict_prune(self, in_dict, dicts_pruned=False):
- '''
- Prunes the ImageDict of empty, unterminated, branches
- (which occur after parts have been removed).
- Returns True if a dict was pruned, False if not.
- '''
- pop_list = []
- for key, val in in_dict.iteritems():
- if isinstance(val, dict):
- # descend further up into the dictionary tree structure:
- if len(val.keys()) > 0:
- dicts_pruned = self.dict_prune(val, dicts_pruned=dicts_pruned)
- else:
- pop_list.append(key)
- dicts_pruned = True
- elif val is None:
- pop_list.append(key)
- dicts_pruned = True
- # now do the prune:
- for key in pop_list:
- in_dict.pop(key)
-
- return dicts_pruned
-
-[docs] def dict_print(self, in_dict, indent=0, outstr=''):
- 'recursively details a dictionary of dictionaries, with indentation, to a string'
- n_spaces = 2 # number of spaces to indent, per level
- # loop over the defined list of keys, to present in them in the current sorted order.
- for key, value in in_dict.iteritems():
- outstr = '%s%s%s:\n' % (outstr, ' '*indent*n_spaces, key)
- if isinstance(value, dict):
- outstr = self.dict_print(value, indent=indent+1, outstr=outstr)
- else:
- outstr = '%s%s%s\n' % (outstr, ' '*(indent+1)*n_spaces, value)
- return outstr
-
-[docs] def dict_depth(self, uniform_depth=False):
- '''
- Uses dict_depths to get the depth of all branches of the plot_dict and,
- if required, checks they all equal the max
- '''
- # get the depth of all trees of the dict, and flatten the list:
- dict_depths = [d for d in self.flatten_lists(self.dict_depths(self.dict))]
- # find the max:
- dict_depth = max(dict_depths)
- # and check its uniformity if required:
- if uniform_depth:
- # check the dictionary depth is uniform_depth for all elements,
- # and raise an error if not
- if len(set(dict_depths)) != 1:
- msg = 'Plot Dictionary has non uniform depth and uniform_depth=True is specified'
- raise ValueError(msg)
- return dict_depth
-
-[docs] def dict_depths(self, in_dict, depth=0):
- 'Recursively finds the depth of a ImageDict and returns a list of lists'
- if not isinstance(in_dict, dict) or not in_dict:
- return depth
- return [self.dict_depths(next_dict, depth+1) for (next_key, next_dict) in in_dict.iteritems()]
-
-[docs] def flatten_lists(self, in_list):
- 'Recursively flattens a list of lists:'
- for list_element in in_list:
- if isinstance(list_element, collections.Iterable) and \
- not isinstance(list_element, basestring):
- for sub_list in self.flatten_lists(list_element):
- yield sub_list
- else:
- yield list_element
-
-[docs] def list_keys_by_depth(self, devmode=False):
- '''
- Lists the keys of the dictionary to create a list of keys, for each level of the
- dictionary, up to its depth.
-
- It is usually much faster to create an ImageDict by appending images to it,
- with skip_key_relist=True but this leaves an ImageDict without a list of keys. In this
- case, list_keys_by_depth needs to be called once at the end of the process to complete
- the list of keys.
-
- It works by converting the sets, from keys_by_depth to a list (where they can be ordered
- and indexed).
- This also produces the unique subdirectory locations of all images.
- '''
- keys, subdirs = self.keys_by_depth(self.dict)
-
- out_keys = {}
- for level in keys.keys():
- # convert to a sorted list:
- out_keys[level] = sorted(list(keys[level]))
-
- self.keys = out_keys
- self.subdirs = sorted(list(subdirs))
- #return out_keys
-
-[docs] def keys_by_depth(self, in_dict, depth=0, keys=None, subdirs=None):
- '''
- Returns:
-
- * a dictionary of sets, containing the keys at each level of\
- the dictionary (keyed by the level number).
- * a set of the subdirectories for the target images
- '''
- if keys is None:
- keys = {}
- subdirs = set([])
- if not depth in keys:
- keys[depth] = set()
- for key in in_dict:
- keys[depth].add(key)
- if isinstance(in_dict[key], dict):
- self.keys_by_depth(in_dict[key], depth+1, keys, subdirs)
- elif isinstance(in_dict[key], list):
- # we have a list of images:
- for img_file in in_dict[key]:
- subdirs.add(os.path.split(img_file)[0])
- elif isinstance(in_dict[key], str):
- # we have the location of a single image;
- subdirs.add(os.path.split(in_dict[key])[0])
- return keys, subdirs
-
-[docs] def key_at_depth(self, in_dict, depth):
- 'returns the keys of a dictionary, at a given depth'
- if depth > 0:
- return [key for subdict in in_dict.itervalues() for key in self.key_at_depth(subdict, depth-1)]
- else:
- return in_dict.keys()
-
-[docs] def return_key_inds(self, in_dict, out_array=None, this_set_of_inds=None,
- depth=None, level=None, verbose=False, devmode=False):
- '''
- Does the work for dict_index_array, by recursively adding indices to
- the keys to a current list, and branching where required, and adding
- compelted lists to the out_array
- '''
- for key, value in in_dict.iteritems():
- if verbose:
- print 'IN: level: %s, before changes: %s, key "%s" in %s' \
- % (level, this_set_of_inds, key, self.keys[level])
-
- if isinstance(value, dict):
- # make a note of which key it is:
-
- if key in self.keys[level]:
- # we've moved up a level from the previous one, make a
- # note of the new value at the new level
- this_set_of_inds[level] = self.keys[level].index(key)
- # increment the level, in case the next dict is at the
- # higher level in the tree structure:
- if level+1 < depth:
- level += 1
- if verbose:
- print 'new setting: %s' % this_set_of_inds
- print 'out_array: %s' % out_array
- # and recurse, to the next level if needed:
- self.return_key_inds(value, out_array=out_array,
- this_set_of_inds=this_set_of_inds,
- depth=depth, level=level, devmode=devmode)
- else:
- out_array.append(deepcopy(this_set_of_inds))
-
- elif key in self.keys[level-1]:
- # the dictionary we've now got isn't at a higher level than before, which means
- # we're traversing the level from the previous call.
- # record the new index on a copy, and then recursively carry on:
- branched_level = deepcopy(level)
- branched_set_of_inds = deepcopy(this_set_of_inds)
- branched_set_of_inds[branched_level-1] = self.keys[branched_level-1].index(key)
- if verbose:
- print 'new setting: %s' % this_set_of_inds
- print 'out_array: %s' % out_array
- # and recurse:
- self.return_key_inds(value, out_array=out_array,
- this_set_of_inds=branched_set_of_inds,
- depth=depth, level=branched_level,
- devmode=devmode)
-
- else:
- # we really shouldn't be here:
- msg = 'Error recursing through dict: key "%s"' % key
- msg += ' not found in this level, or one below'
- raise ValueError(msg)
- #elif isinstance(value, dict) and level == depth:
- #
- # pdb.set_trace()
- else:
- # we're at the top level of the tree, as far as we can or want to go,
- # so record the index:
- if key in self.keys[level]:
- # we've moved up a level from the previous one,
- # make a note of the new value at the new level
- this_set_of_inds[level] = self.keys[level].index(key)
- #elif level == 0:
- # # wer're traversing the top level of the dictionary, so
- # # level has been set to zero:
- # this_set_of_inds[-1] = self.keys[depth-1].index(key)
- else:
- # again, we shouldn't ever get here:
- if devmode:
- pdb.set_trace() #@@@
- print 'stop here' #@@@
- else:
- msg = 'Error recursing through the plot dictionary: '
- msg += 'key not found in top level!'
- raise ValueError(msg)
-
- # we're done, so append this to the out_array, and DON'T recurse:
- out_array.append(deepcopy(this_set_of_inds))
-
-[docs] def dict_index_array(self, devmode=False, maxdepth=None, verbose=False):
- '''
- Using the list of dictionary keys (at each level of a uniform_depth dictionary
- of dictionaries), this produces a list of the indices that can be used to reference
- the keys to get the result for each element.
-
- Options:
- * maxdepth - the maximum desired depth to go to (ie. the number of levels)
- '''
- # want to build up a list of lists, each giving the indices of the keys that get to a plot:
- out_array = []
- if maxdepth is None:
- depth = self.dict_depth(uniform_depth=True)
- this_set_of_inds = [None] * depth
- else:
- depth=maxdepth
- this_set_of_inds = [None] * depth
- level = 0
- self.return_key_inds(self.dict, out_array=out_array,
- this_set_of_inds=this_set_of_inds, depth=depth,
- level=level, devmode=devmode, verbose=verbose)
- # the recursive method comes out sorted as it iterates about the dictionary,
- # not as to how the keys are sorted. Easy to do:
- out_array.sort()
-
- return (self.keys, out_array)
-
-[docs] def sort_keys(self, sort_methods, devmode=False):
- '''
- Sorts the keys of a plot dictionary, according to a particular sort method
- (or a list of sort methods that matches the number of keys).
-
- Valid sort methods so far are mostly focused on meteorological terms, and include:
- * 'sort' - just an ordinary sort
- * 'level' or 'numeric' - starting with the surface and working upwards, then \
- 'special' levels like cross sections etc.
- * 'T+' - in ascending order of the number after a T+ (or similar) string.
- * an input list - Specific elements in the input list are sorted as per their order\
- in the list, while the rest are just sorted.
-
- The methods activated by a string can be reversed as 'reverse_sort' or 'reverse_sort',
- or 'reverse numeric' or 'reverse_numeric'.
- '''
-
- if len(sort_methods) != len(self.keys):
- raise ValueError('inconsistent lengths of the sort_methods and the self.keys to sort')
-
- for i_key, method in enumerate(sort_methods):
- if isinstance(method, str):
- # the method is a specified way of sorting:
- if method in ['sort', 'alphabetical']:
- # - just alphanumeric style sort.
- self.keys[i_key].sort()
-
- elif method in ['reverse sort', 'reverse_sort']:
- # -a reversed sort
- self.keys[i_key].sort(reverse=True)
-
- elif method in ['T+', 'reverse T+', 'reversed_T+']:
- #'T+' - in ascending order of the T+??? number:
-
- # get a list of tuples, containing the string, and the value
- # of the T+ from a pattern match regex:
- try:
- labels_and_values = [(x, re.match('[tT][+]{,}([0-9.]{1,})|None', x).group(1)) for x in self.keys[i_key]]
- if method == 'T+':
- # map the None to a string, so it goes to then end of a sort
- labels_and_values = [(x, float(y)) if not y is None else (x, 'None') for x, y in labels_and_values]
- elif method in ['reverse T+', 'reversed_T+']:
- # don;t map the none to a string, so it goes to the
- # end of a reversed sort...
- labels_and_values = [(x, float(y)) if not y is None else (x, y) for x, y in labels_and_values]
- except:
- msg = 'Keys for plot dictionary level "%s" ' % self.keys[i_key]
- msg += 'do not match the "T+" (or None) pattern'
- if devmode:
- print msg
- pdb.set_trace()
- print 'stop'
- else:
- raise ValueError(msg)
-
- # now either sort, or reverse sort, using the value as the key:
- if method == 'T+':
- labels_and_values.sort(key=lambda x: x[1])
- elif method in ['reverse T+', 'reversed_T+']:
- labels_and_values.sort(key=lambda x: x[1], reverse=True)
- # and pull out the labels, in the right order:
- self.keys[i_key] = [x[0] for x in labels_and_values]
-
- elif method in ['level', 'numeric', 'reverse_level', 'reverse_numeric']:
- #'level' - starting with the surface and working upwards, then 'special'
- # levels like cross sections etc.
-
- # add to this as keys from self.keys[i_key] are added to it:
- tmp_keys = []
-
- # the surface levels go first:
- surface_levels = ['Surface']
- for item in surface_levels:
- if item in self.keys[i_key]:
- tmp_keys.append(self.keys[i_key].pop(self.keys[i_key].index(item)))
- if len(self.keys[i_key]) == 0:
- break
-
- # now anything with a 'm' or 'km' or 'nm' (for wavelenghts!) needs
- # to be sorted, starting with the lowest:
- # TODO: add more things to this, microns, with the micro as /mu????
- metre_patterns_and_scalings = [(r'([0-9.eE+-]{1,})[\s]{,}m$', 1.0),
- (r'([0-9.eE+-]{1,})[\s]{,}mm$', 1.0-3),
- (r'([0-9.eE+-]{1,})[\s]{,}microns$', 1.0-6),
- (r'([0-9.eE+-]{1,})[\s]{,}\mum$', 1.0-6),
- (r'([0-9.eE+-]{1,})[\s]{,}nm$', 1.0e-9),
- (r'([0-9.eE+-]{1,})[\s]{,}km$', 1000.0)]
-
- # now anything with a 'hPa' or 'mb' needs to be sorted, starting
- # with the lowest in height (hieghest value):
- pressure_patterns_and_scalings = [(r'([0-9.eE+-]{1,})[\s]{,}Pa$', 1.0),
- (r'([0-9.eE+-]{1,})[\s]{,}mb$', 100.0),
- (r'([0-9.eE+-]{1,})[\s]{,}mbar$', 100.0),
- (r'([0-9.eE+-]{1,})[\s]{,}hPa$', 100.0)]
-
- model_lev_patterns_and_scalings = [(r'Model level ([0-9]{1,})', 1.0),
- (r'model level ([0-9]{1,})', 1.0),
- (r'Model lev ([0-9]{1,})', 1.0),
- (r'model level ([0-9]{1,})', 1.0),
- (r'ML([0-9]{1,})', 1.0),
- (r'ml([0-9]{1,})', 1.0)]
-
- # now anything where the level defines locations, with latt long coordinates:
- lattlong_patterns_and_scalings = [('([0-9.]{1,})[E][,\s]{,}[0-9.]{1,}[NS]', 1.0),
- ('([0-9.]{1,})[W][,\s]{,}[0-9.]{1,}[NS]', -1.0)]
-
- # now anything else with a numeric value:
- numeric_patterns_and_scalings = [(r'([0-9.eE+-]{1,})', 1.0)]
-
- # now loop through the different patterns/scalings, and their orders:
- if method.startswith('reverse'):
- pattern_order_loop = [(metre_patterns_and_scalings, 'reversed'),
- (pressure_patterns_and_scalings, 'sort'),
- (model_lev_patterns_and_scalings, 'reversed'),
- (lattlong_patterns_and_scalings, 'reversed'),
- (numeric_patterns_and_scalings, 'reversed')]
- else:
- pattern_order_loop = [(metre_patterns_and_scalings, 'sort'),
- (pressure_patterns_and_scalings, 'reversed'),
- (model_lev_patterns_and_scalings, 'sort'),
- (lattlong_patterns_and_scalings, 'sort'),
- (numeric_patterns_and_scalings, 'sort')]
-
- for patterns_scalings, sort_method in pattern_order_loop:
- labels_and_values = []
- for item in self.keys[i_key]:
- for pattern, scaling in patterns_scalings:
- item_match = re.match(pattern, item)
- if item_match:
- # add the label and value to the list:
- if devmode:
- try:
- _ = float(item_match.group(1)) * scaling
- except:
- pdb.set_trace()
- print 'unable to convert item "%s" with pattern "%s" to float' % (item, pattern)
- labels_and_values.append((item, float(item_match.group(1)) * scaling))
- break
- # now sort the labels_and_values, according to the value:
- if sort_method == 'sort':
- labels_and_values.sort(key=lambda x: x[1])
- elif sort_method == 'reversed':
- labels_and_values.sort(key=lambda x: x[1], reverse=True)
- else:
- raise ValueError('Unrecognised sort_method "%s"' % sort_method)
- # add the labels to the tmp_keys and remove them from the self.keys[i_key]:
- for item, scaling in labels_and_values:
- tmp_keys.append(item)
- self.keys[i_key].pop(self.keys[i_key].index(item))
-
-
- # now sort what's left:
- self.keys[i_key].sort()
-
- # and put the tmp_keys at the start of it:
- self.keys[i_key] = tmp_keys + self.keys[i_key]
-
-
- elif isinstance(method, list):
- # the input list should be a list of strings, which give the priority contents
- # to be put at the start of the list. The remaining items are sorted normally:
- # - specific model names get to the top, the rest are alphaebetical
-
- # add to tmp_keys as we go, by popping elements from the main list:
- tmp_keys = []
- # this sets the order of the model names (names not in this list are alphabetical):
- for item in method:
- if item in self.keys[i_key]:
- tmp_keys.append(self.keys[i_key].pop(self.keys[i_key].index(item)))
- if len(self.keys[i_key]) == 0:
- break
- # now sort the remaining keys alphabetically:
- self.keys[i_key].sort()
- # and put the tmp_keys back in at the start:
- self.keys[i_key] = tmp_keys + self.keys[i_key]
-
-[docs] def copy_except_dict_and_keys(self):
- 'returns a copy of an ImageDict except it will have null values for the dict and keys'
- out_imgdict = ImageDict({'null': None})
- for mem_name, mem_value in inspect.getmembers(self):
- if mem_name.startswith('__'):
- pass
- elif mem_name in ['dict', 'keys']:
- pass
- elif inspect.ismethod(eval('self.%s' % mem_name)):
- pass
- else:
- setattr(out_imgdict, mem_name, mem_value)
-
- return out_imgdict
-
-[docs] def return_from_list(self, vals_at_depth):
- '''
- Returns the end values of ImageDict, when given a list of values for the keys
- at different depths.
- Returns None if the set of values is not contained in the ImageDict.
-
- Assumes that the ImageDict has its keys up to date, so last time it was
- appended/removed it was with skip_key_relist=False or list_keys_by_depth()
- method has been called since.
- '''
-
- if not isinstance(vals_at_depth, list):
- raise ValueError('Input vals_at_depth should be a list')
- dict_depth = len(self.keys)
- if len(vals_at_depth) > dict_depth:
- msg = 'Length of input list, vals_at_depth, greater than the length of the keys list'
- raise ValueError(msg)
-
- if vals_at_depth[0] not in self.keys[0]:
- return None
- else:
- sub_dict = self.dict[vals_at_depth[0]]
-
- for depth in range(1, len(vals_at_depth)):
- if vals_at_depth[depth] in sub_dict:
- sub_dict = sub_dict[vals_at_depth[depth]]
- else:
- return None
- return sub_dict
-
-
-[docs]def readmeta_from_image(img_file, img_format=None):
- '''Reads the metadata added by the ImageMetaTag savefig, from an image file,
- and returns a dictionary of *tagname: value* pairs'''
-
- if img_format is None:
- # get the img_format from the end of the filename
- _, img_format = os.path.splitext(img_file)
- if img_format is None or img_format == '':
- msg = 'Cannot determine file img_format to read from filename "%s"' % img_file
- raise ValueError(msg)
- # get rid of the . to be consistent throughout
- img_format = img_format[1:]
- else:
- if img_format.startswith('.'):
- img_format = img_format[1:]
-
- # how we read in the metadata depends on the format:
- if img_format == 'png':
- try:
- img_obj = Image.open(img_file)
- img_info = img_obj.info
- read_ok = True
- except:
- # if anthing goes wrong, then read_ok is False and img_info None
- read_ok = False
- img_info = None
- else:
- msg = 'Currently, ImageMetaTag does not support "%s" format images' % img_format
- raise NotImplementedError(msg)
-
- return (read_ok, img_info)
-
-[docs]def dict_heirachy_from_list(in_dict, payload, heirachy):
- '''
- Converts a flat dictionary of *tagname: value* pairs, into an ordered dictionary
- of dictionaries according to the input heirachy (which is a list of tagnames).
-
- The output dictionary will only have one element per level, but can be used to create or
- append into an :class:`ImageMetaTag.ImageDict`.
- The final level will be the 'payload' input, which is the object the dictionary, with all
- it's levels, is describing.
- The payload would usually be the full/relative path of the image file, or list of image files.
-
- Returns False if the input dict does not contain the required keys.
- '''
- for level in heirachy:
- if not level in in_dict.keys():
- return False
-
- out_dict = {in_dict[heirachy[-1]]: payload}
- for level in heirachy[-2::-1]:
- out_dict = {in_dict[level]: out_dict}
- return out_dict
-
-
-[docs]def dict_split(in_dict, n_split=None, size_split=None, extra_opts=None):
- '''
- Generator that breaks up a flat dictionary and yields a set of sub-dictionaries in
- n_split chunks, or size_split in size. It is split on it's first level, not recursively.
-
- It is very useful for splitting large dictionaries of image metadata
- to parallelise processing these into ImageDicts.
-
- Inputs:
- in_dict - the dictionary to split
-
- Options:
-
- * n_split - the number of dictionaries to break the in_dict up into.
- * size_split - the size of the required output dictionaries.
- * extra_opts - If supplied as an iterable, this routine will yield a tuple containing the \
- output sub-dictionary and then each of the elements of extra_opts.
-
- .. note:: One, and only one, of n_slpit, or size_split must be specified, as an integer.
-
- '''
-
- if not isinstance(in_dict, dict):
- raise ValueError('Input in_dict is not a dictionary')
-
- if len(in_dict) == 0:
- # an empty dict needs to output an empty dict, possiblty with the
- # extra options:
- out_dict = {}
- if extra_opts is None:
- yield out_dict
- else:
- # yield a tuple containing the output dictionary, plus all the extra options,
- # as elements in a tuple:
- out_tuple = (out_dict, )
- for opt in extra_opts:
- out_tuple = out_tuple + (opt,)
- yield out_tuple
- else:
- if size_split is None and isinstance(n_split, int):
- if n_split < 1:
- raise ValueError('Cannot split a dictionary into less than 1 dictionary')
- # work out the size of a split - the last dict can be smaller than the others:
- size_split = int(ceil(len(in_dict) / float(n_split)))
- elif isinstance(size_split, int) and n_split is None:
- # do nothing, use the input size_split
- pass
- else:
- msg = 'One, and only one, of n_slpit, or size_split must be specified, as an integer.'
- raise ValueError(msg)
-
- iterdict = iter(in_dict)
- for i in xrange(0, len(in_dict), size_split):
-
- out_dict = {k:in_dict[k] for k in islice(iterdict, size_split)}
-
- if extra_opts is None:
- yield out_dict
- else:
- # yield a tuple containing the output dictionary, plus all the extra options,
- # as elements in a tuple:
- out_tuple = (out_dict, )
- for opt in extra_opts:
- out_tuple = out_tuple + (opt,)
-
- yield out_tuple
-
-
-
-[docs]def simple_dict_filter(simple_dict, tests, raise_key_mismatch=False):
- '''
- Tests the contents of a simple, un-heirachical dict (properties an image) against
- a set of tests.
-
- An example set of tests:
- tests = {'number of rolls': ['6 simulated rolls', '216 simulated rolls', '1296 simulated rolls'],\
- 'plot color': None,\
- 'image compression': None,\
- 'plot type': ['Histogram', ('All', ['Histogram', 'Line plots'])],\
- 'image trim': None}
- Here, the 'number of rolls' is restricted to a simple list.
-
- The plot type is filtered according to 'Histogram', and there is also a second element that
- contains both 'Histogram and 'Line plots' which are to be presented together.
-
- The other image characteristics are not filtered.
-
- Options:
-
- * raise_key_mismatch - if True, then attempting to test a dictionary with a missing key \
- will raise. Default is to return all False
-
- Returns three logicals:
-
- * The first indicates whether the input dict passes the simple tests
- * The second indicates whether the input dict is part of the grouped elements \
- of the test (the ['Histogram', 'Line plots'] list).#
- * The third indicates whether the input dict is the first element of a list grouped \
- elements (is 'Histogram' in this ['Histogram', 'Line plots'] list).
-
- '''
- # this is set to False if the input dict fails the simple criteria:
- passes_tests = True
- # this stores all of the tests:
- passes = [True] * len(tests)
- # this stores if it passes and if the test is complex, this image is first:
- passes_and_first = [True] * len(tests)
-
- # the input tests can also contain a tuple that define how multiple
- # images can be grouped together:
- has_complex_test = False
- if not tests is None:
- for i_test, test in enumerate(tests.keys()):
- if tests[test] is None:
- # None here means no filter is applied:
- pass
- else:
- if not test in simple_dict.keys():
- msg = 'Specified filter test "%s" not a property of the input dict "%s"' \
- %(test, simple_dict)
- if raise_key_mismatch:
- raise ValueError(msg)
- else:
- print msg
- return (False, False, False)
- if isinstance(tests[test], list):
- # simple test, does it meet the normal criteria:
- # now check to see if the test includes a tuple, marking out a complex
- # multi-element list:
- test_is_tuple = [isinstance(x, tuple) for x in tests[test]]
- if any(test_is_tuple):
- has_complex_test = True
-
- # now loop through all of the tuples within the test:
- any_tuple_passes = False
- # this marks whether it is the FIRST element in a tuple (and so the one that
- # would typically be used for processing a set of images)
- first_tuple_passes = False
- tuple_tests = compress(tests[test], test_is_tuple)
- for tuple_test in tuple_tests:
- if simple_dict[test] in tuple_test[1]:
- # failed this test, so it counts as a failure:
- any_tuple_passes = True
- # and is this the first element in the tuple:
- if simple_dict[test] == tuple_test[1][0]:
- first_tuple_passes = True
-
- # if none of the tuple tests pass, then make a note of that:
- if not any_tuple_passes:
- passes[i_test] = False
- passes_and_first[i_test] = False
- elif not first_tuple_passes:
- # and make a note if this wasn't first:
- passes_and_first[i_test] = False
-
- # also apply a test in the simple case:
- if not simple_dict[test] in tests[test]:
- passes_tests = False
- else:
- # no complex test for this test, just the simlpe one:
- if not simple_dict[test] in tests[test]:
- passes_tests = False
- passes[i_test] = False
- passes_and_first[i_test] = False
-
- else:
- msg = 'Test values should be specified as lists'
- raise ValueError(msg)
-
- if has_complex_test:
- # for the complex test, all tests need to be passed as well as the complex case:
- passes_complex_test = all(passes)
- passes_and_first = all(passes_and_first)
- else:
- passes_complex_test = False
- passes_and_first = False
-
- return (passes_tests, passes_complex_test, passes_and_first)
-
-
-[docs]def check_for_required_keys(img_info, req_keys):
- '''
- Checks an img_info dictionary has a set of required keys, specifed as a list of strings
-
- Returns True or False accordingly.
- '''
- for key in req_keys:
- if key not in img_info.keys():
- return False
- return True
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/docs/build/html/_modules/ImageMetaTag/savefig.html b/docs/build/html/_modules/ImageMetaTag/savefig.html
deleted file mode 100644
index df9221f..0000000
--- a/docs/build/html/_modules/ImageMetaTag/savefig.html
+++ /dev/null
@@ -1,589 +0,0 @@
-
-
-
-
-
-
-
- ImageMetaTag.savefig — ImageMetaTag 0.6.4 documentation
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Source code for ImageMetaTag.savefig
-'''
-This module contains a wrapper for matplotlib.pyplot.savefig. The primary function of the wrapper
-is to add image metadata taggging and database storage of that metadata.
-
-As the output images are already being post-processed to add the metadata, basic image
-manipulation options are included to crop images, add logos and reduce their file size
-by simplifying their colour palette.
-
-.. moduleauthor:: Malcolm Brooks https://github.com/malcolmbrooks
-'''
-
-import os, sys, io, sqlite3, pdb
-import matplotlib.pyplot as plt
-from datetime import datetime
-
-from ImageMetaTag import db, META_IMG_FORMATS, POSTPROC_IMG_FORMATS
-from ImageMetaTag import DEFAULT_DB_TIMEOUT, DEFAULT_DB_ATTEMPTS
-
-# image manipulations:
-from PIL import Image, ImageChops, PngImagePlugin#, ImageFilter
-import numpy as np
-
-THUMB_DEFAULT_IMG_SIZE = 150, 150
-THUMB_DEFAULT_DIR_NAME = 'thumbnail'
-
-[docs]def savefig(filename, img_format=None, img_converter=0, do_trim=False, trim_border=0,
- do_thumb=False, img_tags=None, keep_open=False, dpi=None,
- logo_file=None, logo_width=40, logo_padding=0, logo_pos=0,
- db_file=None, db_timeout=DEFAULT_DB_TIMEOUT, db_attempts=DEFAULT_DB_ATTEMPTS,
- db_full_paths=False,
- verbose=False, ):
- '''
- A wrapper around matplotlib.pyplot.savefig, to include file size optimisation and
- image tagging.
-
- The filesize optimisation depends on the img_converter input passes into
- :func:`ImageMetaTag.image_file_postproc`.
-
- Args:
- filename (can include the file extension, or that can be specified in the img_format option)
-
- Options:
-
- * img_format - file format of the image. If not supplied it will be guessed from the filename.\
- Currently only the png file format is supported for tagging/conversion.
- * img_tags - a dictionary of {tag_name : value} pairs to be added to the image metadata.
- * db_file - a database file to be used by :func:`ImageMetaTag.db.write_img_to_dbfile` to \
- store all image metadata so they can be quickly accessed.
- * db_full_paths - by default, if the images can be expressed as relative path to the database \
- file then the database will contain only relative links, unless \
- db_full_paths is True.
- * db_timeout - change the database timeout (in seconds).
- * db_attempts - change the number of attempts to write to the database.
- * dpi - change the image resolution passed into matplotlib.savefig.
- * keep_open - by default, this savefig wrapper closes the figure after use, except if \
- keep_open is True.
- * verbose - switch for verbose output (reports file sizes before/after conversion)
- * img_converter - see :func:`ImageMetaTag.image_file_postproc`.
- * do_trim - see :func:`ImageMetaTag.image_file_postproc`.
- * trim_border - see :func:`ImageMetaTag.image_file_postproc`.
- * logo_file - see :func:`ImageMetaTag.image_file_postproc`.
- * logo_width - see :func:`ImageMetaTag.image_file_postproc`.
- * logo_padding - see :func:`ImageMetaTag.image_file_postproc`.
- * logo_pos - see :func:`ImageMetaTag.image_file_postproc`.
- * do_thumb - see :func:`ImageMetaTag.image_file_postproc`.
-
- TODO: the logo would also be good if it could accept a list of files, widths,
- positions and paddings. That way different logos could be added to the top left and top
- right corner, for instance.
-
- '''
-
- if img_format is None:
- write_file = filename
- # get the img_format from the end of the filename
- _, img_format = os.path.splitext(filename)
- if img_format is None or img_format == '':
- msg = 'Cannot determine file img_format to save from filename "%s"' % filename
- raise ValueError(msg)
-
- # get rid of the . to be consistent throughout
- img_format = img_format[1:]
- else:
- if img_format.startswith('.'):
- img_format = img_format[1:]
- write_file = '%s.%s' % (filename, img_format)
-
-
- # Where to save the figure to? If we're going to postprocess it, save to memory
- # for speed and to cut down on IO load:
- do_any_postproc = img_format in META_IMG_FORMATS or img_format in POSTPROC_IMG_FORMATS
- if do_any_postproc:
- buf = io.BytesIO()
- savefig_file = buf
- else:
- savefig_file = write_file
- buf = None
-
- # should probably add lots of other args, or use **kwargs
- if dpi:
- plt.savefig(savefig_file, dpi=dpi)
- else:
- plt.savefig(savefig_file)
- if not keep_open:
- plt.close()
- if buf:
- # need to go to the start of the buffer, if that's where it went:
- buf.seek(0)
-
- if img_format in META_IMG_FORMATS:
- use_img_tags = img_tags
- else:
- use_img_tags = None
-
- if verbose:
- postproc_st = datetime.now()
-
- if img_format in POSTPROC_IMG_FORMATS:
- image_file_postproc(write_file, img_buf=buf, img_converter=img_converter, do_trim=do_trim,
- trim_border=trim_border, logo_file=logo_file, logo_width=logo_width,
- logo_padding=logo_padding, logo_pos=logo_pos,
- do_thumb=do_thumb, img_tags=use_img_tags, verbose=verbose)
- else:
- msg = 'Currently, ImageMetaTag does not support "%s" format images' % img_format
- raise NotImplementedError(msg)
-
- # image post-processing completed, so close the buffer if we opened it:
- if buf:
- buf.close()
- if verbose:
- print 'Image post-processing took: %s' %(str(datetime.now() - postproc_st))
-
-
- # now write to the database, if it is specifed:
- if not (db_file is None or img_tags is None):
- if verbose:
- db_st = datetime.now()
-
- # if the image path can be expressed as a relative path compared
- # to the database file, then do so (unless told otherwise).
- db_dir = os.path.split(db_file)[0]
- if filename.startswith(db_dir) and not db_full_paths:
- db_filename = os.path.relpath(filename, db_dir)
- else:
- db_filename = filename
-
- wrote_db = False
- n_tries = 1
- while not wrote_db and n_tries <= db_attempts:
- try:
- db.write_img_to_dbfile(db_file, db_filename, img_tags, timeout=db_timeout)
- wrote_db = True
- except sqlite3.OperationalError as OpErr:
- if 'database is locked' in OpErr.message:
- # database being locked is what the retries and timeouts are for:
- print '%s database timeout for image "%s", writing to file "%s", %s s' \
- % (db.dt_now_str(), db_file, write_file, n_tries * db_timeout)
- n_tries += 1
- else:
- # everything else needs to be reported and raised immediately:
- msg = '{} for file {}'.format(OpErr.message, db_file)
- raise sqlite3.OperationalError(msg)
- except:
- raise
- if n_tries > db_attempts:
- raise sqlite3.OperationalError(OpErr.message)
- if verbose:
- print 'Database write took: %s' %(str(datetime.now() - db_st))
-
-[docs]def image_file_postproc(filename, outfile=None, img_buf=None, img_converter=0, do_trim=False, trim_border=0,
- logo_file=None, logo_width=40, logo_padding=0, logo_pos=0,
- do_thumb=False, img_tags=None, verbose=False):
- '''
- Does the image post-processing for :func:`ImageMetaTag.savefig`.
-
- Arguments: filename the name of the image file to process
-
- Options:
-
- * outfile - If supplied, the processing will be applied to a new file, with this name. \
- If not supplied, the post processing will overwrite the file given input file.
- * img_buf - If the image has been saved to an in-memory buffer, then supply the image buffer \
- here. This will speed up the post-processing.
- * img_converter - an integer switch controlling the level of file size compression
- * 0 - no compression
- * 1 - light compression, from RGBA to RGB
- * 2 - moderate compression, from RGBA to RGB, then to an adaptive 256 colour \
- palette.
- * 3 - heavy compression, from RGBA to RGB, then to 8-bit web standard palette.
- * do_trim - switch to trim whitespace from the edge of the image
- * trim_border - if do_trim then this can be used to define an integer number of pixels as a \
- border around the trim.
- * logo_file - a file to use as a logo, to be added to the image
- * logo_width - the desired width of the logo, in pixels. If the supplied image file is not \
- the right size, it will be resized using a method that applies filters and \
- antialiasing that works well for shrinking images with text to a much \
- smaller size. The aspect ratio of the logo image is always maintained. \
- Defaults to 40 pixels.
- * logo_padding - a number of pixels to pad around the logo (default to zero)
- * logo_pos - corner position of the logo (following pyplot.legend, but for corners):
- * 0: 'best' in this context will be upper left (default)
- * TODO: 1: 'upper right'
- * 2: 'upper left'
- * TODO: 3: 'lower left'
- * TODO: 4: 'lower right'
- * do_thumb - switch to produce default sized thumbnail, or integer/tuple to define the \
- maximum size in pixels
- * img_tags: a dictionary of tags to be added to the image metadata
- * verbose: switch for verbose output (reports file sizes before/after conversion)
- '''
-
- # usually, this is used to overwrite a file, but an outfile can be specified:
- if not outfile:
- outfile = filename
-
- if verbose:
- if img_buf:
- st_fsize = int(sys.getsizeof(img_buf))
- else:
- st_fsize = os.path.getsize(filename)
-
- if not (img_tags is None or isinstance(img_tags, dict)):
- raise ValueError('Image tags must be supplied as a dictionary')
-
- if not img_converter in range(4):
- raise ValueError('Unavailable method for image conversion')
-
- # do_thumb should equate to integer type or be a tuple of integers
- #
- # this test is taking advantage of the isinstance(do_thumb, tutple) being true before testing
- # the contents of do_thumb.
- # Also that as a bool, do_thumb also passes isinstance(do_thumb, int).
- if not isinstance(do_thumb, int) or (isinstance(do_thumb, tuple)
- and isinstance(do_thumb[0], int)
- and isinstance(do_thumb[1], int)):
- raise ValueError('Invalid thumbnail size')
-
- # do we do any image modification at all?
- modify = do_trim or do_thumb or img_tags or img_converter > 0 or logo_file is not None
-
- if img_buf:
- # if the image is in a buffer, then load it now
- im_obj = Image.open(img_buf)
- if not modify:
- # if we're not doing anyhting, then save it:
- im_obj.save(outfile, optimize=True)
- else:
- if modify:
- # use the image library to open the file:
- im_obj = Image.open(filename)
-
- if do_trim:
- # call the _im_trim routine defined above:
- im_obj = _im_trim(im_obj, border=trim_border)
-
- if logo_file is not None:
- im_obj = _im_logo(im_obj, logo_file, logo_width, logo_padding, logo_pos)
-
- if do_thumb:
- # make a thumbnail image here, if required. It is important to do this
- # before we change the colour pallette of the main image, so that there
- # are sufficent colours to do the interpolation. Afterwards, the thumbnail
- # can hage its colour table reduced as well.
- #
- # set a default thumbnail directory name and determine relative paths
- thumb_dir_name = THUMB_DEFAULT_DIR_NAME
- thumb_directory = os.path.join(os.path.split(outfile)[0], thumb_dir_name)
- thumb_full_path = os.path.join(thumb_directory, os.path.split(outfile)[1])
- # create thumbnail directory if one does not exist
- if not os.path.isdir(thumb_directory):
- os.mkdir(thumb_directory)
- # set to default thumbnail size if no size specified
- if do_thumb is True:
- do_thumb = THUMB_DEFAULT_IMG_SIZE
- # check input
- elif not isinstance(do_thumb, tuple):
- do_thumb = (do_thumb, do_thumb)
- # create the thumbnail
- im_thumb = im_obj.copy()
- im_thumb.thumbnail(do_thumb, Image.ANTIALIAS)
-
- # images start out as RGBA, strip out the alpha channel first by covnerting to RGB,
- # then you convert to the next format (that's key to keeping image quality, I think):
- if img_converter == 1:
- # this is a good quality image, but not very much smaller:
- im_obj = im_obj.convert('RGB')
- if do_thumb:
- im_thumb = im_thumb.convert('RGB')
- elif img_converter == 2:
- # second conversion to 8-bit 'P', palette mode with an adaptive palette.
- # works well for line plots.
- im_obj = im_obj.convert('RGB').convert('P', palette=Image.ADAPTIVE, colors=256)
- if do_thumb:
- im_thumb = im_thumb.convert('RGB').convert('P', palette=Image.ADAPTIVE, colors=256)
- elif img_converter == 3:
- # this is VERY strong optimisation and the result can be speckly.
- im_obj = im_obj.convert('RGB').convert('P', palette=Image.WEB)
- if do_thumb:
- im_thumb = im_thumb.convert('RGB').convert('P', palette=Image.WEB)
-
- if do_thumb:
- # now save the thumbnail:
- if img_tags:
- # add the tags
- im_thumb = _im_add_png_tags(im_thumb, img_tags)
- # and save with metadata
- _im_pngsave_addmeta(im_thumb, thumb_full_path,
- optimize=True, verbose=verbose)
- # set a thumbnail directory tag for the main image
- img_tags.update({'thumbnail directory' : thumb_dir_name})
- else:
- # simple save
- im_thumb.save(thumb_full_path, optimize=True)
-
- # now save the main image:n
- if img_tags:
- # add the tags
- im_obj = _im_add_png_tags(im_obj, img_tags)
- # and save with metadata
- _im_pngsave_addmeta(im_obj, outfile, optimize=True, verbose=verbose)
- elif modify:
- # simple save
- im_obj.save(outfile, optimize=True)
-
- if verbose:
- # now report the file size change:
- en_fsize = os.path.getsize(outfile)
- msg = 'File: "{}". Size: {}, to {} bytes ({}% original size)'
- relative_size = (100.0 * en_fsize)/st_fsize
- print msg.format(filename, st_fsize, en_fsize, relative_size)
-
-def _im_trim(im_obj, border=0):
- 'Trims an image object using Python Image Library'
- if not isinstance(border, int):
- msg = 'Input border must be an int, but is %s, %s instead' %(border, type(border))
- raise ValueError(msg)
- # make a white background:
- backg = Image.new(im_obj.mode, im_obj.size, im_obj.getpixel((0, 0)))
- # do an image difference:
- diff = ImageChops.difference(im_obj, backg)
- # add it together
- diff = ImageChops.add(diff, diff, 1.0, -100)
- # and see what the bbox is of that...
- bbox = diff.getbbox()
-
- if border != 0:
- border_bbox = [-border, -border, border, border]
- # now apply that trim:
- bbox_tr = [x+y for x, y in zip(bbox, border_bbox)]
-
- # bbox defines the first corner as top+left, then the second corner as bottom+right
- # (not the bottom left corner, and the width, height from there)
- if bbox_tr[0] < 0:
- bbox_tr[0] = 0
- if bbox_tr[1] < 0:
- bbox_tr[1] = 0
- if bbox_tr[2] > im_obj.size[0]:
- bbox_tr[2] = im_obj.size[0]
- if bbox_tr[3] > im_obj.size[1]:
- bbox_tr[3] = im_obj.size[1]
- # now check to see if that's actually foing to do anything:
- if bbox_tr == [0, 0, im_obj.size[0], im_obj.size[1]]:
- bbox = None
- else:
- bbox = bbox_tr
-
- if bbox:
- # crop:
- return im_obj.crop(bbox)
- else:
- return im_obj
-
-def _im_logo(im_obj, logo_file, logo_width, logo_padding, logo_pos):
- 'adds a logo to the required corner of an image object (usually after an im_trim)'
-
- # load in the logo file image:
- logo_obj = Image.open(logo_file)
- # rescale to the new width and height:
- if logo_width != logo_obj.size[0]:
- logo_height = int(logo_obj.size[1] * float(logo_width) / logo_obj.size[0])
- res_logo_obj = _img_stong_resize(logo_obj, size=(logo_width, logo_height))
- else:
- res_logo_obj = logo_obj
-
- # TODO: this is written for putting a logo in the top-left corner, but could be extended:
- if logo_pos in [0, 2]:
-
- # now pull out a sub image from the main image, that's just where the logo would go,
- # it it were this is the size we want to have blank, to put the logo, including padding:
- req_logo_size = [x + 2*logo_padding for x in res_logo_obj.size]
-
- corner_obj = im_obj.crop((0, 0, req_logo_size[0], req_logo_size[1]))
- #
- # now get a bounding box as though we were trimming this image:
- backg = Image.new(corner_obj.mode, corner_obj.size, corner_obj.getpixel((0, 0)))
- # do an image difference:
- diff = ImageChops.difference(corner_obj, backg)
- # add it together
- diff = ImageChops.add(diff, diff, 1.0, -100)
- # and see what the bbox is of that...
- bbox = diff.getbbox()
-
-# # get the offset in x and y:
-# if bbox is None:
-# # the corner object is empty so no need to offset:
-# offsets = (0,0)
-# else:
-# offsets = (req_logo_size[0] - bbox[0], req_logo_size[1] - bbox[1])
-# # but you only ever need to offset in one direction (the shortest one):
-# offset = min(offsets)
-# offset_ind = offsets.index(offset)
-
- # as this is the top left corner of a plot, the logo should be offset only
- # in x (so the title is still at the top)
- if bbox is None:
- # the corner object is empty so no need to offset:
- offset = 0
- else:
- offset = req_logo_size[0] - bbox[0]
- offset_ind = 0
-
-
- # now put that together to make an image:
-
- # create the blank image:
- new_size = list(im_obj.size)
- new_size[offset_ind] += offset
- new_obj = Image.new(im_obj.mode, new_size, im_obj.getpixel((0, 0)))
-
- # now put the main image into it, offset:
- if offset_ind == 0:
- offsets = (offset, 0)
- else:
- offsets = (0, offset)
- new_obj.paste(im_obj, offsets)
- # and put the rescaled logo onto it too, in the right place:
- new_obj.paste(res_logo_obj, (logo_padding, logo_padding))
-
- else:
- msg = 'logo positions other than 0 and 2 (both top left) have not been implemented yet'
- raise NotImplementedError(msg)
-
- return new_obj
-
-def _im_add_png_tags(im_obj, png_tags):
- 'adds img_tags to an image object for later saving'
- for key, val in png_tags.iteritems():
- im_obj.info[key] = val
- return im_obj
-
-def _im_pngsave_addmeta(im_obj, outfile, optimize=True, verbose=False):
- 'saves an image object to a png file, adding metadata using the info tag...'
- # these can be automatically added to Image.info dict
- # they are not user-added metadata
- reserved = ('interlace', 'gamma', 'dpi', 'transparency', 'aspect', 'signature', \
- 'date:create', 'date:modify')
-
- # undocumented class
- meta = PngImagePlugin.PngInfo()
-
- # copy metadata into new object
- for key, val in im_obj.info.iteritems():
- if key in reserved:
- pass
- elif val is None:
- if verbose:
- print 'key "%s" is set to None' % key
- else:
- meta.add_text(key, val, 0)
-
- # and save
- im_obj.save(outfile, "PNG", optimize=optimize, pnginfo=meta)
-
-def _img_stong_resize(img_obj, size=None):
- 'does image pre-processing before a strong resize, to get rid of halo effects'
- if size is None:
- size = (40, 40)
- #shrink_ratio = [x/float(y) for x,y in zip(img_obj.size, size)]
- # make sure the image has an alpha channel:
- img_obj = img_obj.convert('RGBA')
- # premultiply the alpha channel:
- new_img_obj = _img_premultiplyAlpha(img_obj)
- ## and smooth is the change is size is large:
- #if max(shrink_ratio) >= 2:
- # new_img_obj = new_img_obj.filter(ImageFilter.SMOOTH)
- # now resize:
- res_img_obj = new_img_obj.resize(size, Image.ANTIALIAS)
- return res_img_obj
-
-def _img_premultiplyAlpha(img_obj):
- 'Premultiplies an input image by its alpha channel, which is useful for stron resizes'
- # fake transparent image to blend with
- transparent = Image.new("RGBA", img_obj.size, (0, 0, 0, 0))
- # blend with transparent image using own alpha
- return Image.composite(img_obj, transparent, img_obj)
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/docs/build/html/_modules/ImageMetaTag/webpage.html b/docs/build/html/_modules/ImageMetaTag/webpage.html
index a6d77e1..76e4ba2 100644
--- a/docs/build/html/_modules/ImageMetaTag/webpage.html
+++ b/docs/build/html/_modules/ImageMetaTag/webpage.html
@@ -6,7 +6,7 @@
- ImageMetaTag.webpage — ImageMetaTag 0.6.4 documentation
+ ImageMetaTag.webpage — ImageMetaTag 0.6.5 documentation
@@ -14,7 +14,7 @@
-
-
-
-
+
+
-
-
+
+
-
+
-
@@ -63,10 +65,10 @@ Quick search
-
+
Source code for ImageMetaTag.webpage
-'''
+'''
This sub-module contains functions to write out an :class:`ImageMetaTag.ImageDict` to a webpage.
The webpages are made up of a single .html file, which is the page to be loaded to view the images.
@@ -105,28 +107,28 @@ Source code for ImageMetaTag.webpage
'''
import os, json, pdb, shutil, tempfile, zlib
-import numpy as np
-import ImageMetaTag as imt
+import numpy as np
+import ImageMetaTag as imt
-from multiprocessing import Pool
+from multiprocessing import Pool
-# single indent to be used on the output webpage
-INDENT = ' '
+# single indent to be used on the output webpage
+INDENT = ' '
LEN_INDENT = len(INDENT)
-# for compressed json files, we use pako to inflate the data back to full size:
-PAKO_JS_FILE = 'pako_inflate.js'
-PAKO_RELEASE = '1.0.5'
-PAKO_SOURE_TAR = 'https://github.com/nodeca/pako/archive/{}.tar.gz'.format(PAKO_RELEASE)
+# for compressed json files, we use pako to inflate the data back to full size:
+PAKO_JS_FILE = 'pako_inflate.js'
+PAKO_RELEASE = '1.0.5'
+PAKO_SOURE_TAR = 'https://github.com/nodeca/pako/archive/{}.tar.gz'.format(PAKO_RELEASE)
-[docs]def write_full_page(img_dict, filepath, title, page_filename=None, tab_s_name=None,
- preamble=None, postamble=None, compression=False,
- initial_selectors=None, show_selector_names=False,
- url_type='int', only_show_rel_url=False, verbose=False,
- style='horiz dropdowns', write_intmed_tmpfile=False,
- description=None, keywords=None):
+[docs]def write_full_page(img_dict, filepath, title, page_filename=None, tab_s_name=None,
+ preamble=None, postamble=None, compression=False,
+ initial_selectors=None, show_selector_names=False,
+ url_type='int', only_show_rel_url=False, verbose=False,
+ style='horiz dropdowns', write_intmed_tmpfile=False,
+ description=None, keywords=None):
'''
Writes out an :class:`ImageMetaTag.ImageDict` as a webpage, to a given file location.
The file is overwritten.
@@ -166,143 +168,143 @@ Source code for ImageMetaTag.webpage
page_dependencies = []
- if not (isinstance(img_dict, imt.ImageDict) or img_dict is None):
- raise ValueError('write_full_page works on an ImageMetaTag ImageDict.')
+ if not (isinstance(img_dict, imt.ImageDict) or img_dict is None):
+ raise ValueError('write_full_page works on an ImageMetaTag ImageDict.')
- if page_filename is None:
+ if page_filename is None:
page_filename = os.path.basename(filepath)
- # other files involved:
+ # other files involved:
file_dir, file_name = os.path.split(filepath)
page_dependencies.append(file_name)
- if img_dict is None:
+ if img_dict is None:
json_files = []
else:
- # now make sure the required javascript library is copied over to the file_dir:
+ # now make sure the required javascript library is copied over to the file_dir:
js_files = copy_required_javascript(file_dir, style, compression=compression)
page_dependencies.extend(js_files)
- # we have real data to work with:
- # this tests the dict has uniform_depth, which is needed for all current webpages.
- dict_depth = img_dict.dict_depth(uniform_depth=True)
- # work out what files we need to create:
+ # we have real data to work with:
+ # this tests the dict has uniform_depth, which is needed for all current webpages.
+ dict_depth = img_dict.dict_depth(uniform_depth=True)
+ # work out what files we need to create:
file_name_no_ext = os.path.splitext(file_name)[0]
- # json file to hold the image_dict branching data etc:
+ # json file to hold the image_dict branching data etc:
json_file_no_ext = os.path.join(file_dir, file_name_no_ext)
json_files = write_json(img_dict, json_file_no_ext, compression=compression)
- # the final page is dependent on the final locations of the json files,
- # relative to the html:
+ # the final page is dependent on the final locations of the json files,
+ # relative to the html:
page_dependencies.extend([os.path.split(x[1])[1] for x in json_files])
- # this is the internal name the different selectors, associated lists for the selectors, and
- # the list of files (all with a numbered suffix):
- selector_prefix = 'sel'
- url_separator = '|'
+ # this is the internal name the different selectors, associated lists for the selectors, and
+ # the list of files (all with a numbered suffix):
+ selector_prefix = 'sel'
+ url_separator = '|'
- # now write the actual output file:
+ # now write the actual output file:
if write_intmed_tmpfile:
- # get a temporary file:
- with tempfile.NamedTemporaryFile('w', suffix='.html', prefix='imt_',
- dir=file_dir, delete=False) as html_file_obj:
+ # get a temporary file:
+ with tempfile.NamedTemporaryFile('w', suffix='.html', prefix='imt_',
+ dir=file_dir, delete=False) as html_file_obj:
tmp_html_filepath = html_file_obj.name
filepath_to_write = tmp_html_filepath
else:
filepath_to_write = filepath
- # start the indent:
- ind = ''
-
- # open the file - this is a nice and simple file so just use the with open...
- with open(filepath_to_write, 'w') as out_file:
- # write out the start of the file:
- out_file.write('<!DOCTYPE html>\n')
- out_file.write(ind + '<html>\n')
- # increase the indent level:
+ # start the indent:
+ ind = ''
+
+ # open the file - this is a nice and simple file so just use the with open...
+ with open(filepath_to_write, 'w') as out_file:
+ # write out the start of the file:
+ out_file.write('<!DOCTYPE html>\n')
+ out_file.write(ind + '<html>\n')
+ # increase the indent level:
ind = _indent_up_one(ind)
- out_file.write(ind + '<head>\n')
+ out_file.write(ind + '<head>\n')
ind = _indent_up_one(ind)
- if not title is None:
- out_file.write('{}<title>{}</title>\n'.format(ind, title))
- out_str = ind+'<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">\n'
+ if not title is None:
+ out_file.write('{}<title>{}</title>\n'.format(ind, title))
+ out_str = ind+'<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">\n'
out_file.write(out_str)
- if style == 'horiz dropdowns':
- # write out a little css at the top:
- css = '''{0}<style>
-{0} body, div, dl, dt, dd, li, h1, h2 {{
-{0} margin: 0;
-{0} padding: 0;
-{0} }}
-{0} h3, h4, h5, h6, pre, form, fieldset, input {{'
-{0} margin: 0;
-{0} padding: 0;
-{0} }}
-{0} textarea, p, blockquote, th, td {{
-{0} margin: 0;
-{0} padding: 0;
-{0} }}
-{0} fieldset, img {{
-{0} border: 0 none;
-{0} }}
-{0} body {{
-{0} font: 12px Myriad,Helvetica,Tahoma,Arial,clean,sans-serif;
-{0} *font-size: 75%;
-{0} }}
-{0} h1 {{
-{0} font-size: 1.5em;
-{0} font-weight: normal;
-{0} line-height: 1em;
-{0} margin-top: 1em;
-{0} margin-bottom:0;
-{0} }}
-{0} h2 {{
-{0} font-size: 1.1667em;
-{0} font-weight: bold;
-{0} line-height: 1.286em;
-{0} margin-top: 1.929em;
-{0} margin-bottom:0.643em;
-{0} }}
-{0} h3, h4, h5, h6 {{
-{0} font-size: 1em;
-{0} font-weight: bold;
-{0} line-height: 1.5em;
-{0} margin-top: 1.5em;
-{0} margin-bottom: 0;
-{0} }}
-{0} p {{
-{0} font-size: 1em;
-{0} margin-top: 1.5em;
-{0} margin-bottom: 1.5em;
-{0} line-height: 1.5em;
-{0} }}
-{0} pre, code {{
-{0} font-size:115%;
-{0} *font-size:100%;
-{0} font-family: Courier, "Courier New";
-{0} background-color: #efefef;
-{0} border: 1px solid #ccc;
-{0} }}
-{0} pre {{
-{0} border-width: 1px 0;
-{0} padding: 1.5em;
-{0} }}
-{0} table {{
-{0} font-size:100%;
-{0} }}
-{0}</style>
-'''
+ if style == 'horiz dropdowns':
+ # write out a little css at the top:
+ css = '''{0}<style>
+{0} body, div, dl, dt, dd, li, h1, h2 {{
+{0} margin: 0;
+{0} padding: 0;
+{0} }}
+{0} h3, h4, h5, h6, pre, form, fieldset, input {{'
+{0} margin: 0;
+{0} padding: 0;
+{0} }}
+{0} textarea, p, blockquote, th, td {{
+{0} margin: 0;
+{0} padding: 0;
+{0} }}
+{0} fieldset, img {{
+{0} border: 0 none;
+{0} }}
+{0} body {{
+{0} font: 12px Myriad,Helvetica,Tahoma,Arial,clean,sans-serif;
+{0} *font-size: 75%;
+{0} }}
+{0} h1 {{
+{0} font-size: 1.5em;
+{0} font-weight: normal;
+{0} line-height: 1em;
+{0} margin-top: 1em;
+{0} margin-bottom:0;
+{0} }}
+{0} h2 {{
+{0} font-size: 1.1667em;
+{0} font-weight: bold;
+{0} line-height: 1.286em;
+{0} margin-top: 1.929em;
+{0} margin-bottom:0.643em;
+{0} }}
+{0} h3, h4, h5, h6 {{
+{0} font-size: 1em;
+{0} font-weight: bold;
+{0} line-height: 1.5em;
+{0} margin-top: 1.5em;
+{0} margin-bottom: 0;
+{0} }}
+{0} p {{
+{0} font-size: 1em;
+{0} margin-top: 1.5em;
+{0} margin-bottom: 1.5em;
+{0} line-height: 1.5em;
+{0} }}
+{0} pre, code {{
+{0} font-size:115%;
+{0} *font-size:100%;
+{0} font-family: Courier, "Courier New";
+{0} background-color: #efefef;
+{0} border: 1px solid #ccc;
+{0} }}
+{0} pre {{
+{0} border-width: 1px 0;
+{0} padding: 1.5em;
+{0} }}
+{0} table {{
+{0} font-size:100%;
+{0} }}
+{0}</style>
+'''
out_file.write(css.format(ind))
- # now write out the specific stuff to the html header:
- if img_dict is None:
- # an empty img_dict needs very little:
+ # now write out the specific stuff to the html header:
+ if img_dict is None:
+ # an empty img_dict needs very little:
write_js_to_header(img_dict,
file_obj=out_file,
pagename=page_filename, tabname=tab_s_name,
ind=ind,
description=description, keywords=keywords)
else:
- # the json_files is a list of (tmp_file, final_file) tuples. Here we want the final one:
+ # the json_files is a list of (tmp_file, final_file) tuples. Here we want the final one:
final_json_files = [os.path.split(x[1])[1] for x in json_files]
write_js_to_header(img_dict, initial_selectors=initial_selectors,
file_obj=out_file, json_files=final_json_files, js_files=js_files,
@@ -311,45 +313,45 @@ Source code for ImageMetaTag.webpage
url_type=url_type, only_show_rel_url=only_show_rel_url,
style=style, ind=ind, compression=compression,
description=description, keywords=keywords)
- # now close the script and head:
+ # now close the script and head:
ind = _indent_down_one(ind)
- out_file.write(ind + '</script>\n')
+ out_file.write(ind + '</script>\n')
ind = _indent_down_one(ind)
- out_file.write(ind + '</head>\n')
+ out_file.write(ind + '</head>\n')
- # now start the body:
- margins = 'leftmargin="0" topmargin="0" marginwidth="0" marginheight="0"'
- bgcolor = 'bcolor="#FFFFFF"'
- text_color = 'text="#000000"'
- out_file.write('{}<body {} {} {}>\n'.format(ind, bgcolor, text_color, margins))
+ # now start the body:
+ margins = 'leftmargin="0" topmargin="0" marginwidth="0" marginheight="0"'
+ bgcolor = 'bcolor="#FFFFFF"'
+ text_color = 'text="#000000"'
+ out_file.write('{}<body {} {} {}>\n'.format(ind, bgcolor, text_color, margins))
- # the preamble is the first thing to go in the body:
- if not preamble is None:
+ # the preamble is the first thing to go in the body:
+ if not preamble is None:
out_file.write(preamble)
- # now the img_dict content:
- if img_dict is None:
- out_file.write('<p><h1>No images are available for this page.</h1></p>')
+ # now the img_dict content:
+ if img_dict is None:
+ out_file.write('<p><h1>No images are available for this page.</h1></p>')
else:
- # now write out the end, which includes the placeholders for the actual
- # stuff that appears on the page:
+ # now write out the end, which includes the placeholders for the actual
+ # stuff that appears on the page:
if show_selector_names:
level_names = img_dict.level_names
else:
- level_names = False
- # if we're labelling selectors, and we have an animator button, label that too:
+ level_names = False
+ # if we're labelling selectors, and we have an animator button, label that too:
if img_dict.selector_animated > 1 and show_selector_names:
anim_level = level_names[img_dict.selector_animated]
else:
- anim_level = None
+ anim_level = None
write_js_placeholders(file_obj=out_file, dict_depth=img_dict.dict_depth(),
style=style, level_names=level_names,
animated_level=anim_level)
- # the body is done, so the postamble comes in:
- if not postamble is None:
- out_file.write(postamble + '\n')
- # finish the body, and html:
- out_file.write(ind + '</body>\n')
- out_file.write('\n</html>')
+ # the body is done, so the postamble comes in:
+ if not postamble is None:
+ out_file.write(postamble + '\n')
+ # finish the body, and html:
+ out_file.write(ind + '</body>\n')
+ out_file.write('\n</html>')
if write_intmed_tmpfile:
@@ -357,21 +359,21 @@ Source code for ImageMetaTag.webpage
else:
tmp_files_to_mv = json_files
for tmp_file_mv in tmp_files_to_mv:
- # now move the json, then the html files:
- os.chmod(tmp_file_mv[0], 0644)
+ # now move the json, then the html files:
+ os.chmod(tmp_file_mv[0], 0644)
shutil.move(tmp_file_mv[0], tmp_file_mv[1])
if verbose:
- print 'File "%s" complete.' % filepath
-
- return page_dependencies
+ print 'File "%s" complete.' % filepath
-[docs]def write_js_to_header(img_dict, initial_selectors=None, style=None,
- file_obj=None, json_files=None, js_files=None,
- pagename=None, tabname=None, selector_prefix=None,
- url_separator='|', url_type='str', only_show_rel_url=False,
- ind=None, compression=False,
- description=None, keywords=None):
+ return page_dependencies
+
+[docs]def write_js_to_header(img_dict, initial_selectors=None, style=None,
+ file_obj=None, json_files=None, js_files=None,
+ pagename=None, tabname=None, selector_prefix=None,
+ url_separator='|', url_type='str', only_show_rel_url=False,
+ ind=None, compression=False,
+ description=None, keywords=None):
'''
Writes out the required ImageMetaTag config and data paths into a html header section
for an input :class:`ImageMetaTag.ImageDict`.
@@ -397,144 +399,144 @@ Source code for ImageMetaTag.webpage
* description - html description metadata7
* keywords - html keyword metadata
'''
- if not (isinstance(img_dict, imt.ImageDict) or img_dict is None):
- raise ValueError('Input img_dict is not an ImageMetaTag ImageDict')
+ if not (isinstance(img_dict, imt.ImageDict) or img_dict is None):
+ raise ValueError('Input img_dict is not an ImageMetaTag ImageDict')
- if not description is None:
- file_obj.write('{}<meta name="description" content="{}">\n'.format(ind, description))
- if not keywords is None:
- file_obj.write('{}<meta name="keywords" content="{}">\n'.format(ind, keywords))
+ if not description is None:
+ file_obj.write('{}<meta name="description" content="{}">\n'.format(ind, description))
+ if not keywords is None:
+ file_obj.write('{}<meta name="keywords" content="{}">\n'.format(ind, keywords))
- if not img_dict is None:
- ## add a reference to the data structure:
- #out_str = '{}<script type="text/javascript" src="{}"></script>\n'.format(ind, json_files)
- #file_obj.write(out_str)
+ if not img_dict is None:
+ ## add a reference to the data structure:
+ #out_str = '{}<script type="text/javascript" src="{}"></script>\n'.format(ind, json_files)
+ #file_obj.write(out_str)
- # now add a reference to the javascript functions to implement the style:
+ # now add a reference to the javascript functions to implement the style:
for js_file in js_files:
- out_str = '{}<script type="text/javascript" src="{}"></script>\n'.format(ind, js_file)
+ out_str = '{}<script type="text/javascript" src="{}"></script>\n'.format(ind, js_file)
file_obj.write(out_str)
- # now write out the javascript cnfiguration variables:
- file_obj.write(ind + '<script type="text/javascript">\n')
+ # now write out the javascript cnfiguration variables:
+ file_obj.write(ind + '<script type="text/javascript">\n')
ind = _indent_up_one(ind)
- # define, read in and parse the json file:
- out_str = '''{0}var json_files = {1};
-{0}var zl_unpack = {2};
-{0}imt = read_parse_json_files(json_files, zl_unpack);
-'''
+ # define, read in and parse the json file:
+ out_str = '''{0}var json_files = {1};
+{0}var zl_unpack = {2};
+{0}imt = read_parse_json_files(json_files, zl_unpack);
+'''
file_obj.write(out_str.format(ind, json_files, _py_to_js_bool(bool(compression))))
- # in case the page we are writing is embedded as a frame, write out the top
- # level page here;
- file_obj.write('{}var pagename = "{}"\n'.format(ind, pagename))
- # the tab name is used in setting up the URL in nested frames:
- file_obj.write('{}var tab_name = "{}";\n'.format(ind, tabname))
+ # in case the page we are writing is embedded as a frame, write out the top
+ # level page here;
+ file_obj.write('{}var pagename = "{}"\n'.format(ind, pagename))
+ # the tab name is used in setting up the URL in nested frames:
+ file_obj.write('{}var tab_name = "{}";\n'.format(ind, tabname))
dict_depth = img_dict.dict_depth()
- # the key_to_selector variable is what maps each set of keys onto a selector on the page:
+ # the key_to_selector variable is what maps each set of keys onto a selector on the page:
key_to_selector = str([selector_prefix + str(x) for x in range(dict_depth)])
- file_obj.write('{}var key_to_selector = {};\n'.format(ind, key_to_selector))
- # this determines whether a selector uses the animation controls on a page:
- file_obj.write('{}var anim_sel = {};\n'.format(ind, img_dict.selector_animated))
- # and the direction the animation runs in:
- file_obj.write('{}var anim_dir = {};\n'.format(ind, img_dict.animation_direction))
- # and the direction the animation runs in:
-
- # the url_separator is the text character that goes between the variables in the url:
- if url_separator == '&':
- msg = 'Cannot use "&" as the url_separator, as some strings will '
- msg += 'become html special characters. For instance ¶-global '
- msg += 'will be treated as a paragraph then -global, not the intended string.'
+ file_obj.write('{}var key_to_selector = {};\n'.format(ind, key_to_selector))
+ # this determines whether a selector uses the animation controls on a page:
+ file_obj.write('{}var anim_sel = {};\n'.format(ind, img_dict.selector_animated))
+ # and the direction the animation runs in:
+ file_obj.write('{}var anim_dir = {};\n'.format(ind, img_dict.animation_direction))
+ # and the direction the animation runs in:
+
+ # the url_separator is the text character that goes between the variables in the url:
+ if url_separator == '&':
+ msg = 'Cannot use "&" as the url_separator, as some strings will '
+ msg += 'become html special characters. For instance ¶-global '
+ msg += 'will be treated as a paragraph then -global, not the intended string.'
raise ValueError(msg)
- file_obj.write('{}var url_separator = "{}";\n'.format(ind, url_separator))
-
- # the url_type determines whether the url is full of integers (int), with meaningful
- # values internally or text which looks more meaningful to the user:
- file_obj.write('{}var url_type = "{}";\n'.format(ind, url_type))
- # the show_rel_url logical (converted to a string to init a javascript bool)
- file_obj.write('{}var show_rel_url = {};\n'.format(ind, _py_to_js_bool(only_show_rel_url)))
-
- # the selected_id needs to be defined here too, as it's used as a global variable
- # (it will be overwritten later if the URL changes it, and when selectors change it):
- if initial_selectors is None:
- # if it's not set, then set it to something invalid, and the validator
- # in the javascript will sort it out. It MUST be the right length though:
- file_obj.write('{}var selected_id = {}\n;'.format(ind, str([-1]*dict_depth)))
+ file_obj.write('{}var url_separator = "{}";\n'.format(ind, url_separator))
+
+ # the url_type determines whether the url is full of integers (int), with meaningful
+ # values internally or text which looks more meaningful to the user:
+ file_obj.write('{}var url_type = "{}";\n'.format(ind, url_type))
+ # the show_rel_url logical (converted to a string to init a javascript bool)
+ file_obj.write('{}var show_rel_url = {};\n'.format(ind, _py_to_js_bool(only_show_rel_url)))
+
+ # the selected_id needs to be defined here too, as it's used as a global variable
+ # (it will be overwritten later if the URL changes it, and when selectors change it):
+ if initial_selectors is None:
+ # if it's not set, then set it to something invalid, and the validator
+ # in the javascript will sort it out. It MUST be the right length though:
+ file_obj.write('{}var selected_id = {}\n;'.format(ind, str([-1]*dict_depth)))
else:
if not isinstance(initial_selectors, list):
- msg = 'Input initial_selectors must be a list, of length the depth of the ImageDict'
+ msg = 'Input initial_selectors must be a list, of length the depth of the ImageDict'
raise ValueError(msg)
if len(initial_selectors) != img_dict.dict_depth():
- msg = 'Input initial_selectors must be a list, of length the depth of the ImageDict'
+ msg = 'Input initial_selectors must be a list, of length the depth of the ImageDict'
raise ValueError(msg)
- # the input can either be a list of integer indices, or strings that match:
+ # the input can either be a list of integer indices, or strings that match:
initial_selectors_as_inds = []
initial_selectors_as_string = []
for i_sel, sel_value in enumerate(initial_selectors):
if isinstance(sel_value, int):
if sel_value < 0 or sel_value >= len(img_dict.keys[i_sel]):
- raise ValueError('initial_selectors are out of range')
- # store the initial_selectors_as_inds
+ raise ValueError('initial_selectors are out of range')
+ # store the initial_selectors_as_inds
initial_selectors_as_inds.append(sel_value)
- # and as a string:
+ # and as a string:
initial_selectors_as_string.append(img_dict.keys[i_sel][sel_value])
else:
- # get the index of that value:
+ # get the index of that value:
initial_selectors_as_inds.append(img_dict.keys[i_sel].index(sel_value))
- # and simple store the string:
+ # and simple store the string:
initial_selectors_as_string.append(sel_value)
- # check that's valid:
- if img_dict.return_from_list(initial_selectors_as_string) is None:
- raise ValueError('Input initial_selectors does not end up at a valid image/payload')
- # write that out:
- file_obj.write('{}var selected_id = {};\n'.format(ind, initial_selectors_as_inds))
+ # check that's valid:
+ if img_dict.return_from_list(initial_selectors_as_string) is None:
+ raise ValueError('Input initial_selectors does not end up at a valid image/payload')
+ # write that out:
+ file_obj.write('{}var selected_id = {};\n'.format(ind, initial_selectors_as_inds))
- # now write out the lists of keys, to the different levels:
+ # now write out the lists of keys, to the different levels:
keys_to_js = [str(x[1]) for x in img_dict.keys.iteritems()]
- file_obj.write('{}var key_lists = [{},\n'.format(ind, keys_to_js[0]))
+ file_obj.write('{}var key_lists = [{},\n'.format(ind, keys_to_js[0]))
ind = _indent_up_one(ind)
for i_depth in range(1, dict_depth):
- file_obj.write('{}{},\n'.format(ind, keys_to_js[i_depth]))
+ file_obj.write('{}{},\n'.format(ind, keys_to_js[i_depth]))
ind = _indent_down_one(ind)
- file_obj.write(ind + '];\n')
-
- # now some top level things:
- if style == 'horiz dropdowns':
- file_obj.write('''
- {0}// other top level derived variables
- {0}// the depth of the ImageMetaTag ImageDict (number of selectors):
- {0}var n_deep = selected_id.length;
- {0}// a list of the options available to the animator buttons, with the current selectio
- {0}var anim_options = [];
- {0}// the index of the current option for the animator:
- {0}var anim_ind = 0;
- '''.format(ind))
-
- # now, the main call:
- file_obj.write(ind + 'window.onload = function() {\n')
+ file_obj.write(ind + '];\n')
+
+ # now some top level things:
+ if style == 'horiz dropdowns':
+ file_obj.write('''
+ {0}// other top level derived variables
+ {0}// the depth of the ImageMetaTag ImageDict (number of selectors):
+ {0}var n_deep = selected_id.length;
+ {0}// a list of the options available to the animator buttons, with the current selectio
+ {0}var anim_options = [];
+ {0}// the index of the current option for the animator:
+ {0}var anim_ind = 0;
+ '''.format(ind))
+
+ # now, the main call:
+ file_obj.write(ind + 'window.onload = function() {\n')
ind = _indent_up_one(ind)
- file_obj.write(ind + '// redefine onload, so it does this:\n')
- file_obj.write(ind + 'imt_main();\n')
+ file_obj.write(ind + '// redefine onload, so it does this:\n')
+ file_obj.write(ind + 'imt_main();\n')
ind = _indent_down_one(ind)
- file_obj.write(ind + '};\n')
- # END of the imt specifc header content:
-
-def write_js_setup_defaults(selector_prefix=None, list_prefix=None, file_list_name=None):
+ file_obj.write(ind + '};\n')
+ # END of the imt specifc header content:
+
+def write_js_setup_defaults(selector_prefix=None, list_prefix=None, file_list_name=None):
'''
this specifies defaults for the internal names the different selectors, associated lists for
the selectors, and the list of files (all with a numbered suffix)
'''
- if selector_prefix is None:
- selector_prefix = 'sel'
- if list_prefix is None:
- list_prefix = 'list'
- if file_list_name is None:
- file_list_name = 'file_list'
+ if selector_prefix is None:
+ selector_prefix = 'sel'
+ if list_prefix is None:
+ list_prefix = 'list'
+ if file_list_name is None:
+ file_list_name = 'file_list'
return (selector_prefix, list_prefix, file_list_name)
-[docs]def write_json(img_dict, file_name_no_ext, compression=False,
- chunk_char_limit=1e7):
+[docs]def write_json(img_dict, file_name_no_ext, compression=False,
+ chunk_char_limit=1e7):
'''
Writes a json dump of the :class:`ImageMetaTag.ImageDict` tree strucuture
to a target file path.
@@ -548,53 +550,53 @@ Source code for ImageMetaTag.webpage
'''
def json_from_dict(in_dict):
- 'returns a json string from an input dict'
- return json.dumps(in_dict, separators=(',', ':'))
+ 'returns a json string from an input dict'
+ return json.dumps(in_dict, separators=(',', ':'))
if isinstance(img_dict, imt.ImageDict):
dict_as_json = json_from_dict(img_dict.dict)
elif isinstance(img_dict, str):
dict_as_json = img_dict
else:
- raise ValueError('input img_dict is not an ImageMetaTag.ImageDict or string')
+ raise ValueError('input img_dict is not an ImageMetaTag.ImageDict or string')
- # file suffix:
- suffix = '.json'
+ # file suffix:
+ suffix = '.json'
if compression:
- suffix += '.zlib'
+ suffix += '.zlib'
- # the output files:
+ # the output files:
out_files = []
tmp_file_dir = os.path.split(file_name_no_ext)[0]
- # use the maximum length of a single string per file:
+ # use the maximum length of a single string per file:
n_chunks = np.ceil(len(dict_as_json) / chunk_char_limit)
n_chunks = int(n_chunks)
if n_chunks == 1:
- # easy if it fits into a single file:
+ # easy if it fits into a single file:
json_file = file_name_no_ext + suffix
- with tempfile.NamedTemporaryFile('w', suffix='.json', prefix='imt_',
- dir=tmp_file_dir, delete=False) as file_obj:
+ with tempfile.NamedTemporaryFile('w', suffix='.json', prefix='imt_',
+ dir=tmp_file_dir, delete=False) as file_obj:
if compression:
file_obj.write(zlib.compress(dict_as_json))
else:
file_obj.write(dict_as_json)
tmp_file_path = file_obj.name
- # make a note of the outputs:
+ # make a note of the outputs:
out_files.append((tmp_file_path, json_file))
else:
- # find the appropriate depth at which to split the dict:
+ # find the appropriate depth at which to split the dict:
if not isinstance(img_dict, imt.ImageDict):
- msg = 'Large data sets need to be supplied as an ImageDict, so they can be split'
+ msg = 'Large data sets need to be supplied as an ImageDict, so they can be split'
raise ValueError(msg)
- dict_depth = img_dict.dict_depth(uniform_depth=True)
+ dict_depth = img_dict.dict_depth(uniform_depth=True)
if len(img_dict.keys) != dict_depth:
- raise ValueError('Inconsistent depth and keys. Do the keys need relisting?')
+ raise ValueError('Inconsistent depth and keys. Do the keys need relisting?')
- # determine approximately how many splits will be obtained by breaking up the
- # dictionary at each level, assuming the tree structure branches uniformly.
+ # determine approximately how many splits will be obtained by breaking up the
+ # dictionary at each level, assuming the tree structure branches uniformly.
n_by_depth = []
for i_depth in range(dict_depth):
if i_depth == 0:
@@ -603,68 +605,68 @@ Source code for ImageMetaTag.webpage
n_by_depth.append(len(img_dict.keys[i_depth]) * n_by_depth[-1])
if n_by_depth[-1] >= n_chunks:
break
- # i_depth is an index, but depth is the number of levels, so needs one adding:
+ # i_depth is an index, but depth is the number of levels, so needs one adding:
depth = i_depth + 1
- # get all the combinations of keys that reach the required depth:
+ # get all the combinations of keys that reach the required depth:
keys, array_inds = img_dict.dict_index_array(maxdepth=depth)
- # now loop through the array_inds. Each one contains the indices of a valid path through
- # the dict, to the required depth. Each subdict will be written to a separate .json file
+ # now loop through the array_inds. Each one contains the indices of a valid path through
+ # the dict, to the required depth. Each subdict will be written to a separate .json file
paths = []
top_dict = {}
for i_json, path_inds in enumerate(array_inds):
- # traverse to the subdict, given by the current path,
- # storing the keys of the path along the way
+ # traverse to the subdict, given by the current path,
+ # storing the keys of the path along the way
subdict = img_dict.dict
path = []
for level, ind in enumerate(path_inds):
subdict = subdict[keys[level][ind]]
path.append(keys[level][ind])
- # convert the subdict to .json
+ # convert the subdict to .json
subdict_as_json = json_from_dict(subdict)
- # and write this out:
- json_file = '{}_{}{}'.format(file_name_no_ext, i_json, suffix)
- with tempfile.NamedTemporaryFile('w', suffix='.json', prefix='imt_',
- dir=tmp_file_dir, delete=False) as file_obj:
+ # and write this out:
+ json_file = '{}_{}{}'.format(file_name_no_ext, i_json, suffix)
+ with tempfile.NamedTemporaryFile('w', suffix='.json', prefix='imt_',
+ dir=tmp_file_dir, delete=False) as file_obj:
if compression:
file_obj.write(zlib.compress(subdict_as_json))
else:
file_obj.write(subdict_as_json)
tmp_file_path = file_obj.name
- # make a note of the outputs:
+ # make a note of the outputs:
out_files.append((tmp_file_path, json_file))
- # now add this to the top level dict structure, so the final json file can pull them all togther:
- path_dict = {path[-1]: '**FILE_{}**'.format(i_json)}
- # go backwards, from the second from last element of the path, to add more;
+ # now add this to the top level dict structure, so the final json file can pull them all togther:
+ path_dict = {path[-1]: '**FILE_{}**'.format(i_json)}
+ # go backwards, from the second from last element of the path, to add more;
for key in path[-2::-1]:
path_dict = {key: path_dict}
img_dict.dict_union(top_dict, path_dict)
- # add it to the paths, as a cross reference:
+ # add it to the paths, as a cross reference:
paths.append(path)
- # now create the final json file that combines the previous ones into a single usable object:
+ # now create the final json file that combines the previous ones into a single usable object:
i_json += 1
- # convert the subdict to .json
+ # convert the subdict to .json
subdict_as_json = json_from_dict(top_dict)
- # and write this out:
- json_file = '{}_{}{}'.format(file_name_no_ext, i_json, suffix)
- with tempfile.NamedTemporaryFile('w', suffix='.json', prefix='imt_',
- dir=tmp_file_dir, delete=False) as file_obj:
+ # and write this out:
+ json_file = '{}_{}{}'.format(file_name_no_ext, i_json, suffix)
+ with tempfile.NamedTemporaryFile('w', suffix='.json', prefix='imt_',
+ dir=tmp_file_dir, delete=False) as file_obj:
if compression:
file_obj.write(zlib.compress(subdict_as_json))
else:
file_obj.write(subdict_as_json)
tmp_file_path = file_obj.name
- # make a note of the outputs:
+ # make a note of the outputs:
out_files.append((tmp_file_path, json_file))
- return out_files
-
-[docs]def write_js_placeholders(file_obj=None, dict_depth=None, selector_prefix=None,
- style='horiz dropdowns', level_names=False,
- animated_level=None):
+ return out_files
+
+[docs]def write_js_placeholders(file_obj=None, dict_depth=None, selector_prefix=None,
+ style='horiz dropdowns', level_names=False,
+ animated_level=None):
'''
Writes the placeholders into the page body, for the javascript to manipulate
@@ -679,89 +681,89 @@ Source code for ImageMetaTag.webpage
* animated_level - if supplied, as a string, this will be used to label the animator buttons.
'''
- if selector_prefix is None:
+ if selector_prefix is None:
selector_prefix, _junk1, _junk2 = write_js_setup_defaults()
- apply_level_names = False
+ apply_level_names = False
if level_names:
if not isinstance(level_names, list):
- raise ValueError('level_names needs to be a list of length dict_depth')
+ raise ValueError('level_names needs to be a list of length dict_depth')
if len(level_names) != dict_depth:
- raise ValueError('level_names needs to be a list, of length dict_depth')
- apply_level_names = True
+ raise ValueError('level_names needs to be a list, of length dict_depth')
+ apply_level_names = True
else:
- apply_level_names = False
-
- if style == 'horiz dropdowns':
- file_obj.write('''
-<!-- Now for some placeholders for the scripts to put content -->
-<table border=0 cellspacing=0 cellpadding=0 width=99% align=center>
- <tr>
- <td>
- <font size=3>''')
- # a text label for the animator buttons:
+ apply_level_names = False
+
+ if style == 'horiz dropdowns':
+ file_obj.write('''
+<!-- Now for some placeholders for the scripts to put content -->
+<table border=0 cellspacing=0 cellpadding=0 width=99% align=center>
+ <tr>
+ <td>
+ <font size=3>''')
+ # a text label for the animator buttons:
if isinstance(animated_level, str):
- anim_label = '{}: '.format(animated_level)
+ anim_label = '{}: '.format(animated_level)
else:
- anim_label = ''
+ anim_label = ''
- # for each level of depth in the plot dictionary, add a span to hold the selector:
+ # for each level of depth in the plot dictionary, add a span to hold the selector:
if apply_level_names:
- # if we want labelled selectors, then write out
- # a table, with pairs of label, selector, in columns:
- file_obj.write('''
- <table border=0 cellspacing=0 cellpadding=0 style='border-spacing: 3px 0;'>
- <tr>
-''')
+ # if we want labelled selectors, then write out
+ # a table, with pairs of label, selector, in columns:
+ file_obj.write('''
+ <table border=0 cellspacing=0 cellpadding=0 style='border-spacing: 3px 0;'>
+ <tr>
+''')
for level in range(dict_depth):
- file_obj.write(' <td>{} </td>\n'.format(level_names[level]))
- file_obj.write(''' </tr>
- <tr>
-''')
+ file_obj.write(' <td>{} </td>\n'.format(level_names[level]))
+ file_obj.write(''' </tr>
+ <tr>
+''')
for level in range(dict_depth):
selp = selector_prefix + str(level)
- out_str = ' <td><span id="{}"> </span></td>\n'.format(selp)
+ out_str = ' <td><span id="{}"> </span></td>\n'.format(selp)
file_obj.write(out_str)
- file_obj.write(''' </tr>
-''')
- # add the placeholder for animators buttons:
- file_obj.write(''' <tr>
- <td colspan={}>
- {}<span id="animator1"> </span>
- <span id="animator2"> </span>
- </td>
- </tr>
- </table>
-'''.format(dict_depth, anim_label))
+ file_obj.write(''' </tr>
+''')
+ # add the placeholder for animators buttons:
+ file_obj.write(''' <tr>
+ <td colspan={}>
+ {}<span id="animator1"> </span>
+ <span id="animator2"> </span>
+ </td>
+ </tr>
+ </table>
+'''.format(dict_depth, anim_label))
else:
- # simply a set of spans, in a line:
+ # simply a set of spans, in a line:
for lev in range(dict_depth):
- file_obj.write('''
- <span id="%s%s"> </span>''' % (selector_prefix, lev))
- file_obj.write('\n <br>')
- # add the placeholder for animators buttons:
- file_obj.write('''
- {}<span id="animator1"> </span>
- <span id="animator2"> </span>
- <br>
- '''.format(anim_label))
-
- # now add somewhere for the image to go:
- file_obj.write(''' <div id="the_image">Please wait while the page is loading</div>
- <div id="the_url">....</div>''')
- # and finish off the placeholders:
- file_obj.write('''
- </font>
- </td>
- </tr>
-</table>
-
-''')
+ file_obj.write('''
+ <span id="%s%s"> </span>''' % (selector_prefix, lev))
+ file_obj.write('\n <br>')
+ # add the placeholder for animators buttons:
+ file_obj.write('''
+ {}<span id="animator1"> </span>
+ <span id="animator2"> </span>
+ <br>
+ '''.format(anim_label))
+
+ # now add somewhere for the image to go:
+ file_obj.write(''' <div id="the_image">Please wait while the page is loading</div>
+ <div id="the_url">....</div>''')
+ # and finish off the placeholders:
+ file_obj.write('''
+ </font>
+ </td>
+ </tr>
+</table>
+
+''')
else:
- raise ValueError('"%s" tyle of content placeholder not defined' % style)
-
-[docs]def copy_required_javascript(file_dir, style, compression=False, overwrite=True):
+ raise ValueError('"%s" tyle of content placeholder not defined' % style)
+
+[docs]def copy_required_javascript(file_dir, style, compression=False, overwrite=True):
'''
Copies the required javascript library to the directory
containing the required page (file_dir) for a given webpage style.
@@ -773,126 +775,126 @@ Source code for ImageMetaTag.webpage
with zlib, if compression=True.
'''
- if style == 'horiz dropdowns':
- imt_js_to_copy = 'imt_dropdown.js'
- # get this from the installed ImageMetaTag directory:
- file_src_dir = os.path.join(imt.__path__[0], 'javascript')
- first_line = '// ImageMetaTag dropdown menu scripting - vn{}\n'.format(imt.__version__)
+ if style == 'horiz dropdowns':
+ imt_js_to_copy = 'imt_dropdown.js'
+ # get this from the installed ImageMetaTag directory:
+ file_src_dir = os.path.join(imt.__path__[0], 'javascript')
+ first_line = '// ImageMetaTag dropdown menu scripting - vn{}\n'.format(imt.__version__)
else:
- raise ValueError('Javascript library not set up for style: {}'.format(style))
+ raise ValueError('Javascript library not set up for style: {}'.format(style))
if not os.path.isfile(os.path.join(file_dir, imt_js_to_copy)):
- # file isn't in target dir, so copy it:
+ # file isn't in target dir, so copy it:
shutil.copy(os.path.join(file_src_dir, imt_js_to_copy),
os.path.join(file_dir, imt_js_to_copy))
else:
- # the file is there, check it's right:
+ # the file is there, check it's right:
with open(os.path.join(file_dir, imt_js_to_copy)) as file_obj:
this_first_line = file_obj.readline()
if first_line == this_first_line:
- # the file is good, move on:
+ # the file is good, move on:
pass
else:
if overwrite:
shutil.copy(os.path.join(file_src_dir, imt_js_to_copy),
os.path.join(file_dir, imt_js_to_copy))
else:
- print '''File: {}/{} differs to the expected contents, but is
-not being overwritten. Your webpage may be broken!'''.format(file_dir, imt_js_to_copy)
+ print '''File: {}/{} differs to the expected contents, but is
+not being overwritten. Your webpage may be broken!'''.format(file_dir, imt_js_to_copy)
- # make a list of all the required javascript files
+ # make a list of all the required javascript files
js_files = [imt_js_to_copy]
- # now move on to javascript dependencies from the compression:
+ # now move on to javascript dependencies from the compression:
if compression:
js_to_copy = PAKO_JS_FILE
js_src = os.path.join(file_src_dir, js_to_copy)
js_dest = os.path.join(file_dir, js_to_copy)
- # if the file is already at destination, we're good:
+ # if the file is already at destination, we're good:
if os.path.isfile(js_dest):
pass
else:
- # is the required file in the javascript source directory:
+ # is the required file in the javascript source directory:
if not os.path.isfile(js_src):
- # we need to get the required javascript from source.
- #
- # if we have permission to write to teh file_src_dir then
- # try to do so. This means it's installed for all uses from this
- # install of ImageMetaTag:
+ # we need to get the required javascript from source.
+ #
+ # if we have permission to write to teh file_src_dir then
+ # try to do so. This means it's installed for all uses from this
+ # install of ImageMetaTag:
if os.access(file_src_dir, os.W_OK):
pako_to_dir = file_src_dir
- # now get pako:
+ # now get pako:
get_pako(pako_to_dir=pako_to_dir)
- # and copy it to where it's needed for this call:
+ # and copy it to where it's needed for this call:
shutil.copy(js_src, js_dest)
else:
- # put pako js file into the target dir. At least it will
- # be available for subsequent writes to that dir:
+ # put pako js file into the target dir. At least it will
+ # be available for subsequent writes to that dir:
pako_to_dir = file_dir
- # now get pako to that dir:
+ # now get pako to that dir:
get_pako(pako_to_dir=pako_to_dir)
else:
- # copy the file:
+ # copy the file:
shutil.copy(js_src, js_dest)
- # finally, make a note:
+ # finally, make a note:
js_files.append(js_to_copy)
- return js_files
-
-def get_pako(pako_to_dir=None):
+ return js_files
+
+def get_pako(pako_to_dir=None):
'''
Obtains the required pako javascript code from remote host, to a given
javascript directory. If the javascript dir is not supplied, then
the 'javascript' directory alongside the ImageMetaTag python code is used.
'''
import tarfile
- from urllib2 import urlopen
+ from urllib2 import urlopen
- # set up pako into the current imt_dir:
- if pako_to_dir is None:
- pako_to_dir = os.path.join(imt.__path__[0], 'javascript')
+ # set up pako into the current imt_dir:
+ if pako_to_dir is None:
+ pako_to_dir = os.path.join(imt.__path__[0], 'javascript')
- # Open the url
+ # Open the url
pako_urlopen = urlopen(PAKO_SOURE_TAR)
- print "downloading " + PAKO_SOURE_TAR
- # Open our local file for writing
- with tempfile.NamedTemporaryFile('w', suffix='.tar.gz', prefix='pako_',
- delete=False) as local_file:
+ print "downloading " + PAKO_SOURE_TAR
+ # Open our local file for writing
+ with tempfile.NamedTemporaryFile('w', suffix='.tar.gz', prefix='pako_',
+ delete=False) as local_file:
local_file.write(pako_urlopen.read())
targz_file = local_file.name
pako_urlopen.close()
- # now extract the file we need:
- with tarfile.open(name=targz_file, mode='r:gz') as tgz:
+ # now extract the file we need:
+ with tarfile.open(name=targz_file, mode='r:gz') as tgz:
if not tarfile.is_tarfile:
- raise ValueError('Downloaded pako tar.gz file cannot be read.')
+ raise ValueError('Downloaded pako tar.gz file cannot be read.')
else:
- target = 'pako-{}/dist/{}'.format(PAKO_RELEASE, PAKO_JS_FILE)
+ target = 'pako-{}/dist/{}'.format(PAKO_RELEASE, PAKO_JS_FILE)
target_file = tgz.extractfile(target)
if target_file:
- with open(os.path.join(pako_to_dir, PAKO_JS_FILE), 'w') as final_file:
+ with open(os.path.join(pako_to_dir, PAKO_JS_FILE), 'w') as final_file:
for line in target_file:
final_file.write(line)
os.remove(targz_file)
def _indent_up_one(ind):
- 'increases the indent level of an input ind by one'
+ 'increases the indent level of an input ind by one'
n_indents = len(ind) / LEN_INDENT
return INDENT * (n_indents + 1)
def _indent_down_one(ind):
- 'decreases the indent level of an input ind by one'
+ 'decreases the indent level of an input ind by one'
n_indents = len(ind) / LEN_INDENT
return INDENT * max(n_indents - 1, 0)
def _py_to_js_bool(py_bool):
- 'Converts a python boolean to a string, in javascript bool format (all lower case)'
- if py_bool is True:
- return 'true'
- elif py_bool is False:
- return 'false'
+ 'Converts a python boolean to a string, in javascript bool format (all lower case)'
+ if py_bool is True:
+ return 'true'
+ elif py_bool is False:
+ return 'false'
else:
- raise ValueError('input to _py_to_js_bool is not a boolean, it is: %s' % py_bool)
+ raise ValueError('input to _py_to_js_bool is not a boolean, it is: %s' % py_bool)
@@ -900,7 +902,7 @@ Source code for ImageMetaTag.webpage
-
+
-
- © Copyright 2015-2017, British Crown Copyright.
- Created using Sphinx 1.4.8.
+
\ No newline at end of file
diff --git a/docs/build/html/_modules/index.html b/docs/build/html/_modules/index.html
index 5077ffc..36b4e58 100644
--- a/docs/build/html/_modules/index.html
+++ b/docs/build/html/_modules/index.html
@@ -6,7 +6,7 @@
- Overview: module code — ImageMetaTag 0.6.4 documentation
+ Overview: module code — ImageMetaTag 0.6.5 documentation
@@ -14,7 +14,7 @@
-
-
-
+
-
-
+
+
-
+
-
@@ -61,21 +62,20 @@ Quick search
-
+
All modules for which code is available
+
-