def create_ad(app_id: str, app_secret: str, account_access_token: str,
account_id: str, fields, params):
FacebookAdsApi.init(app_id, app_secret, account_access_token)
account = AdAccount(account_id)
return account.create_ad(fields=fields, params=params)
class FbApi(object):
def __init__(self, config_file=None):
self.config_file = config_file
self.df = pd.DataFrame()
self.config = None
self.account = None
self.campaign = None
self.app_id = None
self.app_secret = None
self.access_token = None
self.act_id = None
self.config_list = []
self.date_lists = None
self.field_lists = None
self.adset_dict = None
self.cam_dict = None
self.ad_dict = None
self.pixel = None
if self.config_file:
self.input_config(self.config_file)
def input_config(self, config_file):
logging.info('Loading Facebook config file: ' + str(config_file))
self.config_file = os.path.join(config_path, config_file)
self.load_config()
self.check_config()
FacebookAdsApi.init(self.app_id, self.app_secret, self.access_token)
self.account = AdAccount(self.config['act_id'])
def load_config(self):
try:
with open(self.config_file, 'r') as f:
self.config = json.load(f)
except IOError:
logging.error(self.config_file + ' not found. Aborting.')
sys.exit(0)
self.app_id = self.config['app_id']
self.app_secret = self.config['app_secret']
self.access_token = self.config['access_token']
self.act_id = self.config['act_id']
self.config_list = [
self.app_id, self.app_secret, self.access_token, self.act_id
]
def check_config(self):
for item in self.config_list:
if item == '':
logging.warning(item + 'not in FB config file. Aborting.')
sys.exit(0)
def set_id_name_dict(self, fb_object):
if fb_object == Campaign:
fields = ['id', 'name']
self.cam_dict = list(self.account.get_campaigns(fields=fields))
elif fb_object == AdSet:
fields = ['id', 'name', 'campaign_id']
self.adset_dict = list(self.account.get_ad_sets(fields=fields))
elif fb_object == Ad:
fields = ['id', 'name', 'campaign_id', 'adset_id']
self.ad_dict = list(self.account.get_ads(fields=fields))
def campaign_to_id(self, campaigns):
if not self.cam_dict:
self.set_id_name_dict(Campaign)
cids = [x['id'] for x in self.cam_dict if x['name'] in campaigns]
return cids
def adset_to_id(self, adsets, cids):
as_and_cam = list(itertools.product(adsets, cids))
if not self.adset_dict:
self.set_id_name_dict(AdSet)
asids = [
tuple([x['id'], x['campaign_id']]) for x in self.adset_dict
if tuple([x['name'], x['campaign_id']]) in as_and_cam
]
return asids
def create_campaign(self, campaign_name, objective, status, spend_cap):
if not self.cam_dict:
self.set_id_name_dict(Campaign)
if campaign_name in ([x['name'] for x in self.cam_dict]):
logging.warning(campaign_name + ' already in account. This ' +
'campaign was not uploaded.')
return None
self.campaign = Campaign(parent_id=self.account.get_id_assured())
self.campaign.update({
Campaign.Field.name: campaign_name,
Campaign.Field.objective: objective,
Campaign.Field.effective_status: status,
Campaign.Field.spend_cap: int(spend_cap),
Campaign.Field.special_ad_categories: 'NONE'
})
self.campaign.remote_create()
@staticmethod
def geo_target_search(geos):
all_geos = []
for geo in geos:
params = {
'q': geo,
'type': 'adgeolocation',
'location_types': [Targeting.Field.country],
}
resp = TargetingSearch.search(params=params)
all_geos.extend(resp)
return all_geos
@staticmethod
def target_search(targets_to_search):
all_targets = []
for target in targets_to_search[1]:
params = {
'q': target,
'type': 'adinterest',
}
resp = TargetingSearch.search(params=params)
if not resp:
logging.warning(target + ' not found in targeting search. ' +
'It was not added to the adset.')
continue
if targets_to_search[0] == 'interest':
resp = [resp[0]]
new_tar = [dict((k, x[k]) for k in ('id', 'name')) for x in resp]
all_targets.extend(new_tar)
return all_targets
@staticmethod
def get_matching_saved_audiences(audiences):
aud_list = []
for audience in audiences:
audience = CustomAudience(audience)
val_aud = audience.remote_read(fields=['targeting'])
aud_list.append(val_aud)
aud_list = aud_list[0]['targeting']
return aud_list
def get_matching_custom_audiences(self, audiences):
act_auds = self.account.get_custom_audiences(
fields=[CustomAudience.Field.name, CustomAudience.Field.id])
audiences = [{
'id': x['id'],
'name': x['name']
} for x in act_auds if x['id'] in audiences]
return audiences
def set_target(self, geos, targets, age_min, age_max, gender, device,
publisher_platform, facebook_positions):
targeting = {}
if geos and geos != ['']:
targeting[Targeting.Field.geo_locations] = {
Targeting.Field.countries: geos
}
if age_min:
targeting[Targeting.Field.age_min] = age_min
if age_max:
targeting[Targeting.Field.age_max] = age_max
if gender:
targeting[Targeting.Field.genders] = gender
if device and device != ['']:
targeting[Targeting.Field.device_platforms] = device
if publisher_platform and publisher_platform != ['']:
targeting[Targeting.Field.publisher_platforms] = publisher_platform
if facebook_positions and facebook_positions != ['']:
targeting[Targeting.Field.facebook_positions] = facebook_positions
for target in targets:
if target[0] == 'interest' or target[0] == 'interest-broad':
int_targets = self.target_search(target)
targeting[Targeting.Field.interests] = int_targets
if target[0] == 'savedaudience':
aud_target = self.get_matching_saved_audiences(target[1])
targeting.update(aud_target)
if target[0] == 'customaudience':
aud_target = self.get_matching_custom_audiences(target[1])
targeting[Targeting.Field.custom_audiences] = aud_target
return targeting
def create_adset(self, adset_name, cids, opt_goal, bud_type, bud_val,
bill_evt, bid_amt, status, start_time, end_time, prom_obj,
country, target, age_min, age_max, genders, device, pubs,
pos):
if not self.adset_dict:
self.set_id_name_dict(AdSet)
for cid in cids:
if adset_name in ([
x['name'] for x in self.adset_dict
if x['campaign_id'] == cid
]):
logging.warning(adset_name + ' already in campaign. This ' +
'ad set was not uploaded.')
continue
targeting = self.set_target(country, target, age_min, age_max,
genders, device, pubs, pos)
params = {
AdSet.Field.name: adset_name,
AdSet.Field.campaign_id: cid,
AdSet.Field.billing_event: bill_evt,
AdSet.Field.status: status,
AdSet.Field.targeting: targeting,
AdSet.Field.start_time: start_time,
AdSet.Field.end_time: end_time,
}
if bid_amt == '':
params['bid_strategy'] = 'LOWEST_COST_WITHOUT_CAP'
else:
params[AdSet.Field.bid_amount] = int(bid_amt)
if opt_goal in [
'CONTENT_VIEW', 'SEARCH', 'ADD_TO_CART', 'ADD_TO_WISHLIST',
'INITIATED_CHECKOUT', 'ADD_PAYMENT_INFO', 'PURCHASE',
'LEAD', 'COMPLETE_REGISTRATION'
]:
if not self.pixel:
pixel = self.account.get_ads_pixels()
self.pixel = pixel[0]['id']
params[AdSet.Field.promoted_object] = {
'pixel_id': self.pixel,
'custom_event_type': opt_goal,
'page_id': prom_obj
}
elif 'APP_INSTALLS' in opt_goal:
opt_goal = opt_goal.split('|')
params[AdSet.Field.promoted_object] = {
'application_id': opt_goal[1],
'object_store_url': opt_goal[2],
}
else:
params[AdSet.Field.optimization_goal] = opt_goal
params[AdSet.Field.promoted_object] = {'page_id': prom_obj}
if bud_type == 'daily':
params[AdSet.Field.daily_budget] = int(bud_val)
elif bud_type == 'lifetime':
params[AdSet.Field.lifetime_budget] = int(bud_val)
self.account.create_ad_set(params=params)
def upload_creative(self, creative_class, image_path):
cre = creative_class(parent_id=self.account.get_id_assured())
if creative_class == AdImage:
cre[AdImage.Field.filename] = image_path
cre.remote_create()
creative_hash = cre.get_hash()
elif creative_class == AdVideo:
cre[AdVideo.Field.filepath] = image_path
cre.remote_create()
creative_hash = cre.get_id()
else:
creative_hash = None
return creative_hash
def get_all_thumbnails(self, vid):
video = AdVideo(vid)
thumbnails = video.get_thumbnails()
if not thumbnails:
logging.warning('Could not retrieve thumbnail for vid: ' +
str(vid) + '. Retrying in 120s.')
time.sleep(120)
thumbnails = self.get_all_thumbnails(vid)
return thumbnails
def get_video_thumbnail(self, vid):
thumbnails = self.get_all_thumbnails(vid)
thumbnail = [x for x in thumbnails if x['is_preferred'] is True]
if not thumbnail:
thumbnail = thumbnails[1]
else:
thumbnail = thumbnail[0]
thumb_url = thumbnail['uri']
return thumb_url
@staticmethod
def request_error(e):
if e._api_error_code == 2:
logging.warning(
'Retrying as the call resulted in the following: ' + str(e))
else:
logging.error('Retrying in 120 seconds as the Facebook API call'
'resulted in the following error: ' + str(e))
time.sleep(120)
def create_ad(self,
ad_name,
asids,
title,
body,
desc,
cta,
durl,
url,
prom_obj,
ig_id,
view_tag,
ad_status,
creative_hash=None,
vid_id=None):
if not self.ad_dict:
self.set_id_name_dict(Ad)
for asid in asids:
if ad_name in [
x['name'] for x in self.ad_dict
if x['campaign_id'] == asid[1] and x['adset_id'] == asid[0]
]:
logging.warning(ad_name + ' already in campaign/adset. ' +
'This ad was not uploaded.')
continue
if vid_id:
params = self.get_video_ad_params(ad_name, asid, title, body,
desc, cta, url, prom_obj,
ig_id, creative_hash, vid_id,
view_tag, ad_status)
elif isinstance(creative_hash, list):
params = self.get_carousel_ad_params(ad_name, asid, title,
body, desc, cta, durl,
url, prom_obj, ig_id,
creative_hash, view_tag,
ad_status)
else:
params = self.get_link_ad_params(ad_name, asid, title, body,
desc, cta, durl, url,
prom_obj, ig_id,
creative_hash, view_tag,
ad_status)
for attempt_number in range(100):
try:
self.account.create_ad(params=params)
break
except FacebookRequestError as e:
self.request_error(e)
def get_video_ad_params(self, ad_name, asid, title, body, desc, cta, url,
prom_obj, ig_id, creative_hash, vid_id, view_tag,
ad_status):
data = self.get_video_ad_data(vid_id, body, title, desc, cta, url,
creative_hash)
story = {
AdCreativeObjectStorySpec.Field.page_id: str(prom_obj),
AdCreativeObjectStorySpec.Field.video_data: data
}
if ig_id and str(ig_id) != 'nan':
story[AdCreativeObjectStorySpec.Field.instagram_actor_id] = ig_id
creative = {AdCreative.Field.object_story_spec: story}
params = {
Ad.Field.name: ad_name,
Ad.Field.status: ad_status,
Ad.Field.adset_id: asid[0],
Ad.Field.creative: creative
}
if view_tag and str(view_tag) != 'nan':
params['view_tags'] = [view_tag]
return params
def get_link_ad_params(self, ad_name, asid, title, body, desc, cta, durl,
url, prom_obj, ig_id, creative_hash, view_tag,
ad_status):
data = self.get_link_ad_data(body, creative_hash, durl, desc, url,
title, cta)
story = {
AdCreativeObjectStorySpec.Field.page_id: str(prom_obj),
AdCreativeObjectStorySpec.Field.link_data: data
}
if ig_id and str(ig_id) != 'nan':
story[AdCreativeObjectStorySpec.Field.instagram_actor_id] = ig_id
creative = {AdCreative.Field.object_story_spec: story}
params = {
Ad.Field.name: ad_name,
Ad.Field.status: ad_status,
Ad.Field.adset_id: asid[0],
Ad.Field.creative: creative
}
if view_tag and str(view_tag) != 'nan':
params['view_tags'] = [view_tag]
return params
@staticmethod
def get_video_ad_data(vid_id, body, title, desc, cta, url, creative_hash):
data = {
AdCreativeVideoData.Field.video_id: vid_id,
AdCreativeVideoData.Field.message: body,
AdCreativeVideoData.Field.title: title,
AdCreativeVideoData.Field.link_description: desc,
AdCreativeVideoData.Field.call_to_action: {
'type': cta,
'value': {
'link': url,
},
},
}
if creative_hash[:4] == 'http':
data[AdCreativeVideoData.Field.image_url] = creative_hash
else:
data[AdCreativeVideoData.Field.image_hash] = creative_hash
return data
@staticmethod
def get_link_ad_data(body, creative_hash, durl, desc, url, title, cta):
data = {
AdCreativeLinkData.Field.message: body,
AdCreativeLinkData.Field.image_hash: creative_hash,
AdCreativeLinkData.Field.caption: durl,
AdCreativeLinkData.Field.description: desc,
AdCreativeLinkData.Field.link: url,
AdCreativeLinkData.Field.name: title,
AdCreativeLinkData.Field.call_to_action: {
'type': cta,
'value': {
'link': url,
},
},
}
return data
@staticmethod
def get_carousel_ad_data(creative_hash,
desc,
url,
title,
cta,
vid_id=None):
data = {
AdCreativeLinkData.Field.description: desc,
AdCreativeLinkData.Field.link: url,
AdCreativeLinkData.Field.name: title,
AdCreativeLinkData.Field.call_to_action: {
'type': cta,
'value': {
'link': url,
},
},
}
if creative_hash[:4] == 'http':
data['picture'] = creative_hash
else:
data[AdCreativeVideoData.Field.image_hash] = creative_hash
if vid_id:
data[AdCreativeVideoData.Field.video_id] = vid_id
return data
@staticmethod
def get_individual_carousel_param(param_list, idx):
if idx < len(param_list):
param = param_list[idx]
else:
logging.warning('{} does not have index {}. Using last available.'
''.format(param_list, idx))
param = param_list[-1]
return param
def get_carousel_ad_params(self, ad_name, asid, title, body, desc, cta,
durl, url, prom_obj, ig_id, creative_hash,
view_tag, ad_status):
data = []
for idx, creative in enumerate(creative_hash):
current_description = self.get_individual_carousel_param(desc, idx)
current_url = self.get_individual_carousel_param(url, idx)
current_title = self.get_individual_carousel_param(title, idx)
if len(creative) == 1:
data_ind = self.get_carousel_ad_data(creative_hash=creative[0],
desc=current_description,
url=current_url,
title=current_title,
cta=cta)
else:
data_ind = self.get_carousel_ad_data(creative_hash=creative[1],
desc=current_description,
url=current_url,
title=current_title,
cta=cta,
vid_id=creative[0])
data.append(data_ind)
link = {
AdCreativeLinkData.Field.message: body,
AdCreativeLinkData.Field.link: url[0],
AdCreativeLinkData.Field.caption: durl,
AdCreativeLinkData.Field.child_attachments: data,
AdCreativeLinkData.Field.call_to_action: {
'type': cta,
'value': {
'link': url[0],
},
},
}
story = {
AdCreativeObjectStorySpec.Field.page_id: str(prom_obj),
AdCreativeObjectStorySpec.Field.link_data: link
}
if ig_id and str(ig_id) != 'nan':
story[AdCreativeObjectStorySpec.Field.instagram_actor_id] = ig_id
creative = {AdCreative.Field.object_story_spec: story}
params = {
Ad.Field.name: ad_name,
Ad.Field.status: ad_status,
Ad.Field.adset_id: asid[0],
Ad.Field.creative: creative
}
if view_tag and str(view_tag) != 'nan':
params['view_tags'] = [view_tag]
return params
