def get_ads_pixels(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adspixel import AdsPixel
param_types = {
'id_filter': 'string',
'name_filter': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/adspixels',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdsPixel,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdsPixel, 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_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):
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 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 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 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 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 create_owned_ad_account(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adaccount import AdAccount
param_types = {
'adaccount_id': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/owned_ad_accounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdAccount,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdAccount, 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_owned_page(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'page_id': 'int',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/owned_pages',
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_offline_conversion_data_sets(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.offlineconversiondataset import OfflineConversionDataSet
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/offline_conversion_data_sets',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=OfflineConversionDataSet,
api_type='EDGE',
response_parser=ObjectParser(target_class=OfflineConversionDataSet, 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_offline_conversion_data_set(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.offlineconversiondataset import OfflineConversionDataSet
param_types = {
'auto_assign_to_new_accounts_only': 'bool',
'description': 'string',
'enable_auto_assign_to_accounts': 'bool',
'name': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/offline_conversion_data_sets',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=OfflineConversionDataSet,
api_type='EDGE',
response_parser=ObjectParser(target_class=OfflineConversionDataSet, 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_measurement_report(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'metadata': 'string',
'report_type': 'report_type_enum',
}
enums = {
'report_type_enum': [
'multi_channel_report',
'video_metrics_report',
'fruit_rollup_report',
'third_party_mta_report',
'partner_lift_study_report',
],
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/measurement_reports',
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_grp_plans(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.reachfrequencyprediction import ReachFrequencyPrediction
param_types = {
'status': 'status_enum',
}
enums = {
'status_enum': ReachFrequencyPrediction.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/grp_plans',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ReachFrequencyPrediction,
api_type='EDGE',
response_parser=ObjectParser(target_class=ReachFrequencyPrediction, 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_event_source_groups(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.eventsourcegroup import EventSourceGroup
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/event_source_groups',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=EventSourceGroup,
api_type='EDGE',
response_parser=ObjectParser(target_class=EventSourceGroup, 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_sessions(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.customaudiencesession import CustomAudienceSession
param_types = {
'session_id': 'unsigned int',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/sessions',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=CustomAudienceSession,
api_type='EDGE',
response_parser=ObjectParser(target_class=CustomAudienceSession),
)
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_owned_product_catalog(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.productcatalog import ProductCatalog
param_types = {
'da_display_settings': 'Object',
'destination_catalog_settings': 'map',
'flight_catalog_settings': 'map',
'name': 'string',
'vertical': 'vertical_enum',
}
enums = {
'vertical_enum': ProductCatalog.Vertical.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/owned_product_catalogs',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductCatalog,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductCatalog, 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):
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 get_pending_owned_ad_accounts(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.legacybusinessadaccountrequest import LegacyBusinessAdAccountRequest
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/pending_owned_ad_accounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=LegacyBusinessAdAccountRequest,
api_type='EDGE',
response_parser=ObjectParser(target_class=LegacyBusinessAdAccountRequest, 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 get_hotel_rooms_batch(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.productcataloghotelroomsbatch import ProductCatalogHotelRoomsBatch
param_types = {
'handle': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/hotel_rooms_batch',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductCatalogHotelRoomsBatch,
api_type='EDGE',
response_parser=ObjectParser(
target_class=ProductCatalogHotelRoomsBatch),
)
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 create_product_set(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.productset import ProductSet
param_types = {
'filter': 'Object',
'name': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/product_sets',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductSet,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductSet),
)
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_product_sets_batch(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'handle': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/product_sets_batch',
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 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):
self.assure_call()
param_types = {
'account_id': 'string',
'adlabels': 'list<Object>',
'id': 'string',
'name': 'string',
'run_status': 'unsigned int',
}
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 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 create_ad_label(self,
fields=None,
params=None,
batch=None,
pending=False):
self.assure_call()
param_types = {
'adlabels': 'list<Object>',
'id': 'string',
}
enums = {}
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_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_accounts(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.page import Page
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=Page,
api_type='EDGE',
response_parser=ObjectParser(target_class=Page, 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_ads(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.ad import Ad
param_types = {
'effective_status': 'list<string>',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/ads',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Ad,
api_type='EDGE',
response_parser=ObjectParser(target_class=Ad),
)
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
param_types = {
'page_id': 'string',
'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, 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 delete_users(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'id': 'string',
'payload': 'Object',
'session': 'Object',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='DELETE',
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 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 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 get_promotable_domains(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.domain import Domain
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/promotable_domains',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Domain,
api_type='EDGE',
response_parser=ObjectParser(target_class=Domain, 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
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 get_promotable_events(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.event import Event
param_types = {
'include_past_events': 'bool',
'is_page_event': 'bool',
'page_id': 'unsigned int',
}
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, 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
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 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=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 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 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>',
}
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=AdLabel,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdLabel),
)
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_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 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_agencies(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.business import Business
self.assure_call()
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/agencies',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Business,
api_type='EDGE',
response_parser=ObjectParser(target_class=Business),
)
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_external_event_source(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.externaleventsource import ExternalEventSource
self.assure_call()
param_types = {
'external_event_sources': 'list<string>',
'id': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/external_event_sources',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ExternalEventSource,
api_type='EDGE',
response_parser=ObjectParser(target_class=ExternalEventSource),
)
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_product_group(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.productgroup import ProductGroup
self.assure_call()
param_types = {
'id': 'string',
'retailer_id': 'string',
'variants': 'list<Object>',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/product_groups',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductGroup,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductGroup),
)
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
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_product_sets(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.productset import ProductSet
self.assure_call()
param_types = {
'ancestor_id': 'string',
'has_children': 'bool',
'parent_id': 'string',
}
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),
)
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 get_products(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.productitem import ProductItem
self.assure_call()
param_types = {
'filter': 'Object',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
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
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 add_ad_account(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {'adaccount_id': 'string'}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adaccounts',
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_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 create_ad_account(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.customaudienceadaccount import CustomAudienceAdAccount
param_types = {
'adaccounts': 'list<string>',
'id': 'string',
'permissions': 'string',
'replace': 'bool',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adaccounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=CustomAudienceAdAccount,
api_type='EDGE',
response_parser=ObjectParser(target_class=CustomAudienceAdAccount),
)
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_assigned_product_catalogs(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.productcatalog import ProductCatalog
param_types = {
'email': 'string',
'user_id': 'int',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/assigned_product_catalogs',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductCatalog,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductCatalog, 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()
