def cancel_page_permission_request(self):
request = FacebookRequest(
node_id=self.get_parent_id_assured(),
endpoint=self.get_endpoint(),
api=self.get_api(),
method='DELETE',
)
request.add_params({'page_id': self.get_id_assured()})
request.execute()
def remove_user_permission(self, user_id, business_id):
request = FacebookRequest(
node_id=self.get_id_assured(),
method='DELETE',
endpoint=UserPagePermission.get_endpoint(),
api=self.get_api(),
)
request.add_params({'user': user_id, 'business': business_id})
request.execute()
def remote_delete(
self,
batch=None,
failure=None,
params=None,
success=None,
api_version=None,
):
"""Deletes the object by calling the API with the DELETE http method.
Args:
batch (optional): A FacebookAdsApiBatch object. If specified,
the call will be added to the batch.
params (optional): A mapping of request parameters where a key
is the parameter name and its value is a string or an object
which can be JSON-encoded.
success (optional): A callback function which will be called with
the FacebookResponse of this call if the call succeeded.
failure (optional): A callback function which will be called with
the FacebookResponse of this call if the call failed.
Returns:
self if not a batch call.
the return value of batch.add if a batch call.
"""
if hasattr(self, 'api_delete'):
request = self.api_delete(pending=True)
else:
request = FacebookRequest(
node_id=self.get_id_assured(),
method='DELETE',
endpoint='/',
api=self._api,
)
request.add_params(params)
if batch is not None:
def callback_success(response):
self.clear_id()
if success:
success(response)
def callback_failure(response):
if failure:
failure(response)
batch_call = batch.add_request(
request=request,
success=callback_success,
failure=callback_failure,
)
return batch_call
else:
request.execute()
self.clear_id()
return self
def remote_update(self, batch=None, failure=None, files=None, params=None, success=None, api_version=None):
"""Updates the object by calling the API with only the changes recorded.
Args:
batch (optional): A FacebookAdsApiBatch object. If specified,
the call will be added to the batch.
params (optional): A mapping of request parameters where a key
is the parameter name and its value is a string or an object
which can be JSON-encoded.
files (optional): An optional mapping of file names to binary open
file objects. These files will be attached to the request.
success (optional): A callback function which will be called with
the FacebookResponse of this call if the call succeeded.
failure (optional): A callback function which will be called with
the FacebookResponse of this call if the call failed.
Returns:
self if not a batch call.
the return value of batch.add if a batch call.
"""
params = {} if not params else params.copy()
params.update(self.export_changed_data())
self._set_data(params)
if hasattr(self, "api_update"):
request = self.api_update(pending=True)
else:
request = FacebookRequest(
node_id=self.get_id_assured(),
method="POST",
endpoint="/",
api=self._api,
target_class=self.__class__,
response_parser=ObjectParser(reuse_object=self),
)
request.add_params(params)
request.add_files(files)
if batch is not None:
def callback_success(response):
self._clear_history()
if success:
success(response)
def callback_failure(response):
if failure:
failure(response)
batch_call = batch.add_request(request=request, success=callback_success, failure=callback_failure)
return batch_call
else:
request.execute()
self._clear_history()
return self
def get_reach_estimate(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.reachestimate import ReachEstimate
param_types = {
'currency': 'string',
'daily_budget': 'float',
'optimize_for': 'optimize_for_enum',
}
enums = {
'optimize_for_enum': ReachEstimate.OptimizeFor.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/reachestimate',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ReachEstimate,
api_type='EDGE',
response_parser=ObjectParser(target_class=ReachEstimate),
)
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_get(self, fields=None, params=None, batch=None, pending=False):
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdReportRun,
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_previews(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adpreview import AdPreview
param_types = {
'ad_format': 'ad_format_enum',
'height': 'unsigned int',
'locale': 'string',
'post': 'Object',
'product_item_ids': 'list<int>',
'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
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_ad_sets(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adset import AdSet
param_types = {
"ad_draft_id": "string",
"date_preset": "date_preset_enum",
"effective_status": "list<effective_status_enum>",
"is_completed": "bool",
"time_range": "map",
}
enums = {
"date_preset_enum": AdSet.DatePreset.__dict__.values(),
"effective_status_enum": AdSet.EffectiveStatus.__dict__.values(),
}
request = FacebookRequest(
node_id=self["id"],
method="GET",
endpoint="/adsets",
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdSet,
api_type="EDGE",
response_parser=ObjectParser(target_class=AdSet),
)
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_accounts(self, fields=None, params=None, batch=None, pending=False):
self.assure_call()
param_types = {
'business_id': 'string',
'is_business': 'bool',
'is_place': 'bool',
'is_promotable': 'bool',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/accounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
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):
self.assure_call()
param_types = {
'id': 'string',
'variants': 'list<Object>',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
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 create_ad_label(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>", "id": "string"}
enums = {"execution_options_enum": AdLabel.ExecutionOptions.__dict__.values()}
request = FacebookRequest(
node_id=self["id"],
method="POST",
endpoint="/adlabels",
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type="EDGE",
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
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_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'accounts': 'map',
'name': 'string',
'redownload': 'bool',
'status': 'unsigned int',
'users': 'map',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
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
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_picture(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.profilepicturesource import ProfilePictureSource
param_types = {
'height': 'int',
'redirect': 'bool',
'type': 'type_enum',
'width': 'int',
}
enums = {
'type_enum': ProfilePictureSource.Type.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/picture',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProfilePictureSource,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProfilePictureSource, 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_ad_label(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adlabel import AdLabel
self.assure_call()
param_types = {
'adlabels': 'list<Object>',
'execution_options': 'list<execution_options_enum>',
'id': 'string',
}
enums = {
'execution_options_enum': AdLabel.ExecutionOptions.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adlabels',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
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_ad_sets(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adset import AdSet
self.assure_call()
param_types = {
'ad_draft_id': 'string',
'date_preset': 'date_preset_enum',
'effective_status': 'list<effective_status_enum>',
'is_completed': 'bool',
'time_range': 'map',
}
enums = {
'date_preset_enum': AdSet.DatePreset.__dict__.values(),
'effective_status_enum': AdSet.EffectiveStatus.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/adsets',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdSet,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdSet),
)
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_account_group(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adaccountgroup import AdAccountGroup
self.assure_call()
param_types = {
'accounts': 'map',
'id': 'int',
'name': 'string',
'redownload': 'bool',
'users': 'map',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adaccountgroups',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdAccountGroup,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdAccountGroup),
)
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):
self.assure_call()
param_types = {
'adlabels': 'list<Object>',
'execution_options': 'list<execution_options_enum>',
'name': 'string',
'objective': 'objective_enum',
'promoted_object': 'Object',
'spend_cap': 'unsigned int',
'status': 'status_enum',
}
enums = {
'execution_options_enum': Campaign.ExecutionOptions.__dict__.values(),
'objective_enum': Campaign.Objective.__dict__.values(),
'status_enum': Campaign.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
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 get_promotable_events(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.event import Event
self.assure_call()
param_types = {
'is_page_event': 'bool',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/promotable_events',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Event,
api_type='EDGE',
response_parser=ObjectParser(target_class=Event),
)
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_user(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'account_group_roles': 'list<map>',
'redownload': 'bool',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/users',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
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_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'filter': 'Object',
'name': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductSet,
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_targeting_sentence_lines(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.targetingsentenceline import TargetingSentenceLine
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/targetingsentencelines',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=TargetingSentenceLine,
api_type='EDGE',
response_parser=ObjectParser(target_class=TargetingSentenceLine),
)
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_ad_accounts(self, fields=None, params=None, batch=None, pending=False):
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/adaccounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
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_requests(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adasyncrequest import AdAsyncRequest
param_types = {
'statuses': 'list<statuses_enum>',
}
enums = {
'statuses_enum': AdAsyncRequest.Statuses.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/requests',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdAsyncRequest,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdAsyncRequest, 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_lead_gen_forms(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.leadgenform import LeadgenForm
self.assure_call()
param_types = {
'query': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/leadgen_forms',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=LeadgenForm,
api_type='EDGE',
response_parser=ObjectParser(target_class=LeadgenForm),
)
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_product_sets(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.productset import ProductSet
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/product_sets',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductSet,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductSet, 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_keyword_stats(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adkeywordstats import AdKeywordStats
param_types = {
'date': 'datetime',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/keywordstats',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdKeywordStats,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdKeywordStats),
)
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_ad_label(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adlabel import AdLabel
param_types = {
'adlabels': 'list<Object>',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adlabels',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdLabel,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdLabel, 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_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'account_id': 'string',
'adlabels': 'list<Object>',
'name': 'string',
'status': 'status_enum',
}
enums = {
'status_enum': AdCreative.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdCreative,
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_accounts(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adaccount import AdAccount
self.assure_call()
param_types = {
'adaccounts': 'list<string>',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='DELETE',
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
return request if pending else request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False):
self.assure_call()
param_types = {
'app_event': 'string',
'app_id_for_app_event_firing': 'int',
'id': 'string',
'name': 'string',
'tag': 'tag_enum',
}
enums = {
'tag_enum': OffsitePixel.Tag.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
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_get(self, fields=None, params=None, batch=None, pending=False):
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductFeedUploadError,
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_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<int>',
'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 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 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 api_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'default_currency': 'string',
'deletion_enabled': 'bool',
'delimiter': 'delimiter_enum',
'encoding': 'encoding_enum',
'id': 'string',
'name': 'string',
'quoted_fields': 'bool',
'schedule': 'string',
}
enums = {
'delimiter_enum': ProductFeed.Delimiter.__dict__.values(),
'encoding_enum': ProductFeed.Encoding.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
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
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'adlabels': 'list<Object>',
'execution_options': 'list<execution_options_enum>',
'name': 'string',
'objective': 'objective_enum',
'promoted_object': 'Object',
'spend_cap': 'unsigned int',
'status': 'status_enum',
}
enums = {
'execution_options_enum': Campaign.ExecutionOptions.__dict__.values(),
'objective_enum': Campaign.Objective.__dict__.values(),
'status_enum': Campaign.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
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
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_system_users(self, fields=None, params=None, batch=None, pending=False):
self.assure_call()
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/system_users',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
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_access_token_debug_details(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'input_token': 'string',
'access_token': 'string',
}
enums = {
}
request = FacebookRequest(
node_id='debug_token',
method='GET',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='NODE',
response_parser=ObjectParser(reuse_object=self),
)
# TODO: Create an actual object instead of using AbstractCrudObject with this list..
request._accepted_fields = list(request._accepted_fields)
request._accepted_fields.extend([
'app_id', 'application', 'expires_at', 'is_valid', 'issued_at', 'scopes', 'user_id', 'type',
'profile_id'
])
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 api_delete(self, fields=None, params=None, batch=None, pending=False):
self.assure_call()
param_types = {
'id': 'int',
}
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 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_measurement_reports(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.measurementreport import MeasurementReport
self.assure_call()
param_types = {
'filters': 'list<Object>',
'report_type': 'report_type_enum',
}
enums = {
'report_type_enum': [
'multi_channel_report',
'video_metrics_report',
'fruit_rollup_report',
],
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/measurement_reports',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
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_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 get_stats(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'aggr_time': 'aggr_time_enum',
'end': 'int',
'skip_empty_values': 'bool',
'start': 'int',
'user_timezone_id': 'unsigned int',
}
enums = {
'aggr_time_enum': [
'upload_time',
'event_time',
],
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/stats',
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_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_update(self, fields=None, params=None, batch=None, pending=False):
self.assure_call()
param_types = {
'adlabels': 'list<Object>',
'adset_id': 'unsigned int',
'bid_amount': 'int',
'creative': 'AdCreative',
'display_sequence': 'unsigned int',
'execution_options': 'list<execution_options_enum>',
'name': 'string',
'redownload': 'bool',
'status': 'status_enum',
'tracking_specs': 'Object',
}
enums = {
'execution_options_enum': Ad.ExecutionOptions.__dict__.values(),
'status_enum': Ad.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
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 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 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()
api_type='EDGE',
response_parser=ObjectParser(target_class=AdsInsights,
api=self._api),
include_summary=False,
)
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_insights_async(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adreportrun import AdReportRun
from facebookads.adobjects.adsinsights import AdsInsights
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',
def remote_create(
self,
batch=None,
failure=None,
files=None,
params=None,
success=None,
api_version=None,
):
"""Creates the object by calling the API.
Args:
batch (optional): A FacebookAdsApiBatch object. If specified,
the call will be added to the batch.
params (optional): A mapping of request parameters where a key
is the parameter name and its value is a string or an object
which can be JSON-encoded.
files (optional): An optional mapping of file names to binary open
file objects. These files will be attached to the request.
success (optional): A callback function which will be called with
the FacebookResponse of this call if the call succeeded.
failure (optional): A callback function which will be called with
the FacebookResponse of this call if the call failed.
Returns:
self if not a batch call.
the return value of batch.add if a batch call.
"""
if self.get_id():
raise FacebookBadObjectError(
"This %s object was already created."
% self.__class__.__name__,
)
if not 'get_endpoint' in dir(self):
raise TypeError('Cannot create object of type %s.'
% self.__class__.__name__)
params = {} if not params else params.copy()
params.update(self.export_all_data())
request = None
if hasattr(self, 'api_create'):
request = self.api_create(self.get_parent_id_assured(), pending=True)
else:
request = FacebookRequest(
node_id=self.get_parent_id_assured(),
method='POST',
endpoint=self.get_endpoint(),
api=self._api,
target_class=self.__class__,
response_parser=ObjectParser(
reuse_object=self
),
)
request.add_params(params)
request.add_files(files)
if batch is not None:
def callback_success(response):
self._set_data(response.json())
self._clear_history()
if success:
success(response)
def callback_failure(response):
if failure:
failure(response)
return batch.add_request(
request=request,
success=callback_success,
failure=callback_failure,
)
else:
response = request.execute()
self._set_data(response._json)
self._clear_history()
return self
def remote_update(
self,
batch=None,
failure=None,
files=None,
params=None,
success=None,
api_version=None,
):
"""Updates the object by calling the API with only the changes recorded.
Args:
batch (optional): A FacebookAdsApiBatch object. If specified,
the call will be added to the batch.
params (optional): A mapping of request parameters where a key
is the parameter name and its value is a string or an object
which can be JSON-encoded.
files (optional): An optional mapping of file names to binary open
file objects. These files will be attached to the request.
success (optional): A callback function which will be called with
the FacebookResponse of this call if the call succeeded.
failure (optional): A callback function which will be called with
the FacebookResponse of this call if the call failed.
Returns:
self if not a batch call.
the return value of batch.add if a batch call.
"""
params = {} if not params else params.copy()
params.update(self.export_changed_data())
self._set_data(params)
if hasattr(self, 'api_update'):
request = self.api_update(pending=True)
else:
request = FacebookRequest(
node_id=self.get_id_assured(),
method='POST',
endpoint='/',
api=self._api,
target_class=self.__class__,
response_parser=ObjectParser(
reuse_object=self
),
)
request.add_params(params)
request.add_files(files)
if batch is not None:
def callback_success(response):
self._clear_history()
if success:
success(response)
def callback_failure(response):
if failure:
failure(response)
batch_call = batch.add_request(
request=request,
success=callback_success,
failure=callback_failure,
)
return batch_call
else:
request.execute()
self._clear_history()
return self
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,
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>',
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()
