def create_hotel(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.hotel import Hotel
param_types = {
'address': 'Object',
'applinks': 'Object',
'brand': 'string',
'description': 'string',
'guest_ratings': 'list<Object>',
'hotel_id': 'string',
'images': 'list<Object>',
'name': 'string',
'phone': 'string',
'star_rating': 'float',
'url': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/hotels',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Hotel,
api_type='EDGE',
response_parser=ObjectParser(target_class=Hotel, 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.adaccount import AdAccount
param_types = {
'billing_address_id': 'string',
'currency': 'string',
'end_advertiser': 'Object',
'funding_id': 'string',
'invoice': 'bool',
'io': 'bool',
'media_agency': 'string',
'name': 'string',
'partner': 'string',
'po_number': 'string',
'timezone_id': 'unsigned int',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adaccount',
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 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<string>',
'width': 'unsigned int',
}
enums = {
'ad_format_enum': AdPreview.AdFormat.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/previews',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdPreview,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdPreview),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_user_permission(self, fields=None, params=None, batch=None, pending=False):
self.assure_call()
param_types = {
'email': 'string',
'id': 'string',
'role': 'role_enum',
'user': '******',
}
enums = {
'role_enum': [
'ADMIN',
'EMPLOYEE',
'SYSTEM_USER',
'ADMIN_SYSTEM_USER',
'INSTAGRAM_ADMIN',
'INSTAGRAM_EMPLOYEE',
'FB_EMPLOYEE_ACCOUNT_MANAGER',
'FB_EMPLOYEE_SALES_REP',
],
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/userpermissions',
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_businesse(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.business import Business
param_types = {
'id': 'int',
'name': 'string',
'primary_page': 'string',
'sales_rep_email': 'string',
'survey_business_type': 'survey_business_type_enum',
'survey_num_assets': 'unsigned int',
'survey_num_people': 'unsigned int',
'timezone_id': 'unsigned int',
'vertical': 'vertical_enum',
}
enums = {
'survey_business_type_enum': Business.SurveyBusinessType.__dict__.values(),
'vertical_enum': Business.Vertical.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/businesses',
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
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_user_permission(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'business': 'string',
'user': '******',
'role': 'role_enum',
}
enums = {
'role_enum': [
'ADMIN',
'GENERAL_USER',
'REPORTS_ONLY',
],
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/userpermissions',
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_activities(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adactivity import AdActivity
param_types = {
'business_id': 'string',
'category': 'category_enum',
'since': 'datetime',
'uid': 'int',
'until': 'datetime',
}
enums = {
'category_enum': AdActivity.Category.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/activities',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdActivity,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdActivity,
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 = {
'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=Ad,
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_extended_access_token(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'grant_type': 'string',
'client_id': 'string',
'client_secret': 'string',
'fb_exchange_token': 'string',
}
enums = {}
request = FacebookRequest(
node_id='oauth',
method='GET',
endpoint='/access_token',
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(['access_token', 'token_type'])
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):
param_types = {
'adlabels': 'list<Object>',
'budget_rebalance_flag': 'bool',
'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=Campaign,
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_measurement_reports(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'filters': 'list<Object>',
'report_type': 'report_type_enum',
}
enums = {
'report_type_enum': [
'multi_channel_report',
'video_metrics_report',
'fruit_rollup_report',
'third_party_mta_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
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_leads(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.lead import Lead
self.assure_call()
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/leads',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Lead,
api_type='EDGE',
response_parser=ObjectParser(target_class=Lead),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
return request if pending else request.execute()
def create_ad_accounts(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adaccount import AdAccount
param_types = {
'access_type': 'access_type_enum',
'adaccount_id': 'string',
'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=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_measurement_report(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.measurementreport import MeasurementReport
self.assure_call()
param_types = {
'id': 'Object',
'metadata': 'string',
'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='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),
)
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 = {
'content_type': 'content_type_enum',
'description': 'string',
'exclusions': 'list<Object>',
'inclusions': 'list<Object>',
'lookalike_spec': 'string',
'name': 'string',
'opt_out_link': 'string',
'product_set_id': 'string',
'retention_days': 'unsigned int',
'rule': 'string',
}
enums = {
'content_type_enum': CustomAudience.ContentType.__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 create_hotel_rooms_batch(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.productcataloghotelroomsbatch import ProductCatalogHotelRoomsBatch
param_types = {
'file': 'file',
'standard': 'standard_enum',
'update_only': 'bool',
}
enums = {
'standard_enum':
ProductCatalogHotelRoomsBatch.Standard.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
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 get_delivery_estimate(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adcampaigndeliveryestimate import AdCampaignDeliveryEstimate
param_types = {
'optimization_goal': 'optimization_goal_enum',
'promoted_object': 'Object',
'targeting_spec': 'Targeting',
}
enums = {
'optimization_goal_enum':
AdCampaignDeliveryEstimate.OptimizationGoal.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/delivery_estimate',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdCampaignDeliveryEstimate,
api_type='EDGE',
response_parser=ObjectParser(
target_class=AdCampaignDeliveryEstimate, 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_user_permissions(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/userpermissions',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
# TODO: Create an actual object instead of using AbstractCrudObject with this list..
request._accepted_fields = list(request._accepted_fields)
request._accepted_fields.extend([
'business_persona', 'status', 'user', 'role', 'email',
'created_by', 'updated_by', 'created_time', 'updated_time',
'page_permissions', 'adaccount_permissions'
])
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_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 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 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 api_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {'name': 'string'}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Project,
api_type='NODE',
response_parser=ObjectParser(reuse_object=self),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_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_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_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 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_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'default_currency': 'string',
'deletion_enabled': 'bool',
'delimiter': 'delimiter_enum',
'encoding': 'encoding_enum',
'name': 'string',
'quoted_fields_mode': 'quoted_fields_mode_enum',
'schedule': 'string',
}
enums = {
'delimiter_enum': ProductFeed.Delimiter.__dict__.values(),
'encoding_enum': ProductFeed.Encoding.__dict__.values(),
'quoted_fields_mode_enum': ProductFeed.QuotedFieldsMode.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductFeed,
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_get(self, fields=None, params=None, batch=None, pending=False):
self.assure_call()
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdAsyncRequest,
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_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()
