def api_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'applinks': 'Object',
'base_price': 'float',
'currency': 'string',
'description': 'string',
'images': 'list<Object>',
'margin_level': 'unsigned int',
'name': 'string',
'pricing_variables': 'list<Object>',
'sale_price': 'float',
'url': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=HotelRoom,
api_type='NODE',
response_parser=ObjectParser(reuse_object=self),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def delete_ad_labels(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adlabel import AdLabel
param_types = {
'adlabels': 'list<Object>',
'execution_options': 'list<execution_options_enum>',
}
enums = {
'execution_options_enum':
AdLabel.ExecutionOptions.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='DELETE',
endpoint='/adlabels',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_previews(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adpreview import AdPreview
self.assure_call()
param_types = {
'ad_format': 'ad_format_enum',
'height': 'unsigned int',
'locale': 'string',
'post': 'Object',
'product_item_ids': 'list<string>',
'width': 'unsigned int',
}
enums = {
'ad_format_enum': AdPreview.AdFormat.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/previews',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdPreview,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdPreview),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
return request if pending else request.execute()
def create_ad_accounts(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adaccount import AdAccount
param_types = {
'access_type': 'access_type_enum',
'adaccount_id': 'string',
'permitted_roles': 'list<permitted_roles_enum>',
}
enums = {
'access_type_enum': AdAccount.AccessType.__dict__.values(),
'permitted_roles_enum': AdAccount.PermittedRoles.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adaccounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdAccount,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdAccount),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_upload(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.productfeedupload import ProductFeedUpload
param_types = {
'file': 'file',
'password': '******',
'update_only': 'bool',
'url': 'string',
'username': '******',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/uploads',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductFeedUpload,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductFeedUpload,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_objective(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adstudyobjective import AdStudyObjective
param_types = {
'adspixels': 'list<Object>',
'applications': 'list<Object>',
'customconversions': 'list<Object>',
'is_primary': 'bool',
'name': 'string',
'offline_conversion_data_sets': 'list<Object>',
'offsitepixels': 'list<Object>',
'type': 'type_enum',
}
enums = {
'type_enum': AdStudyObjective.Type.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/objectives',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdStudyObjective,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdStudyObjective, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_delete(self, fields=None, params=None, batch=None, pending=False):
self.assure_call()
param_types = {
'id': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='DELETE',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='NODE',
response_parser=ObjectParser(reuse_object=self),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
return request if pending else request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {'name': 'string'}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Project,
api_type='NODE',
response_parser=ObjectParser(reuse_object=self),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_samples(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.productfeeduploaderrorsample import ProductFeedUploadErrorSample
self.assure_call()
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/samples',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductFeedUploadErrorSample,
api_type='EDGE',
response_parser=ObjectParser(
target_class=ProductFeedUploadErrorSample),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
return request if pending else request.execute()
def api_get(self, fields=None, params=None, batch=None, pending=False):
self.assure_call()
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductFeedUploadErrorSample,
api_type='NODE',
response_parser=ObjectParser(reuse_object=self),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
return request if pending else request.execute()
AdsInsights.Breakdowns.__dict__.values(),
'date_preset_enum':
AdsInsights.DatePreset.__dict__.values(),
'summary_enum':
AdsInsights.Summary.__dict__.values(),
'level_enum':
AdsInsights.Level.__dict__.values(),
'summary_action_breakdowns_enum':
AdsInsights.SummaryActionBreakdowns.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/insights',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdsInsights,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdsInsights),
include_summary=False,
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
return request if pending else request.execute()
def get_insights_async(self,
def create_video(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'content_category': 'content_category_enum',
'description': 'string',
'embeddable': 'bool',
'file_size': 'unsigned int',
'file_url': 'string',
'fov': 'unsigned int',
'guide': 'list<list<unsigned int>>',
'guide_enabled': 'bool',
'initial_heading': 'unsigned int',
'initial_pitch': 'unsigned int',
'original_fov': 'unsigned int',
'original_projection_type': 'original_projection_type_enum',
'referenced_sticker_id': 'string',
'replace_video_id': 'string',
'slideshow_spec': 'map',
'source': 'string',
'spherical': 'bool',
'start_offset': 'unsigned int',
'swap_mode': 'swap_mode_enum',
'thumb': 'file',
'title': 'string',
'unpublished_content_type': 'unpublished_content_type_enum',
'upload_phase': 'upload_phase_enum',
'upload_session_id': 'string',
'video_file_chunk': 'string',
}
enums = {
'content_category_enum': [
'BEAUTY_FASHION',
'BUSINESS',
'CARS_TRUCKS',
'COMEDY',
'CUTE_ANIMALS',
'ENTERTAINMENT',
'FAMILY',
'FOOD_HEALTH',
'HOME',
'LIFESTYLE',
'MUSIC',
'NEWS',
'POLITICS',
'SCIENCE',
'SPORTS',
'TECHNOLOGY',
'VIDEO_GAMING',
'OTHER',
],
'original_projection_type_enum': [
'equirectangular',
'cubemap',
'equiangular_cubemap',
],
'swap_mode_enum': [
'replace',
],
'unpublished_content_type_enum': [
'SCHEDULED',
'DRAFT',
'ADS_POST',
],
'upload_phase_enum': [
'start',
'transfer',
'finish',
'cancel',
],
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/videos',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def __init__(self):
self._data = {}
self._field_checker = TypeChecker(self._field_types,
self._get_field_enum_info())
class AbstractObject(collections.MutableMapping):
"""
Represents an abstract object (may or may not have explicitly be a node of
the Graph) as a MutableMapping of its data.
"""
_default_read_fields = []
_field_types = {}
class Field:
pass
def __init__(self):
self._data = {}
self._field_checker = TypeChecker(self._field_types,
self._get_field_enum_info())
def __getitem__(self, key):
return self._data[str(key)]
def __setitem__(self, key, value):
if key.startswith('_'):
self.__setattr__(key, value)
else:
self._data[key] = self._field_checker.get_typed_value(key, value)
return self
def __eq__(self, other):
return other is not None and 'export_all_data' in other and \
self.export_all_data() == other.export_all_data()
def __delitem__(self, key):
del self._data[key]
def __iter__(self):
return iter(self._data)
def __len__(self):
return len(self._data)
def __contains__(self, key):
return key in self._data
def __unicode__(self):
return unicode(self._data)
def __repr__(self):
return "<%s> %s" % (
self.__class__.__name__,
json.dumps(
self.export_value(self._data),
sort_keys=True,
indent=4,
separators=(',', ': '),
),
)
#reads in data from json object
def _set_data(self, data):
if hasattr(data, 'items'):
for key, value in data.items():
self[key] = value
else:
raise FacebookBadObjectError("Bad data to set object data")
self._json = data
@classmethod
def _get_field_enum_info(cls):
"""Returns info for fields that use enum values
Should be implemented in subclasses
"""
return {}
# @deprecated get_endpoint function is deprecated
@classmethod
def get_endpoint(cls):
"""Returns the endpoint name.
Raises:
NotImplementedError if the method is not implemented in a class
that derives from this abstract class.
"""
raise NotImplementedError(
"%s must have implemented get_endpoint." % cls.__name__,
)
@classmethod
def get_default_read_fields(cls):
"""Returns the class's list of default fields to read."""
return cls._default_read_fields
@classmethod
def set_default_read_fields(cls, fields):
"""Sets the class's list of default fields to read.
Args:
fields: list of field names to read by default without specifying
them explicitly during a read operation either via EdgeIterator
or via AbstractCrudObject.read.
"""
cls._default_read_fields = fields
@classmethod
def _assign_fields_to_params(cls, fields, params):
"""Applies fields to params in a consistent manner."""
if fields is None:
fields = cls.get_default_read_fields()
if fields:
params['fields'] = ','.join(fields)
def set_data(self, data):
"""
For an AbstractObject, we do not need to keep history.
"""
self._set_data(data)
def export_value(self, data):
if isinstance(data, AbstractObject):
data = data.export_all_data()
elif isinstance(data, dict):
data = dict((k, self.export_value(v))
for k, v in data.items()
if v is not None)
elif isinstance(data, list):
data = [self.export_value(v) for v in data]
return data
def export_data(self):
"""
Deprecated. Use export_all_data() instead.
"""
return self.export_all_data()
def export_all_data(self):
return self.export_value(self._data)
@classmethod
def create_object(cls, api, data, target_class):
new_object = target_class(api=api)
new_object._set_data(data)
return new_object
def __init__(self):
self._data = {}
self._field_checker = TypeChecker(self._field_types,
self._get_field_enum_info())
class AbstractObject(collections.MutableMapping):
"""
Represents an abstract object (may or may not have explicitly be a node of
the Graph) as a MutableMapping of its data.
"""
_default_read_fields = []
_field_types = {}
class Field:
pass
def __init__(self):
self._data = {}
self._field_checker = TypeChecker(self._field_types,
self._get_field_enum_info())
def __getitem__(self, key):
return self._data[str(key)]
def __setitem__(self, key, value):
if key.startswith('_'):
self.__setattr__(key, value)
else:
self._data[key] = self._field_checker.get_typed_value(key, value)
return self
def __eq__(self, other):
return other is not None and 'export_all_data' in other and \
self.export_all_data() == other.export_all_data()
def __delitem__(self, key):
del self._data[key]
def __iter__(self):
return iter(self._data)
def __len__(self):
return len(self._data)
def __contains__(self, key):
return key in self._data
def __unicode__(self):
return unicode(self._data)
def __repr__(self):
return "<%s> %s" % (
self.__class__.__name__,
json.dumps(
self.export_value(self._data),
sort_keys=True,
indent=4,
separators=(',', ': '),
),
)
#reads in data from json object
def _set_data(self, data):
if hasattr(data, 'items'):
for key, value in data.items():
self[key] = value
else:
raise FacebookBadObjectError("Bad data to set object data")
self._json = data
@classmethod
def _get_field_enum_info(cls):
"""Returns info for fields that use enum values
Should be implemented in subclasses
"""
return {}
# @deprecated get_endpoint function is deprecated
@classmethod
def get_endpoint(cls):
"""Returns the endpoint name.
Raises:
NotImplementedError if the method is not implemented in a class
that derives from this abstract class.
"""
raise NotImplementedError(
"%s must have implemented get_endpoint." % cls.__name__,
)
@classmethod
def get_default_read_fields(cls):
"""Returns the class's list of default fields to read."""
return cls._default_read_fields
@classmethod
def set_default_read_fields(cls, fields):
"""Sets the class's list of default fields to read.
Args:
fields: list of field names to read by default without specifying
them explicitly during a read operation either via EdgeIterator
or via AbstractCrudObject.read.
"""
cls._default_read_fields = fields
@classmethod
def _assign_fields_to_params(cls, fields, params):
"""Applies fields to params in a consistent manner."""
if fields is None:
fields = cls.get_default_read_fields()
if fields:
params['fields'] = ','.join(fields)
def set_data(self, data):
"""
For an AbstractObject, we do not need to keep history.
"""
self._set_data(data)
def export_value(self, data):
if isinstance(data, AbstractObject):
data = data.export_all_data()
elif isinstance(data, dict):
data = dict((k, self.export_value(v))
for k, v in data.items()
if v is not None)
elif isinstance(data, list):
data = [self.export_value(v) for v in data]
return data
def export_data(self):
"""
Deprecated. Use export_all_data() instead.
"""
return self.export_all_data()
def export_all_data(self):
return self.export_value(self._data)
@classmethod
def create_object(cls, api, data, target_class):
new_object = target_class(api=api)
new_object._set_data(data)
return new_object
def __init__(self):
self._data = dict.fromkeys(self.Field.__dict__.values())
self._field_checker = TypeChecker(self._field_types,
self._get_field_enum_info())
def get_insights_async(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adreportrun import AdReportRun
from facebookads.adobjects.adsinsights import AdsInsights
self.assure_call()
param_types = {
'action_attribution_windows':
'list<action_attribution_windows_enum>',
'action_breakdowns': 'list<action_breakdowns_enum>',
'action_report_time': 'action_report_time_enum',
'breakdowns': 'list<breakdowns_enum>',
'date_preset': 'date_preset_enum',
'default_summary': 'bool',
'fields': 'list<fields_enum>',
'filtering': 'list<Object>',
'level': 'level_enum',
'product_id_limit': 'int',
'sort': 'list<string>',
'summary': 'list<summary_enum>',
'summary_action_breakdowns':
'list<summary_action_breakdowns_enum>',
'time_increment': 'string',
'time_range': 'map',
'time_ranges': 'list<map>',
}
enums = {
'action_attribution_windows_enum':
AdsInsights.ActionAttributionWindows.__dict__.values(),
'action_breakdowns_enum':
AdsInsights.ActionBreakdowns.__dict__.values(),
'action_report_time_enum':
AdsInsights.ActionReportTime.__dict__.values(),
'breakdowns_enum':
AdsInsights.Breakdowns.__dict__.values(),
'date_preset_enum':
AdsInsights.DatePreset.__dict__.values(),
'summary_enum':
AdsInsights.Summary.__dict__.values(),
'level_enum':
AdsInsights.Level.__dict__.values(),
'summary_action_breakdowns_enum':
AdsInsights.SummaryActionBreakdowns.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/insights',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdReportRun,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdReportRun),
include_summary=False,
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
return request if pending else request.execute()
def create_product(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.productitem import ProductItem
param_types = {
'additional_image_urls': 'list<string>',
'android_app_name': 'string',
'android_class': 'string',
'android_package': 'string',
'android_url': 'string',
'availability': 'availability_enum',
'brand': 'string',
'category': 'string',
'checkout_url': 'string',
'color': 'string',
'condition': 'condition_enum',
'currency': 'string',
'custom_data': 'map',
'custom_label_0': 'string',
'custom_label_1': 'string',
'custom_label_2': 'string',
'custom_label_3': 'string',
'custom_label_4': 'string',
'description': 'string',
'expiration_date': 'string',
'gender': 'gender_enum',
'gtin': 'string',
'image_url': 'string',
'inventory': 'unsigned int',
'ios_app_name': 'string',
'ios_app_store_id': 'unsigned int',
'ios_url': 'string',
'ipad_app_name': 'string',
'ipad_app_store_id': 'unsigned int',
'ipad_url': 'string',
'iphone_app_name': 'string',
'iphone_app_store_id': 'unsigned int',
'iphone_url': 'string',
'manufacturer_part_number': 'string',
'name': 'string',
'ordering_index': 'unsigned int',
'pattern': 'string',
'price': 'unsigned int',
'product_type': 'string',
'retailer_id': 'string',
'sale_price': 'unsigned int',
'sale_price_end_date': 'datetime',
'sale_price_start_date': 'datetime',
'short_description': 'string',
'size': 'string',
'start_date': 'string',
'url': 'string',
'visibility': 'visibility_enum',
'windows_phone_app_id': 'unsigned int',
'windows_phone_app_name': 'string',
'windows_phone_url': 'string',
}
enums = {
'availability_enum': ProductItem.Availability.__dict__.values(),
'condition_enum': ProductItem.Condition.__dict__.values(),
'gender_enum': ProductItem.Gender.__dict__.values(),
'visibility_enum': ProductItem.Visibility.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/products',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductItem,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductItem),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def __init__(self):
self._data = dict.fromkeys(self.Field.__dict__.values())
self._field_checker = TypeChecker(self._field_types,
self._get_field_enum_info())
