def get_ad_data(ad_account: adaccount.AdAccount) -> {}:
"""Retrieves the ad data of the ad account as a dictionary
Args:
ad_account: An ad account for which to retrieve the ad data
Returns:
A dictionary with {ad_id: {'name': 1, 'ad_set_id': 2, 'attributes': {}}} format
"""
logging.info('get ad data for account {}'.format(ad_account['account_id']))
ads = ad_account.get_ads(fields=['id', 'name', 'adset_id', 'adlabels'],
params={
'limit': 1000,
'status': ['ACTIVE', 'PAUSED', 'ARCHIVED']
})
result = {}
for ad in ads:
result[ad['id']] = {
'name': ad['name'],
'ad_set_id': ad['adset_id'],
'attributes': parse_labels(ad.get('adlabels', []))
}
return result
params = {'date_presets': 'lifetime'}
# TODO: Clean up this part and create methods / class with verification
File.write(
"../data/" + output_filename,
arrayToTSVLine([
"ad_name".upper(), "ad_id".upper(), "campaign_id".upper(),
"account_id".upper(), "adset_id".upper(), "status".upper(),
"clicks".upper(), "cpc".upper(), "cpm".upper(), "cpp".upper(),
"ctr".upper(), "spend".upper(), "relevance_score".upper(),
"date_start".upper(), "date_end".upper()
]))
for ad in account.get_ads(fields, params=params):
# Ad Initialization
current_ad = Ad(ad["id"])
status = ad["status"]
fields = [
'spend', 'clicks', 'ad_id', 'adset_id', 'account_id', 'campaign_id',
'cost_per_unique_click', 'cpc', 'cpp', 'cpc', 'cpm', 'ctr',
'date_start', 'date_stop', 'reach', 'frequency', 'impressions',
'social_spend', 'unique_ctr', 'unique_clicks', 'ad_name'
]
params = {'date_presets': 'lifetime'}
# Get all insights above from current AD
from facebook_business.adobjects.adcreative import AdCreative
from facebook_business.adobjects.adaccountuser import AdAccountUser as AdUser
import config
import pprint
pp = pprint.PrettyPrinter(indent=4)
my_app_id = config.my_app_id
my_app_secret = config.my_app_secret
my_access_token = config.my_access_token
FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
my_account = AdAccount(config.my_account)
#print('>>> Reading permissions field of user:'******'''
print(">>> Campaign Stats")
for campaign in my_account.get_ad_campaigns(fields=[AdCampaign.Field.name]):
for stat in campaign.get_stats(fields=[
def get_ads(app_id: str, app_secret: str, account_access_token: str,
account_id: str):
FacebookAdsApi.init(app_id, app_secret, account_access_token)
account = AdAccount(account_id)
return account.get_ads()
class LibFacebook:
def __init__(self, app_id, app_secret, access_token, ad_account_id):
FacebookAdsApi.init(app_id, app_secret, access_token)
self.account = AdAccount(ad_account_id)
def create_ad_tree(self):
# Campaign fields
fields = ["id",
"account_id",
"adlabels",
"bid_strategy",
"boosted_object_id",
"brand_lift_studies",
"budget_rebalance_flag",
"budget_remaining",
"buying_type",
"can_create_brand_lift_study",
"can_use_spend_cap",
"configured_status",
"created_time",
"daily_budget",
"effective_status",
"issues_info",
"lifetime_budget",
"name",
"objective",
"recommendations",
"source_campaign",
"source_campaign_id",
"spend_cap",
"start_time",
"status",
"stop_time",
"updated_time"]
# List of all campaigns
campaigns = self.account.get_campaigns(fields=fields)
# Ad set fields
fields = ["id",
"account_id",
"adlabels",
"adset_schedule",
"attribution_spec",
"bid_amount",
"bid_info",
"bid_strategy",
"billing_event",
"budget_remaining",
"campaign",
"campaign_id",
"configured_status",
"created_time",
"creative_sequence",
"daily_budget",
"daily_min_spend_target",
"daily_spend_cap",
"destination_type",
"effective_status",
"end_time",
"frequency_control_specs",
"instagram_actor_id",
"is_dynamic_creative",
"issues_info",
"lifetime_budget",
"lifetime_imps",
"lifetime_min_spend_target",
"lifetime_spend_cap",
"name",
"optimization_goal",
"pacing_type",
"promoted_object",
"recommendations",
"recurring_budget_semantics",
"rf_prediction_id",
"source_adset",
"source_adset_id",
"start_time",
"status",
"targeting",
"time_based_ad_rotation_id_blocks",
"time_based_ad_rotation_intervals",
"updated_time",
"use_new_app_click"]
# List of all ad sets
ad_sets = self.account.get_ad_sets(fields=fields)
# Ad fields
fields = ["id",
"account_id",
"ad_review_feedback",
"adlabels",
"adset",
"adset_id",
"bid_amount",
"bid_info",
"bid_type",
"campaign",
"campaign_id",
"configured_status",
"conversion_specs",
"created_time",
"creative",
"effective_status",
"issues_info",
"last_updated_by_app_id",
"name",
"recommendations",
"source_ad",
"status",
"tracking_specs",
"updated_time"]
# List of all ads
ads = self.account.get_ads(fields=fields)
ad_tree = []
for i in campaigns:
ad_structure_dict = {"campaign": i.export_all_data(),
"adset_list": []}
a = 0
for j in ad_sets:
if j["campaign_id"] == i["id"]:
ad_structure_dict["adset_list"].append({"ad_set": j.export_all_data(),
"ad_list": []})
for k in ads:
if k["adset_id"] == j["id"]:
ad_structure_dict["adset_list"][a]["ad_list"].append({"ad": k.export_all_data()})
a += 1
ad_tree.append(ad_structure_dict)
return ad_tree
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