new_contents: # -*- coding: utf-8 -*-
  import vimbastructure as structs
  from vimbadll import VimbaDLL
  from vimbaexception import VimbaException
  from vimbacamera import VimbaCamera
  from ctypes import *
  
  class Vimba(object):
  	"""
  	An Allied Vision Technology Vimba API.
  	This API provides access to AVT cameras.
  	"""
  	
  	# todo - assign camera info and feature info as own object proeprties
  	
  	def __init__(self):
  		
  		# list of VimbaCameraInfo objects
  		# can't be called before startup() so populate later
  		self._cameraInfos = None
  		
  		# dict of {camera ID : VimbaCamera object} as we don't want to forget them
  		self._cameras = {}
  		
  	def _getCameraInfos(self):
  		"""
  		Gets camera info of all attached cameras.
  		
  		:returns: list -- camera info for available cameras.
  		"""
  		if self._cameraInfos is None:
  			# args
  			dummyCameraInfo = structs.VimbaCameraInfo()	 
  			numFound = c_uint32(-1)
  			
  			# call once just to get the number of cameras
  			# Vimba DLL will return an error code
  			errorCode = VimbaDLL.camerasList(byref(dummyCameraInfo),
  											 0,
  											 byref(numFound),
  											 sizeof(dummyCameraInfo))
  			if errorCode != 0:
  				print errorCode
  				raise VimbaException(errorCode)
  			
  			numCameras = numFound.value
  			
  			# args
  			cameraInfoArray = (structs.VimbaCameraInfo * numCameras)()
  		
  			# call again to get the features
  			# Vimba DLL will return an error code
  			errorCode = VimbaDLL.camerasList(cameraInfoArray,
  											 numCameras,
  											 byref(numFound),
  											 sizeof(dummyCameraInfo))
  			if errorCode != 0:
  				raise VimbaException(errorCode)
  			self._cameraInfos = list(camInfo for camInfo in cameraInfoArray)
  		return self._cameraInfos
  	
  	def getCameraIds(self):
  		"""
  		Gets IDs of all available cameras.
  		
  		:returns: list -- camera IDs for available cameras.
  		"""
  		return list(camInfo.cameraIdString for camInfo in self._getCameraInfos())
  	
  	def getCameraInfo(self, cameraId):
  		"""
  		Gets camera info object of specified camera.
  		
  		:param cameraId: the ID of the camera object to get.
  		
  		:returns: VimbaCameraInfo object -- the camera info object specified.
  		"""
  		# don't do this live as we already have this info
  		# return info object if it exists
  		for camInfo in self._getCameraInfos():
  			if camInfo.cameraIdString == cameraId:
  				return camInfo
  		# otherwise raise error
  		raise VimbaException(-50)
  		
  	def getCamera(self, cameraId):
  		"""
  		Gets camera objects based on camera ID string. Will not recreate
  		camera object if it already exists.
  		
  		:param cameraId: the ID of the camera.
  		
  		:returns: VimbaCamera object -- the camera object specified.		
  		"""
  		# check ID is valid
  		if cameraId in self.getCameraIds():
  			# create it if it doesn't exist
  			if cameraId not in self._cameras:
  				self._cameras[cameraId] = VimbaCamera(cameraId)
  			return self._cameras[cameraId]
  		raise VimbaException(-50)
  
  	def getVersion(self):
  		"""
  		Retrieve the version number of VimbaC.
  		
  		:returns: string - Vimba API version info.
  		"""
  		# args
  		versionInfo = structs.VimbaVersion()
  		
  		# Vimba DLL will return an error code
  		errorCode = VimbaDLL.versionQuery(versionInfo,
  										  sizeof(versionInfo))
  		if errorCode != 0:
  			raise VimbaException(errorCode)
  		
  		versionStr = '.'.join([str(versionInfo.major),
  							   str(versionInfo.minor),
  							   str(versionInfo.patch)])
  		return versionStr
  		
  	def startup(self):
  		"""
  		Initialize the VimbaC API.
  		"""
  		# Vimba DLL will return an error code
  		errorCode = VimbaDLL.startup()
  		if errorCode != 0:
  			raise VimbaException(errorCode)
  		
  	def shutdown(self):
  		"""
  		Perform a shutdown on the API.
  		"""
  		VimbaDLL.shutdown()
  
subject: Create vimba.py