# Used to split up requests into batches of records_per_page when doing requests. this helps speed tremendously

# when getting lots of results back. doesn't affect the interface of the api at all (you always get the full set

# of results back as one array) but just how the client class communicates with the server.

records_per_page = 500

schema_expire_mins = 60

def __init__(self, base_url, script_name, api_key, convert_datetimes_to_utc=True, http_proxy=None):

"""

self.server = None

if base_url.split("/")[0] not in ("http:","https:"):

raise ShotgunError("URL protocol must be http or https. Value was '%s'" % base_url)

self.base_url = "/".join(base_url.split("/")[0:3]) # cheesy way to strip off anything past the domain name, so:

# http://blah.com/asd => http://blah.com

self.script_name = script_name

self.api_key = api_key

self.api_ver = 'api3'

self.api_url = "%s/%s/" % (self.base_url, self.api_ver)

self.convert_datetimes_to_utc = convert_datetimes_to_utc

self.sid = None # only load this if needed

self.http_proxy = http_proxy

server_options = {

'server_url': self.api_url,

'script_name': self.script_name,

'script_key': self.api_key,

'http_proxy' : self.http_proxy,

'convert_datetimes_to_utc': self.convert_datetimes_to_utc

}

self._api3 = ShotgunCRUD(server_options)

self.server_info = self._api3.info()

self._determine_features()

self.local_path_string = None

self.platform = self._determine_platform()

if self.platform:

self.local_path_string = "local_path_%s" % (self.platform)

def _determine_features(self):

self.supports_paging_info = False

if self.server_info.has_key('version'):

v = self.server_info['version']

else:

return

if v[0] == 2 and v[1] == 3 and v[2] >= 4:

self.supports_paging_info = True

elif v[0] >= 2 and v[1] >= 4:

self.supports_paging_info = True

def _determine_platform(self):

s = platform.system().lower()

if s in ['windows','linux','darwin']:

if s == 'darwin':

return 'mac'

else:

return s

return None

def _inject_field_values(self, records):

"""

if len(records) == 0:

return records

for i,r in enumerate(records):

# skip results that aren't entity dictionaries

if type(r) is not dict:

continue

# iterate over each item and check each field for possible injection

for k, v in r.items():

# check for thumbnail

if k == 'image' and v:

records[i]['image'] = self._get_thumb_url(r['type'], r['id'])

if type(v) == dict and 'link_type' in v and v['link_type'] == 'local' \

and self.platform and self.local_path_string in r[k]:

records[i][k]['local_path'] = r[k][self.local_path_string]

records[i][k]['url'] = "file://%s" % (r[k]['local_path'])

return records

def _get_thumb_url(self, entity_type, entity_id):

"""

url = self.base_url + "/upload/get_thumbnail_url?entity_type=%s&entity_id=%d"%(entity_type,entity_id)

for i in range(3):

f = urllib.urlopen(url)

response_code = f.readline().strip()

# something else happened. try again. found occasional connection errors still spit out html but not

# the correct response codes. usually trying again will right the ship. if not, we catch for it later.

if response_code not in ('0','1'):

continue

elif response_code == '1':

path = f.readline().strip()

if path:

return self.base_url + path

elif response_code == '0':

break

# if it's an error, message is printed on second line

raise ValueError, "%s:%s " % (entity_type,entity_id)+f.read().strip()

def set_session_uuid(self, session_uuid):

server_options = {

'server_url': self.api_url,

'script_name': self.script_name,

'script_key': self.api_key,

'http_proxy' : self.http_proxy,

'convert_datetimes_to_utc': self.convert_datetimes_to_utc,

'session_uuid': session_uuid

}

self._api3 = ShotgunCRUD(server_options)

def schema_read(self):

resp = self._api3.schema_read()

return resp["results"]

def schema_field_read(self, entity_type, field_name=None):

args = {

"type":entity_type

}

if field_name:

args["field_name"] = field_name

resp = self._api3.schema_field_read(args)

return resp["results"]

def schema_field_create(self, entity_type, data_type, display_name, properties=None):

if properties == None:

properties = {}

args = {

"type":entity_type,

"data_type":data_type,

"properties":[{'property_name': 'name', 'value': display_name}]

}

for f,v in properties.items():

args["properties"].append( {"property_name":f,"value":v} )

resp = self._api3.schema_field_create(args)

return resp["results"]

def schema_field_update(self, entity_type, field_name, properties):

args = {

"type":entity_type,

"field_name":field_name,

"properties":[]

}

for f,v in properties.items():

args["properties"].append( {"property_name":f,"value":v} )

resp = self._api3.schema_field_update(args)

return resp["results"]

def schema_field_delete(self, entity_type, field_name):

args = {

"type":entity_type,

"field_name":field_name

}

resp = self._api3.schema_field_delete(args)

return resp["results"]

def schema_entity_read(self):

resp = self._api3.schema_entity_read()

return resp["results"]

def find(self, entity_type, filters, fields=None, order=None, filter_operator=None, limit=0, retired_only=False, page=0):

"""

if fields == None:

fields = ['id']

if order == None:

order = []

if type(filters) == type([]):

new_filters = {}

if not filter_operator or filter_operator == "all":

new_filters["logical_operator"] = "and"

else:

new_filters["logical_operator"] = "or"

new_filters["conditions"] = []

for f in filters:

new_filters["conditions"].append( {"path":f[0],"relation":f[1],"values":f[2:]} )

filters = new_filters

elif filter_operator:

raise ShotgunError("Deprecated: Use of filter_operator for find() is not valid any more. See the documention on find()")

if retired_only:

return_only = 'retired'

else:

return_only = 'active'

req = {

"type": entity_type,

"return_fields": fields,

"filters": filters,

"return_only" : return_only,

"paging": {"entities_per_page": self.records_per_page, "current_page": 1}

}

if self.supports_paging_info:

req["return_paging_info"] = True

if order:

req['sorts'] = []

for sort in order:

if sort.has_key('column'):

# TODO: warn about deprecation of 'column' param name

sort['field_name'] = sort['column']

if not sort.has_key('direction'):

sort['direction'] = 'asc'

req['sorts'].append({'field_name': sort['field_name'],'direction' : sort['direction']})

if type(limit) != int or limit < 0:

raise ValueError("find() 'limit' parameter must be a positive integer")

elif (limit and limit > 0 and limit <= self.records_per_page):

req["paging"]["entities_per_page"] = limit

# If page isn't set and the limit doesn't require pagination, then trigger the

# faster code path.

if page == 0:

page = 1

records = []

# if page is specified, then only return the page of records requested

if type(page) != int or page < 0:

raise ValueError("find() 'page' parameter must be a positive integer")

elif page != 0:

# No paging_info needed, so optimize it out.

if self.supports_paging_info:

req["return_paging_info"] = False

req["paging"]["current_page"] = page

resp = self._api3.read(req)

results = resp["results"]["entities"]

records.extend(results)

else:

done = False

while not done:

resp = self._api3.read(req)

results = resp["results"]["entities"]

if results:

records.extend(results)

if ( len(records) >= limit and limit > 0 ):

records = records[:limit]

done = True

elif len(records) == resp["results"]["paging_info"]["entity_count"]:

done = True

else:

req['paging']['current_page'] += 1

else:

done = True

records = self._inject_field_values(records)

return records

def find_one(self, entity_type, filters, fields=None, order=None, filter_operator=None, retired_only=False):

"""

result = self.find(entity_type, filters, fields, order, filter_operator, 1, retired_only)

if len(result) > 0:

return result[0]

else:

return None

def _required_keys(self, message, required_keys, data):

missing = set(required_keys) - set(data.keys())

if missing:

raise ShotgunError("%s missing required key: %s. Value was: %s." % (message, ", ".join(missing), data))

def batch(self, requests):

if type(requests) != type([]):

raise ShotgunError("batch() expects a list. Instead was sent a %s"%type(requests))

reqs = []

for r in requests:

self._required_keys("Batched request",['request_type','entity_type'],r)

if r["request_type"] == "create":

self._required_keys("Batched create request",['data'],r)

nr = {

"request_type": "create",

"type": r["entity_type"],

"fields": []

}

if "return_fields" in r:

nr["return_fields"] = r

for f,v in r["data"].items():

nr["fields"].append( { "field_name": f, "value": v } )

reqs.append(nr)

elif r["request_type"] == "update":

self._required_keys("Batched create request",['entity_id','data'],r)

nr = {

"request_type": "update",

"type": r["entity_type"],

"id": r["entity_id"],

"fields": []

}

for f,v in r["data"].items():

nr["fields"].append( { "field_name": f, "value": v } )

reqs.append(nr)

elif r["request_type"] == "delete":

self._required_keys("Batched delete request",['entity_id'],r)

nr = {

"request_type": "delete",

"type": r["entity_type"],

"id": r["entity_id"]

}

reqs.append(nr)

else:

raise ShotgunError("Invalid request_type for batch")

resp = self._api3.batch(reqs)

records = self._inject_field_values(resp["results"])

return records

def create(self, entity_type, data, return_fields=None):

"""

if return_fields == None:

return_fields = ['id']

args = {

"type":entity_type,

"fields":[],

"return_fields":return_fields

}

for f,v in data.items():

args["fields"].append( {"field_name":f,"value":v} )

resp = self._api3.create(args)

record = self._inject_field_values([resp["results"]])[0]

return record

def update(self, entity_type, entity_id, data):

"""

args = {"type":entity_type,"id":entity_id,"fields":[]}

for f,v in data.items():

args["fields"].append( {"field_name":f,"value":v} )

resp = self._api3.update(args)

records = self._inject_field_values([resp["results"]])

return records

def delete(self, entity_type, entity_id):

"""

resp = self._api3.delete( {"type":entity_type, "id":entity_id} )

return resp["results"]

def revive(self, entity_type, entity_id):

"""

resp = self._api3.revive( {"type":entity_type, "id":entity_id} )

return resp["results"]

def upload(self, entity_type, entity_id, path, field_name=None, display_name=None, tag_list=None):

"""

is_thumbnail = (field_name == "thumb_image")

params = {}

params["entity_type"] = entity_type

params["entity_id"] = entity_id

# send auth, so server knows which

# script uploaded the file

params["script_name"] = self.script_name

params["script_key"] = self.api_key

if not os.path.isfile(path):

raise ShotgunError("Path must be a valid file.")

url = "%s/upload/upload_file" % (self.base_url)

if is_thumbnail:

url = "%s/upload/publish_thumbnail" % (self.base_url)

params["thumb_image"] = open(path, "rb")

else:

if display_name is None:

display_name = os.path.basename(path)

# we allow linking to nothing for generic reference use cases

if field_name is not None:

params["field_name"] = field_name

params["display_name"] = display_name

params["tag_list"] = tag_list

params["file"] = open(path, "rb")

# Create opener with extended form post support

opener = urllib2.build_opener(FormPostHandler)

# Perform the request

try:

result = opener.open(url, params).read()

except urllib2.HTTPError, e:

if e.code == 500:

raise ShotgunError("Server encountered an internal error. \n%s\n(%s)\n%s\n\n" % (url, params, e))

else:

raise ShotgunError("Unanticipated error occurred uploading %s: %s" % (path, e))

else:

if not str(result).startswith("1"):

raise ShotgunError("Could not upload file successfully, but not sure why.\nPath: %s\nUrl: %s\nError: %s" % (path, url, str(result)))

# we changed the result string in the middle of 1.8 to return the id

# remove once everyone is > 1.8.3

r = str(result).split(":")

id = 0

if len(r) > 1:

id = int(str(result).split(":")[1].split("\n")[0])

return id

def upload_thumbnail(self, entity_type, entity_id, path, **kwargs):

"""

result = self.upload(entity_type, entity_id, path, field_name="thumb_image", **kwargs)

return result

def download_attachment(self, entity_id):

"""

sid = self._get_session_token()

domain = urlparse(self.base_url)[1].split(':',1)[0]

cj = cookielib.LWPCookieJar()

c = cookielib.Cookie('0', '_session_id', sid, None, False, domain, False, False, "/", True, False, None, True, None, None, {})

cj.set_cookie(c)

cookie_handler = urllib2.HTTPCookieProcessor(cj)

urllib2.install_opener(urllib2.build_opener(cookie_handler))

url = '%s/file_serve/attachment/%s' % (self.base_url, entity_id)

try:

request = urllib2.Request(url)

request.add_header('User-agent','Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.0.7) Gecko/2009021906 Firefox/3.0.7')

attachment = urllib2.urlopen(request).read()

except IOError, e:

err = "Failed to open %s" % url

if hasattr(e, 'code'):

err += "\nWe failed with error code - %s." % e.code

elif hasattr(e, 'reason'):

err += "\nThe error object has the following 'reason' attribute :", e.reason

err += "\nThis usually means the server doesn't exist, is down, or we don't have an internet connection."

raise ShotgunError(err)

else:

if attachment.lstrip().startswith('<!DOCTYPE '):

error_string = "\n%s\nThe server generated an error trying to download the Attachment. \nURL: %s\n" \

"Either the file doesn't exist, or it is a local file which isn't downloadable.\n%s\n" % ("="*30, url, "="*30)

raise ShotgunError(error_string)

return attachment

def _get_session_token(self):

"""

if self.sid == None:

# HACK: use API2 to get token for now until we better resolve how we manage Attachments in general

api2_url = "%s/%s/" % (self.base_url, 'api2')

conn = ServerProxy(api2_url)

self.sid = conn.getSessionToken([self.script_name, self.api_key])['session_id']

return self.sid

# Deprecated methods from old wrapper

def schema(self, entity_type):

raise ShotgunError("Deprecated: use schema_field_read('type':'%s') instead" % entity_type)

def entity_types(self):

def __init__(self, options):

self.__sg_url = options['server_url']

self.__auth_args = {'script_name': options['script_name'], 'script_key': options['script_key']}

if 'session_uuid' in options:

self.__auth_args['session_uuid'] = options['session_uuid']

if 'convert_datetimes_to_utc' in options:

convert_datetimes_to_utc = options['convert_datetimes_to_utc']

else:

convert_datetimes_to_utc = 1

if 'error_stream' in options:

self.__err_stream = options['error_stream']

else:

self.__err_stream = 'sys.stderr'

if 'http_proxy' in options and options['http_proxy']:

p = ProxiedTransport()

p.set_proxy( options['http_proxy'] )

self.__sg = ServerProxy(self.__sg_url, convert_datetimes_to_utc = convert_datetimes_to_utc, transport=p)

else:

self.__sg = ServerProxy(self.__sg_url, convert_datetimes_to_utc = convert_datetimes_to_utc)

def __getattr__(self, attr):

def callable(*args, **kwargs):

return self.meta_caller(attr, *args, **kwargs)

return callable

def info(self):

try:

server_info = self.__sg.info()

except:

server_info = {}

return server_info

def meta_caller(self, attr, *args, **kwargs):

try:

return eval(

'self._%s__sg.%s(self._%s__auth_args, *args, **kwargs)' %

(self.__class__.__name__, attr, self.__class__.__name__)

)

except Fault, e:

if self.__err_stream:

eval('%s.write("\\n" + "-"*80 + "\\n")' % self.__err_stream)

eval('%s.write("XMLRPC Fault %s:\\n")' % (self.__err_stream, e.faultCode))

eval('%s.write(e.faultString)' % self.__err_stream)

eval('%s.write("\\n" + "-"*80 + "\\n")' % self.__err_stream)

"""

handler_order = urllib2.HTTPHandler.handler_order - 10 # needs to run first

def http_request(self, request):

data = request.get_data()

if data is not None and not isinstance(data, basestring):

files = []

params = []

for key, value in data.items():

if isinstance(value, file):

files.append((key, value))

else:

params.append((key, value))

if not files:

data = urllib.urlencode(params, True) # sequencing on

else:

boundary, data = self.encode(params, files)

content_type = 'multipart/form-data; boundary=%s' % boundary

request.add_unredirected_header('Content-Type', content_type)

request.add_data(data)

return request

def encode(self, params, files, boundary=None, buffer=None):

if boundary is None:

boundary = mimetools.choose_boundary()

if buffer is None:

buffer = cStringIO.StringIO()

for (key, value) in params:

buffer.write('--%s\r\n' % boundary)

buffer.write('Content-Disposition: form-data; name="%s"' % key)

buffer.write('\r\n\r\n%s\r\n' % value)

for (key, fd) in files:

filename = fd.name.split('/')[-1]

content_type = mimetypes.guess_type(filename)[0] or 'application/octet-stream'

file_size = os.fstat(fd.fileno())[stat.ST_SIZE]

buffer.write('--%s\r\n' % boundary)

buffer.write('Content-Disposition: form-data; name="%s"; filename="%s"\r\n' % (key, filename))

buffer.write('Content-Type: %s\r\n' % content_type)

buffer.write('Content-Length: %s\r\n' % file_size)

fd.seek(0)

buffer.write('\r\n%s\r\n' % fd.read())

buffer.write('--%s--\r\n\r\n' % boundary)

buffer = buffer.getvalue()

return boundary, buffer

def https_request(self, request):

def __init__(self):

self.utc = self.UTC()

self.local = self.LocalTimezone()

class UTC(tzinfo):

def utcoffset(self, dt):

return ZERO

def tzname(self, dt):

return "UTC"

def dst(self, dt):

return ZERO

class LocalTimezone(tzinfo):

def utcoffset(self, dt):

if self._isdst(dt):

return DSTOFFSET

else:

return STDOFFSET

def dst(self, dt):

if self._isdst(dt):

return DSTDIFF

else:

return ZERO

def tzname(self, dt):

return _time.tzname[self._isdst(dt)]

def _isdst(self, dt):

tt = (dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.weekday(), 0, -1)

stamp = _time.mktime(tt)

tt = _time.localtime(stamp)