def get_offline_conversion_data_sets(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.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 get_pricing_variables_batch(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.productcatalogpricingvariablesbatch import ProductCatalogPricingVariablesBatch
param_types = {
'handle': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/pricing_variables_batch',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductCatalogPricingVariablesBatch,
api_type='EDGE',
response_parser=ObjectParser(
target_class=ProductCatalogPricingVariablesBatch,
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_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,
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_check_batch_request_status(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.checkbatchrequeststatus import CheckBatchRequestStatus
param_types = {
'handle': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/check_batch_request_status',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=CheckBatchRequestStatus,
api_type='EDGE',
response_parser=ObjectParser(target_class=CheckBatchRequestStatus,
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_external_event_source(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.externaleventsource import ExternalEventSource
param_types = {
'external_event_sources': 'list<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,
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 = {
'name': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdLabel,
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 = {
'da_display_settings': 'Object',
'default_image_url': 'string',
'fallback_image_url': 'string',
'flight_catalog_settings': 'map',
'name': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductCatalog,
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 = {
'evaluation_spec': 'Object',
'execution_spec': 'Object',
'name': 'string',
'reset_period': 'int',
'schedule_spec': 'Object',
'status': 'status_enum',
}
enums = {
'status_enum': AdRule.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdRule,
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_history(self, fields=None, params=None, batch=None, pending=False):
from facebookads_v2.adobjects.adrulehistory import AdRuleHistory
param_types = {
'action': 'action_enum',
'hide_no_changes': 'bool',
'object_id': 'string',
}
enums = {
'action_enum': AdRuleHistory.Action.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/history',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdRuleHistory,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdRuleHistory,
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_picture(self, fields=None, params=None, batch=None, pending=False):
from facebookads_v2.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 get_samples(self, fields=None, params=None, batch=None, pending=False):
from facebookads_v2.adobjects.productfeeduploaderrorsample import ProductFeedUploadErrorSample
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, 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_pending_owned_ad_accounts(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.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 create_owned_app(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'app_id': 'Object',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/owned_apps',
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_offline_conversion_data_set(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.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 api_get(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'breakdowns': 'list<breakdowns_enum>',
}
enums = {
'breakdowns_enum': AdStudyObjective.Breakdowns.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdStudyObjective,
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 = {
'app_event': 'string',
'app_id_for_app_event_firing': 'int',
'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=OffsitePixel,
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_shared_account(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'accounts': 'list<string>',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/shared_accounts',
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_requests(self, fields=None, params=None, batch=None, pending=False):
from facebookads_v2.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 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=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
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_test_lead(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'custom_disclaimer_responses': 'list<Object>',
'field_data': 'list<Object>',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/test_leads',
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 get_agencies(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.business import Business
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, 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_v2.adobjects.adaccount import AdAccount
param_types = {
'adaccounts': 'list<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=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 delete_external_event_sources(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'external_event_sources': 'list<string>',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='DELETE',
endpoint='/external_event_sources',
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_ads(self, fields=None, params=None, batch=None, pending=False):
from facebookads_v2.adobjects.ad import Ad
param_types = {
'effective_status': 'list<string>',
'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, 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_home_listings(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'bulk_pagination': 'bool',
'filter': 'Object',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/home_listings',
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_sessions(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.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,
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_set(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.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,
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_user(self, fields=None, params=None, batch=None, pending=False):
from facebookads_v2.adobjects.user import User
param_types = {
'namespace': 'string',
'payload': 'Object',
'session': 'Object',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/users',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=User,
api_type='EDGE',
response_parser=ObjectParser(target_class=User, 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_products(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.productitem import ProductItem
param_types = {
'bulk_pagination': 'bool',
'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,
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_v2.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()
