[Jahshaka-cvs] openlibraries/test/openassetlib/python_bindings_unittest jahlogo.png, NONE, 1.1 python_binding_unittest.py, NONE, 1.1 uuid.py, NONE, 1.1

[jpn <non...@us...>]

Update of /cvsroot/openlibraries/openlibraries/test/openassetlib/python_bindings_unittest
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv6220/test/openassetlib/python_bindings_unittest

Added Files:
	jahlogo.png python_binding_unittest.py uuid.py 
Log Message:
New python test script

--- NEW FILE: uuid.py ---
"""handling RFC 4122 compatible UUIDs"""

"""Copyright (c) 2006 Juergen Urner

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to 
do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial
portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""

__version__ = "0.3.2"

import calendar as _calendar
import md5 as _md5
import random as _random
import re as _re
import sha as _sha
import sys as _sys
import time as _time
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

VARIANT_UNKNOWN =  0	# unknown variant
VARIANT_NCS          =    1	# reserved for NCS backward compatibility
VARIANT_RFC4122  =    2	# RFC4122 compatible (produced by this module)
VARIANT_MS            =    3	# Reserved for Microsoft backward compatibility
VARIANT_FUTURE    =    4	# Reserved for future definition


VERSION_UNKNOWN  = 0	# unknown version
VERSION_TIME            = 1	# time based UUID
VERSION_DCE             = 2	# DCE Security version
VERSION_MD5            = 3	# name based UUID with MD5 hashing
VERSION_RANDOM     = 4	# randomly generated UUID
VERSION_SHA1           = 5	# name based UUID with SHA1 hashing


NAMESPACE_DNS = '{6ba7b810-9dad-11d1-80b4-00c04fd430c8}'	# DNS namespace UUID
NAMESPACE_URL = '{6ba7b811-9dad-11d1-80b4-00c04fd430c8}'		# URL namespace UUID
NAMESPACE_OID = '{6ba7b812-9dad-11d1-80b4-00c04fd430c8}'		# OID namespace UUID
NAMESPACE_X500 = '{6ba7b814-9dad-11d1-80b4-00c04fd430c8}'	# X500 namespace UUID

UUID_NIL = '{00000000-0000-0000-0000-000000000000}'	 			# UUID NULL


# TODO: the thrown in getrandbits() replacement may not work as expected
# check if getrandbits is available (requires python 2.4)
try:
	_getrandbits = _random.getrandbits
except:
	def _getrandbits(num_bits):	# took this from: http://www.zopelabs.com/cookbook/1067449107
		rnd = _random.Random()
		bytes = 0L
		for i in range(0, num_bits):
			bytes += long(rnd.randint(0,1)) << i
		return bytes
		

# throw replacement in for socket.htonl and friends (enshures? we always get a ulong in return)
def _DWORD(num): return num & 0xFFFFFFFFL
def _WORD(num): return num & 0xFFFF

if _sys.byteorder == 'big':
	def _htonl(dw): return _DWORD(dw)
	def _htons(w): return _WORD(w)
else:
	def _htons(w): 
		w = _WORD(w)
		return ((w & 0xff00) >> 8) | ((w & 0x00ff) << 8)
	def _htonl(dw): 		
		dw = _DWORD(dw)
		return ((dw & 0xff000000L) >> 24) | \
					((dw & 0x00ff0000L) >> 8)  |    \
					((dw & 0x0000ff00L) << 8)  |    \
					((dw & 0x000000ffL) << 24)
_ntohs = _htons
_ntohl = _htonl	


class UuidError(Exception):
	"""default error"""


class _GeneratorState(object):
	
	CLOCK_SEQ_MAX = 0x3FFF
	
	# TODO: how to calculate time resolution ?
	# holds the number of 100ns ticks of the actual resolution of the system's clock
	# the current implementation just limits the number or UUIDs generated/tick to 10.000,
	# no matter what tick is
	UUIDS_PER_TICK = 10000
	
	# time delta in 100ns steps from system epoch to uuid epoch (00:00:00.00, 15 October 1582)
	# calculate delta of the actual epoch relative to UNIX_EPOCH
	GM_UNIX_EPOCH = (1970, 1, 1, 0, 0, 0, 3, 1, 0)
	UNIX_EPOCH = _calendar.timegm(GM_UNIX_EPOCH) * 10000000
	UNIX_OFFSET = 0x01b21dd213814000		# offset in nanoseconds to uuid epoch
	TDELTA = UNIX_OFFSET - UNIX_EPOCH
			
	def __init__(self):
		self.is_inited = False
		self.time_last = 0
		self.clock_seq = 0
		self.uuids_per_tick = 0
		
	def load(self):
		"""supposed to read state from storage"""
		#try:
		#	read state from storage
		#	self.is_inited = True
		#except:
		#	self.clock_seq = _getrandbits(14)
		#	self.is_inited = False
		self.clock_seq = _getrandbits(14)
			
	def dump(self):
		"""supposed to dump state to storage"""
		
						
####################
#                                               #
# uuid generator                     #
#                                               #
####################

class UuidGen(object):
	
	
	def __init__(self):
		
		self._state = _GeneratorState()
		
		
		# public methods -----------------------------------------------------------
	
	def uuid_time(self):
		time_now = self._get_time_now()
		clock_seq = self._state.clock_seq
				
		time_low = time_now & 0xFFFFFFFFL
		time_mid = (time_now >> 32) & 0xFFFF
		time_hi_and_version = (time_now>> 48)	& 0x0FFFF
		node = _getrandbits(47)						# throw in random bits instead of MAC address
		node |= (1 << 47)								# set unicast/multicast bit	
		
		# put in variant and version bits
		time_hi_and_version |= (1 << 12)	
		clock_seq_low = clock_seq &	0xFF
		clock_seq_hi_and_reserved = (clock_seq & 0x3F00) >> 8
		clock_seq_hi_and_reserved |= 0x80
				
		return self._format(time_low, time_mid, time_hi_and_version, 
										clock_seq_hi_and_reserved, clock_seq_low, node)
		

	def uuid_random(self):
		rnd = _getrandbits(128)
		time_low = rnd & 0xFFFFFFFFL
		time_mid = (rnd >> 32) & 0x0FFFF
		time_hi_and_version = (rnd >> 48) & 0x0FFFF
		clock_seq_hi_and_reserved = (rnd >> 64) & 0x0FF
		clock_seq_low= (rnd >> 72) & 0x0FF
		node = (rnd >> 80)
							
		# put in variant and version bits
		time_hi_and_version &= 0x0FFF;
		time_hi_and_version |= (4 << 12)
		clock_seq_hi_and_reserved &= 0x3F
		clock_seq_hi_and_reserved |= 0x80
		
		return self._format(time_low, time_mid, time_hi_and_version, 
										clock_seq_hi_and_reserved, clock_seq_low, node)		
		
				
	def uuid_md5(self, nsuuid, name):
		return self._format_uuid_v3or5(nsuuid, name, _md5, 3)
		
	
	def uuid_sha1(self, nsuuid, name):
		return self._format_uuid_v3or5(nsuuid, name, _sha, 5)

		
	# helper methods --------------------------------------------------------
	
	def _format(self, *args):
		return '{%08x-%04x-%04x-%02x%02x-%012x}' % args
	
	
	def _int_to_bytes(self, num):
		out = ''
		while num:
			num, tail = divmod(num, 256)
			out += chr(tail)
		return out[-1::-1]
		
	
	def _bytes_to_int(self, bytes):
		num = 0
		for char in bytes:
			num = (num << 8) + ord(char)
		return num
		
	
	# helper for md5 and sha1 UUIDS
	def _format_uuid_v3or5(self, nsuuid, name, hasher, ver):
		try:
			nsuuid = clean(nsuuid)
		except:
			raise UuidError('invalid namespace uuid: %r' % nsuuid)
		# convert UUID bytes to network byte order
		time_low = _htonl(long(nsuuid[:8], 16))
		time_mid = _htons(long(nsuuid[9:13], 16))
		time_hi_and_version = _htons(long(nsuuid[14:18], 16))
		
		# hash the stuff
		h = hasher.new()
		h.update(self._int_to_bytes(time_low))
		h.update(self._int_to_bytes(time_mid))
		h.update(self._int_to_bytes(time_hi_and_version))
		h.update(name)
		hash_ = h.digest()[:16]
						
		# convert hash to back to host byte order
		time_low = _ntohl(self._bytes_to_int(hash_[:4]))
		time_mid = _ntohs(self._bytes_to_int(hash_[4:6]))
		time_hi_and_version = _ntohs(self._bytes_to_int(hash_[6:8]))
		clock_seq_hi_and_reserved = _ntohs(self._bytes_to_int(hash_[8:9]))
		clock_seq_low= self._bytes_to_int(hash_[9:10])
		node = self._bytes_to_int(hash_[10:])
				
		# throw in variant and version bits
		time_hi_and_version &= 0x0FFF;
		time_hi_and_version |= (ver << 12)
		clock_seq_hi_and_reserved &= 0x3F
		clock_seq_hi_and_reserved |= 0x80
				
		return self._format(time_low, time_mid, time_hi_and_version, 
										clock_seq_hi_and_reserved, clock_seq_low, node)
		
	
	
	# returns a new timestamp for time based UUIDs
	def _get_time_now(self):
		
		self._state.load()
				
		while True:
			
			time_now = _time.time() * 10000000 
			
			if time_now < self._state.time_last - self._state.uuids_per_tick:	# adjust clock_seq if time turned backwards
				if self._state.is_inited:
					self._state.clock_seq += 1
					if self._state.clock_seq > self._state.CLOCK_SEQ_MAX:
						self._state.clock_seq = 0
				self._state.uuids_per_tick = 0
				break
			
			elif time_now <= self._state.time_last:	# patch/slow down if more then 1 uuid is requested/tick
				self._state.uuids_per_tick += 1
				if self._state.uuids_per_tick < self._state.UUIDS_PER_TICK:
					time_now += self._state.uuids_per_tick
					break
			
			else:
				self._state.uuids_per_tick = 0
				break
		
		##
		self._state.time_last = time_now
		self._state.dump()
		return long(time_now) + self._state.TDELTA	
	
		

####################
#                                               #
#   functions                             #
#                                               #
####################

def uuid_time(): 
	return UuidGen().uuid_time()


def uuid_random(): 
	return UuidGen().uuid_random()


def uuid_md5(nsuuid, name): 
	return UuidGen().uuid_md5(nsuuid, name)


def uuid_sha1(nsuuid, name): 
	return UuidGen().uuid_sha1(nsuuid, name)


def clean(uuid):
	match = UUID_PAT.match(uuid)
	if not match:
		raise ValueError('invalid UUID: %r' % uuid)
	return match.group(1)

UUID_PAT = _re.compile(r'''
	.*?
	([0-9a-f]{8}\-[0-9a-f]{4}\-[0-9a-f]{4}\-[0-9a-f]{4}\-[0-9a-f]{12})
	.*?
	''', _re.I|_re.X)	


def get_variant(uuid):
	uuid = clean(uuid)
	variant = long(uuid[19:21], 16)
	if not variant & 0x80:
		return VARIANT_NCS
	elif not variant & 0x40 and variant & 0x80:
		return VARIANT_RFC4122
	elif not variant & 0x20 and variant & 0x40 and variant & 0x80:
		return VARIANT_MS
	elif variant & 0x20 and variant & 0x40 and variant & 0x80:
		return VARIANT_FUTURE
	else:
		return VARIANT_UNKNOWN


def get_version(uuid):
	uuid = clean(uuid)
	time_hi_and_version = long(uuid[14:18], 16)
	version =  time_hi_and_version >> 12
	if 1 < version > 5:
		version = VERSION_UNKNOWN
	return version


def get_time(uuid):
	uuid = clean(uuid)
	time_low = long(uuid[:8], 16)
	time_mid = long(uuid[9:13], 16)
	time_hi_and_version = long(uuid[14:18], 16)
	variant = long(uuid[19:21], 16)
	version =  time_hi_and_version >> 12
	if version == 1 and(variant & 0x80) and not (variant & 0x40):
		time_hi_and_version &= ~(version << 12)
		time_now = time_low | (time_mid << 32) | (time_hi_and_version << 48)
		return 	(float(time_now) - _GeneratorState.TDELTA) /10000000
	return 0
		
	
def get_mac_address(uuid):
	uuid = clean(uuid)
	node = long(uuid[24:], 16)
	time_hi_and_version = long(uuid[14:18], 16)
	variant = long(uuid[19:21], 16)
	version =  time_hi_and_version >> 12
	if version == 1 and(variant & 0x80) and not (variant & 0x40):
		return node
	return 0
	

def format_mac_address(mac_addr):
	return '%02x-%02x-%02x-%02x-%02x-%02x' % (
				(mac_addr & 0xFF0000000000) >> 40,
				(mac_addr & 0xFF00000000)>> 32,
				(mac_addr & 0xFF000000) >> 24,
				(mac_addr & 0xFF0000) >> 16,
				(mac_addr& 0xFF00) >> 8,
				mac_addr & 0xFF
				)

####################
#                                             #
#   commandline interface   #
#                                             #
####################

if __name__ == '__main__': 
	import sys
	import getopt
	
	
	USAGE = """'generates a UUID of the specified type and prints it to stdout

usage:
    uuid.py [-h] [-t <type> [-s <namespace uuid> -n <name>]]

    -h        prints out this help message
    -t         type of uuid (time, random, md5, sha1)
    -s        namespace uuid (required for md5 or sha1)
    -n        name (required for md5 or sha1)
"""
	try:
		o, args = getopt.getopt(sys.argv[1:], 'ht:s:n:')
		o = dict(o)
		if '-h' in o:
			print USAGE
		else:	
			type_uuid = o.get('-t', None)
			if type_uuid == 'time':
				print uuid_time()
			elif type_uuid == 'random':
				print uuid_random()
			elif type_uuid == 'md5':
				print uuid_md5(o['-s'], o['-n'])
			elif type_uuid == 'sha1':
				print uuid_sha1(o['-s'], o['-n'])
			else:
				raise UuidError('')
	except:
		print USAGE
	sys.exit()	

####################
#                                             #
#   test                                   #
#                                             #
####################

def test():
	g = globals().items()
	variants = dict([(value, name) for name, value in g \
								if name.startswith('VARIANT_')])
	versions = dict([(value, name) for name, value in g \
								if name.startswith('VERSION_')])
			
	UUIDS = (
		uuid_time(),
		uuid_random(),
		uuid_md5(NAMESPACE_DNS, 'foo'),
		uuid_sha1(NAMESPACE_DNS, 'bar'),
		)
			
	print
	for UUID in (UUIDS):
		print 'UUID:      %r' % UUID
		print 'variant:    ', variants.get(get_variant(UUID), 'unknown')
		print 'verson:    ', versions.get(get_version(UUID), 'unknown')
		print 'time:        ', _time.ctime(get_time(UUID)), '(%ss since epoch)' \
										% get_time(UUID)
		print 'MAC:         %s' % format_mac_address(get_mac_address(UUID))
		print

#test()	

--- NEW FILE: jahlogo.png ---

--- NEW FILE: python_binding_unittest.py ---
#!/usr/bin/env python

# python_bindings_unittest.py

# Copyright (C) 2005-2006 Visual Media FX Ltd.
# Released under the LGPL.
# For more information, see http://www.openlibraries.org.

import platform
import sys
import os.path
import shutil

if platform.system( ) == "Linux":
	import dl
	sys.setdlopenflags( dl.RTLD_NOW | dl.RTLD_GLOBAL )

import openpluginlib
import openimagelib
import openassetlib as oal
import uuid				# http://home.arcor.de/jurner/python/uuid/dist/uuid-0.3.2.tar.gz

# define guid generator class acceptable to oal
class uuid_generator(oal.guid_generator):
	def generate_guid(self):
		return uuid.uuid_time()
	
def print_asset_content( asset ):
	print "\n\tGUID: ", asset.guid()
	if asset.size() == 0:
		print "\tContains no metadata"
	else:
		print "\t", asset.size(), " associated pieces of metadata"
		for metadata in asset:
			print "\t\t", metadata.first, "\t:\t", metadata.second

def print_set_content( set ):
	print "set name: \"%s\"" % set.name()
	if set.size() == 0:
		print "No Hits!"
	else:
		print "Got ", set.size(), " hits:"
		for a in set:
			print_asset_content(a)

def print_is_convertible( asset ):
	if oal.is_convertible(asset) == True:
		print "\nasset is convertible"
	else:
		print "\nasset isn't convertible"
		
	
#
# Main method
#

def main( ):
	print 'Commencing exercise of openassetlib python bindings...'
	oal.init(uuid_generator())
	
	guid = oal.generate_guid()
	print 'generate_guid: %s' % guid
	
	########################
	print '\ncreating asset 1'
	asset1 = oal.create_asset()
	if asset1 is None:
		print '\tFailed'
	else:
		print '\tSucceeded'
	print_asset_content(asset1)
	
	print 'Changing the GUID...'
	print 'get_guid\t->\t', asset1.guid()
	guid = str('GUID-1')
	asset1.guid(guid)
	print 'set_guid\t<-\t', guid
	print 'get_guid\t->\t', asset1.guid()
	
	print "\tadding metadata..."
	asset1.set("a_bool", True)
	asset1.set("a_string", "Hello :-)")
	asset1.set("an_int", int(12345))
	asset1.set("a_long", long(1234567890))
	asset1.set("a_float", float(3.14159265))
	print_asset_content(asset1)
	
	print '\n\nFinding a_string metadata: %s\n\n' % asset1.find("a_string").second

	########################
	print '\nCreating asset 2 from asset1'
	asset2 = oal.create_asset(asset1)
	if asset2 is None:
		print '\tFailed'
	else:
		print '\tSucceeded'
	print_asset_content(asset2)
	
	print "\tmodifiying metadata & guid..."
	asset2.guid(str('GUID-2'))
	asset2.set("a_bool", False)
	asset2.set("a_string", "I'm a number 2!")
	asset2.set("an_int", int(9876543210))
	asset2.set("a_long", long(98765))
	asset2.set("a_float", float(0.0123456789))
	print_asset_content(asset2)

	########################
	print '\ncreating asset 3'
	#asset3 = oal.create_asset("c:\\Media\\images\\jahlogo.png")
	asset3 = oal.create_asset(os.path.join(os.getcwd(), "jahlogo.png"))
	print 'dir = %s' % os.path.join(os.getcwd(), "jahlogo.png")
	print asset3.get('location')
	print asset3.get('filename')
	asset3.set('location', 'c:\\sandbox\\openlibraries\\test\\openassetlib\\python_bindings_unittest')
	asset3.set('filename', 'jahlogo.png')
	print asset3.get('location')
	print asset3.get('filename')
	
	if asset3 is None:
		print '\tFailed'
	else:
		print '\tSucceeded'
		
	print_asset_content(asset3)
	print "\tadding extra metadata and modifiying guid..."
	asset3.guid(str('GUID-3'))
	asset3.set("a_string", "Three")
	print_asset_content(asset3)

	########################
	print '\ncreating asset 4'
	asset4 = oal.create_asset()
	if asset4 is None:
		print '\tFailed'
	else:
		print '\tSucceeded'

	asset4.guid(str('GUID-4'))
	asset4.set("a_string", "Four")
	print_asset_content(asset4)

	########################
	print '\ncreating asset 5'
	asset5 = oal.create_asset()
	if asset5 is None:
		print '\tFailed'
	else:
		print '\tSucceeded'
		
	asset5.guid(str('GUID-5'))
	asset5.set("a_string", "Five")
	print_asset_content(asset5)

	########################
	print '\ncreating asset 6'
	asset6 = oal.create_asset()
	if asset6 is None:
		print '\tFailed'
	else:
		print '\tSucceeded'
		
	asset6.guid(str('GUID-6'))
	asset6.set("a_string", "Six")
	print_asset_content(asset6)
	
	########################
	print '\nCreating some sets of assets...'
	print '\nCreating set1'
	set1 = oal.create_set(str("name for set1"))
	print '\tset name = %s' % set1.name()
	set1.name("set1's name")
	print '\tset name = %s' % set1.name()
	print 'Size of set1 = %d' % set1.size()
	if set1.empty() is True:
		print 'set1 is empty'
	else:
		print 'set1 is not empty'
		
	print 'pushing some assets onto back...'
	set1.push_back(asset1)
	set1.push_back(asset2)
	set1.push_back(asset3)
	set1.push_back(asset4)
	
	print 'Size of set1 = %d' % set1.size()
	if set1.empty() is True:
		print 'set1 is empty'
	else:
		print 'set1 is not empty'

	print 'List of assets:'	
	for a in set1:
		print "\t", a.guid()
		
	print "Asset at offset 0: ", set1.at(0).guid()
	print "Asset at offset 3: ", set1.at(3).guid()
	
	######################
	print '\ncreating set2 with asset3'
	set2 = oal.create_set(asset3, str("set2's name"))
	print '\tset name = %s' % set2.name()
	print 'Size of set2 = %d' % set2.size()
	if set2.empty() is True:
		print 'set2 is empty'
	else:
		print 'set2 is not empty'
		
	print 'pushing some assets onto back...'
	set2.push_back(asset4)
	set2.push_back(asset5)
	set2.push_back(asset6)

	print 'List of assets:'	
	for a in set2:
		print "\t", a.guid()
	
	######################
	print '\ncreating set3 with set1'
	set3 = oal.create_set(set1, str("set3's name"))
	print '\tset name = %s' % set3.name()
	print 'List of assets:'	
	for a in set3:
		print "\t", a.guid()
	print 'popping the last asset off the back...'
	set3.pop_back()
	print 'List of assets:'	
	for a in set3:
		print "\t", a.guid()
	print 'Inserting asset6 at offset 1'
	set3.insert(asset6, 1)
	print 'List of assets:'	
	for a in set3:
		print "\t", a.guid()
	print 'Inserting set1 at offset 3'
	set3.insert(set1, 3)
	print 'List of assets:'	
	for a in set3:
		print "\t", a.guid()
	print '\nRemoving asset6'
	set3.remove(asset6)
	print 'List of assets:'	
	for a in set3:
		print "\t", a.guid()
	
	######################
	print '\ncreating set4 with set1'
	set4 = oal.create_set(set1)
	print 'List of assets:'	
	for a in set4:
		print "\t", a.guid()
	print '\nClearing set'
	set4.clear()
	print 'List of assets:'	
	if set4.empty() == 0:
		print '\tEMPTY!'
	else:
		for a in set4:
			print "\t", a.guid()
	
	########################################################
	print "\nIntersection of set1 and set2:"
	intersection_set = oal.calculate_intersection(set1, set2)
	print_set_content(intersection_set)

	print "\nIntersection of set1 and set3:"
	intersection_set = oal.calculate_intersection(set1, set3)
	print_set_content(intersection_set)

	print "\nIntersection of set2 and set3:"
	intersection_set = oal.calculate_intersection(set2, set3)
	print_set_content(intersection_set)

	print "\nDifference between set1 and set2:"
	difference_set = oal.calculate_difference(set1, set2)
	print_set_content(difference_set)

	print "\nDifference between set1 and set3:"
	difference_set = oal.calculate_difference(set1, set3)
	print_set_content(difference_set)

	print "\nDifference between set2 and set3:"
	difference_set = oal.calculate_difference(set2, set3)
	print_set_content(difference_set)

	print "\nUnion of set1 and set2:"
	union_set = oal.calculate_union(set1, set2)
	print_set_content(union_set)

	print "\nUnion of set1 and set3:"
	union_set = oal.calculate_union(set1, set3)
	print_set_content(union_set)

	print "\nUnion of set2 and set3:"
	union_set = oal.calculate_union(set2, set3)
	print_set_content(union_set)
	
	###################################
	print "\nSearching set3 for a_string = Hello :-)"
	predicate = oal.key_value_regex_search_predicate("a_.*", "Hello :-\)")
	search_results_set = oal.search(set3, predicate)
	print_set_content(search_results_set)
	
	###################################
	print "\nSearching set3 for all png files"
	search_results_set = oal.search(set3, oal.location_filename_regex_predicate(".*", ".*.png"))
	print_set_content(search_results_set)
	
	###################################
	print_is_convertible(asset3)
	image = oal.convert_to_image(asset3)
	if image is None:
		print 'Failed to convert asset3 to image object'
	else:
		print 'Successfully converted asset3 to image object'
		print 'asset3 width = %s' % asset3.get("width")
		print 'asset3 height = %s' % asset3.get("height")
	
	###################################
	asset4.set("location", "C:/Media/")
	asset4.set("filename", "Donkey.mpeg")
	print_is_convertible(asset4)
	media = oal.convert_to_media(asset4) # Note: Cos oml is not exported as yet, there is convert_to_media in the bindings returns void!
	if media is None:
		print 'Failed to convert asset4 to media object'
	else:
		print 'Successfully converted asset4 to media object'
	print 'asset4 width = %s' % asset4.get("width")
	print 'asset4 height = %s' % asset4.get("height")
	print 'asset4 frames = %s' % asset4.get("frames")
	print 'asset4 video_streams = %s' % asset4.get("video_streams")
	print 'asset4 audio_streams = %s' % asset4.get("audio_streams")
	print 'asset4 fps = %s' % asset4.get("fps")
	print 'asset4 sar = %s' % asset4.get("sar")
	
	search_root_dir = oal.generate_guid()
	os.mkdir(search_root_dir)
	print search_root_dir
	
	full_search_root_dir = os.path.join(os.getcwd(), search_root_dir)
	print full_search_root_dir
	
	full_image_dir = os.path.join(full_search_root_dir, "image")
	os.mkdir(full_image_dir)
	print full_image_dir
	
	full_image2_dir = os.path.join(full_search_root_dir, "image2")
	os.mkdir(full_image2_dir)
	print full_image2_dir
	
	#copy jahlogo.png to newly created test folder
	shutil.copy("jahlogo.png", os.path.join(full_image_dir, "jahlogo.png"))
	shutil.copy("jahlogo.png", os.path.join(full_image2_dir, "jahlogo.png"))
	
	##############################################
	x = openpluginlib.discovery( openpluginlib.all_query_traits( "openassetlib", "", "filesystem", 0 ) )
	if x.size() == 0:
		print "No plugins discovered!"
	else:
		for y in x:
			print y.libname(), ':', y.name(), y.merit()
 			fs_plugin = y.create_plugin("")
 			print fs_plugin
 			if fs_plugin is None:
 				print "Failed to create filesystem plugin"
 			else:
 				print "Successfully created filesystem plugin!  :-)"
 				break
 			
	print "Searching for .png files in root of test folders (non-recursive)"
	fs_search_set1 = oal.search(fs_plugin, ".*\.png", full_search_root_dir, False)
	print fs_search_set1
	print_set_content(fs_search_set1)
	
	print "Searching for .png files in root of test folders (recursive)"
	fs_search_set2 = oal.search(fs_plugin, ".*\.png", full_search_root_dir, True)
	print fs_search_set2
	print_set_content(fs_search_set2)
	
	try:
		for root, dirs, files in os.walk(search_root_dir, topdown=False):
			for name in files:
				os.remove(os.path.join(root, name))
			for name in dirs:
				os.rmdir(os.path.join(root, name))
		os.rmdir(search_root_dir) 
	except OSError:
		print 'OSError caught'
		pass

	
	##############################################
	x = openpluginlib.discovery( openpluginlib.all_query_traits( "openassetlib", "", "sqlite", 0 ) )
	if x.size() == 0:
		print "No plugins discovered!"
	else:
		for y in x:
			print y.libname(), ':', y.name(), y.merit()
 			db_plugin = y.create_plugin("")
 			print db_plugin
 			if db_plugin is None:
 				print "Failed to create sqlite database plugin"
 			else:
 				print "Successfully created sqlite database plugin!  :-)"
 				break

	store_set = oal.create_set()
	store_set.push_back(asset3)
	store_set.push_back(asset4)
	
	oal.store_image(asset4, image, "jahlogo.png")
	
	failed_to_store_set = oal.store(db_plugin, store_set)
	if failed_to_store_set is None:
		print '\nSet successfully stored'
	else:
		print 'The following assets failed to get stored in the db..'
		for failed_asset in failed_to_store_set:
			print '\t%s' % failed_asset.guid()
		print '\n'
		
	restore_set = oal.create_set()
	
	asset_to_restore1 = oal.create_asset()
	asset_to_restore1.guid("GUID-3")
	restore_set.push_back(asset_to_restore1)
	
	asset_to_restore2 = oal.create_asset()
	asset_to_restore2.guid("GUID-4")
	restore_set.push_back(asset_to_restore2)
	
	restored_set = oal.restore(db_plugin, restore_set)
	if restored_set is None:
		print '\nSet failed to restored'
	else:
		print 'Successfully restored assets...'
		print_set_content(restored_set)
		
	image2 = oal.restore_image(restored_set.at(1), "jahlogo.png")
	if image2 is None:
		print 'Failed to restore image'
	else:
		print 'Successfully restored image'
	
	##############################################
	set_to_save = oal.create_set(str("abc123xyz"))
	set_to_save.push_back(asset1)
	set_to_save.push_back(asset2)
	print '\nSaving following set...'
	print_set_content(set_to_save)
	xmlfilename = "test_set.xml"
	if oal.save_set(db_plugin, xmlfilename, set_to_save) is False:
		print 'Failed to save set'
	else:
		print 'Set saved'
	
	print '\nLoading set from %s...' % xmlfilename
	loaded_set = oal.load_set(db_plugin, xmlfilename)
	if loaded_set is None:
		print 'Failed to load set'
	else:
		print 'Loaded set...'
		print_set_content(loaded_set)

	oal.uninit()
	print '\nExercises complete - please check results for anomalies!'
	

#
# Run the main method if required
#

if __name__ == "__main__":
	main( )