def test_campaign_upload(campaign_data, account):
"""
Args:
campaign_data (dict): parameters parsed from Json
account (str): Account where to upload the campaing
Returns:
TYPE: Description
"""
# Check if we're working with the correct account
active_account = AdAccount(account)
active_account.remote_read(fields=[AdAccount.Field.name])
print('Uploading a campaign to %s' % active_account[AdAccount.Field.name])
confirm = input('Do you want to continue? Y/N --> ')
if confirm not in ('y', 'Y'):
print('Aborted campaign upload')
return
print("\nRunning validations...")
# Initial validations
validate(campaign_data)
print("\nUploading campaign...")
# Get existing or create a new campaign
campaign_id = create_campaign(campaign_data, account)
print('Campaign uploaded!')
# Create Ad set
print("\nUploading AdSet...")
create_ad_set(campaign_data, account, campaign_id)
print('Ad set uploaded!')
def reach_esitmate():
cities = get_cities("Bangalore")
targeting_spec_city = []
for city in cities:
targeting_spec_city.append(
{
'key': city._data['key'],
'radius': 12,
'distance_unit': 'mile'
}
)
account = AdAccount('act_259842962')
targeting_spec = {
'geo_locations': {
'cities': targeting_spec_city
},
'age_min': 20,
'age_max': 40,
'custom_audiences': [6037977332713] # custom audience id
}
params = {
'optimize_for': AdSet.OptimizationGoal.offsite_conversions,
'targeting_spec': targeting_spec,
}
reach_estimate = account.get_reach_estimate(params=params)
print(reach_estimate)
return reach_estimate
def get_report(self, fields, params, file_dir):
"""
Uses asynchronous calls to avoid time out. Pins every 15 seconds to check status. Once done, pull
the data, and dump data into a local file
:param fields: all valid fields we can retrieve from an Ad account
:param params: specifies report level, report dates, breakdowns, filters
:param file_dir: specifies the downloading location
:return: None
"""
with gzip.open(file_dir, 'wb') as outfile:
for account_id in self.account_ids:
account = AdAccount('act_' + account_id)
async_job = account.get_insights(fields=fields,
params=params,
async=True)
async_job.remote_read()
while async_job[
AdReportRun.Field.async_status] != 'Job Completed':
time.sleep(5)
async_job.remote_read()
time.sleep(1)
for result in async_job.get_result():
json.dump(result.export_all_data(), outfile)
outfile.write('\n')
outfile.close()
def get_ads_insight(self, report_date,account_id):
ad_account = AdAccount(fbid=account_id)
limit = 5000
fields = ['campaign_name',
'ad_id',
'reach',
'date_start',
'date_stop',
'impressions',
'actions',
'ctr',
'clicks',
'objective',
'spend'
]
params = {
'time_range': {
'since': report_date,
'until': report_date
},
# 'date_preset':'last_7d',
'action_attribution_windows': ['28d_click','28d_view'],
'breakdowns': ['gender', 'age'],
'time_increment':'1',
'level': 'ad',
'limit': limit if limit > 0 else None
}
insights = ad_account.get_insights(fields, params)
return insights
def get_account_business_info(self, account_id):
account = AdAccount('act_%s' % str(account_id))
account.remote_read(fields=[AdAccount.Field.business])
business_info = account[AdAccount.Field.business]
if business_info:
return business_info
return {}
def get_account_info(self, account_id):
account = AdAccount('act_%s' % str(account_id))
account.remote_read(fields=[
AdAccount.Field.id, AdAccount.Field.name,
AdAccount.Field.account_status
])
if account: return account
return {}
def get_campaigns_info_by_account(self, account_id):
account = AdAccount('act_%s' % str(account_id))
campaigns = account.get_campaigns(fields=[
Campaign.Field.id, Campaign.Field.name, Campaign.Field.objective,
Campaign.Field.status, Campaign.Field.updated_time
])
if campaigns: return campaigns
return {}
def get_campaigns(account_id):
fields = ["id", "name"]
def decorate(x):
return {"value": x["id"], "name": x["name"]}
account = AdAccount(account_id)
return [decorate(x) for x in account.get_campaigns(fields)]
def get_ads_insight(self, account_id, from_time, to_time):
"""sample_response:: <api.Cursor> [
<AdsInsights> {
"ad_name": "Ad name here",
"adset_name": "Sample name",
"campaign_id": "123456789",
"campaign_name": "Campaign Test name",
"cost_per_unique_click": "0.727143",
"cpc": "0.727143",
"ctr": "1.62037",
"date_start": "2019-12-10",
"date_stop": "2019-12-10",
"spend": "5.09",
"clicks": "7",
"unique_clicks": "7"
},
]"""
params = self.build_params(from_time, to_time)
the_ad_account = AdAccount(account_id)
try:
async_job = the_ad_account.get_insights_async(fields=self.fields,
params=params)
status = async_job.remote_read()
while status['async_percent_completion'] < 100:
time.sleep(1)
status = async_job.remote_read()
result = async_job.get_result()
insight_data_list = []
for item_ad_insight in result._queue:
temp_dict = {}
for _key in self.fields:
try:
temp_dict.update({
_key:
item_ad_insight.__getitem__(_key),
})
except KeyError:
temp_dict.update({
_key: '',
})
if temp_dict:
insight_data_list.append(temp_dict)
for k in self.required_merged_field_list:
self.final_data.update(
{k: self.add_value_by_key(k, insight_data_list)})
if len(insight_data_list) > 0:
remaining_fields_set = set(self.fields) ^ set(
self.required_merged_field_list)
for f in remaining_fields_set:
# remaining fields has same value of all items of the list. That's why only first item is considered
self.final_data.update(
{f: insight_data_list[0].get(f, '')})
except FacebookRequestError:
pass
# print(er)
return self.final_data
def create_campaign(account_id, name, objective, status):
account = AdAccount(account_id)
campaign = Campaign(parent_id=account.get_id_assured())
campaign[Campaign.Field.name] = name
campaign[Campaign.Field.objective] = objective
campaign[Campaign.Field.configured_status] = status
print(campaign.remote_create())
def get_adset_info_by_account(self, account_id):
account = AdAccount('act_%s' % str(account_id))
adsets = account.get_ad_sets(fields=[
AdSet.Field.id, AdSet.Field.name, AdSet.Field.campaign_id,
AdSet.Field.status
])
if adsets: return adsets
return {}
def adset_comment_fetcher(account, params, fields):
"""
fetches ad ids and corresponding adset name from active campaigns for the selected ad account
"""
account = AdAccount(account)
adset_insights = account.get_insights(fields=fields, params=params)
for insight in adset_insights:
adset_name_ad_id[insight['adset_name']] = insight['ad_id']
return adset_name_ad_id
def getfacebookApi(self):
if self.secret != '-':
self.api = FacebookAdsApi.init(access_token=self.token,
app_secret=self.secret,
api_version='v3.2')
else:
self.api = FacebookAdsApi.init(access_token=self.token,
api_version='v3.2')
self.account = AdAccount('act_' + act_id)
def facebook_data_extraction(config):
'''
Facebook Ads platform data extraction
'''
facebook_get_service(config)
me = User(fbid='me')
print('me', me)
print('me.remote_read(fields=[User.Field.permissions])', me.remote_read())
ad_account = AdAccount(config['ad_account_id'])
print('ad_account', ad_account.remote_read())
print('ad_account', ad_account.get_campaigns())
return ''
def get_account_category(self, account_id):
account_category_dict = {"category": "unknow", "subcategory": "unknow"}
account = AdAccount('act_%s' % str(account_id))
application = account.get_applications(
fields=["category", "subcategory"])
if application:
if "category" in application[0].keys():
account_category_dict["category"] = application[0]["category"]
if "subcategory" in application[0].keys():
account_category_dict["subcategory"] = application[0][
"subcategory"]
return account_category_dict
def match_custom_audience(self, **kwargs):
fb_api_init()
out = []
words = [x.lower() for x in kwargs['words']]
account = AdAccount(kwargs['account_id'])
ca = account.get_custom_audiences(fields=[CustomAudience.Field.name])
for audience in ca:
if any(word in [x.lower() for x in audience['name'].split(' ')]
for word in words):
out.append(audience)
return out
def ad_ids_fetcher(account, params, fields):
"""
fetches ad ids from active campaigns for the selected ad account
"""
account = AdAccount(account)
try:
adset_insights = account.get_insights(fields=fields, params=params)
except Exception:
exception_catcher('/facebook_ads_comments_analyzer/')
ad_ids_list = [insight['ad_id'] for insight in adset_insights]
return ad_ids_list
def ads(self, report_date, account_id):
ad_account = AdAccount(fbid=account_id)
limit = 5000
fields = ['id', 'creative', Ad.Field.name]
params = {
'time_range': {
'since': report_date,
'until': report_date
},
# 'date_preset':'last_90d',
'limit': limit if limit > 0 else None
}
insights = ad_account.get_ads(fields, params)
return insights
def get_creatives(self, report_date, account_id):
ad_account = AdAccount(fbid=account_id)
limit = 500
fields = [AdCreative.Field.thumbnail_url]
params = {
'time_range': {
'since': report_date,
'until': report_date
},
# 'date_preset':'last_90d',
'limit': limit if limit > 0 else None
}
insights = ad_account.get_ad_creatives(fields, params)
return insights
def get_fb_data(AccountId):
FacebookAdsApi.init(facebookConfig.Configs['App_id'],
facebookConfig.Configs['App_secret'],
facebookConfig.Configs['Access_token'])
my_account = AdAccount(facebookConfig.Accounts[AccountId])
# Grab insight info for all ads in the adaccount
#Ever this function will get data from yesterday
#If somebody wants to change the range of date, is necessary to change the param 'date_preset'
#You can change the level of your request. example: ad, adset or campaign
'''
I dont recommend change the param date_preset because the data comes cumulative, not good for me.
The data from yesterday is better and trustworthy . I suggest to compare with reports from your Business manager facebook
'''
data = my_account.get_insights(
params={
'date_preset': 'yesterday',
'level': 'ad'
},
fields=[
AdsInsights.Field.account_id,
AdsInsights.Field.account_name,
#AdsInsights.Field.campaign_id,
AdsInsights.Field.campaign_name,
AdsInsights.Field.ad_name,
AdsInsights.Field.ad_id,
AdsInsights.Field.adset_id,
AdsInsights.Field.adset_name,
AdsInsights.Field.cost_per_outbound_click,
AdsInsights.Field.outbound_clicks,
AdsInsights.Field.spend,
AdsInsights.Field.clicks,
AdsInsights.Field.inline_link_clicks,
AdsInsights.Field.inline_link_click_ctr,
AdsInsights.Field.cpm,
AdsInsights.Field.ctr,
AdsInsights.Field.reach,
AdsInsights.Field.frequency,
AdsInsights.Field.impressions
])
dataNormalize = normalize.dumps_data(data)
df = normalize.change_types(dataNormalize)
return df
def create_video(request):
FacebookAdsApi.init(account_id=settings.FACEBOOK_MAIN_AD_ACCOUNT,
access_token=settings.FACEBOOK_TEST_TOKEN)
ad_video = AdAccount(
fbid=settings.FACEBOOK_MAIN_AD_ACCOUNT
).create_ad_video(
params={
AdVideo.Field.slideshow_spec: {
'images_urls': [
'https://www.downtownrochestermn.com/_files/images/sbs15tkssblue[1].png',
'http://d3sdoylwcs36el.cloudfront.net/VEN-virtual-enterprise-network-business-opportunities-small-fish_id799929_size485.jpg',
'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQmvDxaUoi9wsAm2H0qvdaCn8ISnkqOPSBDojx7WznZLoAMhvW_mjI7Pw'
]
}
})
return JsonResponse(ad_video.export_all_data(), safe=False)
def getvalues():
tmp_string = str(AdAccount(ad_account_id).get_insights(
fields=fields,
params=params,
)).split('<AdsInsights>')
tmp_string = str(tmp_string)[7:][:-3]
i = 2
list_of_jsons = str(tmp_string).split(', \'')
for json1 in list_of_jsons:
json1 = json1.replace('\\n ', '')
json1 = json1.replace('\\n', '')
try:
j = json.loads(json1)
cn = j['campaign_name']
sp = j['spend']
print cn
print type(cn)
cost = Decimal(sp) * Parser.q
print cost
sheet.update_acell('B1', month)
if modified_list.find(cn) != -1:
print ("String in the string!")
else:
sheet.update_acell('A' + str(i), cn)
sheet.update_acell('B' + str(i), cost)
i += 1
except ValueError:
'stupid error, everything works'
def get_campaign_data(ad_account: adaccount.AdAccount) -> {}:
"""Retrieves the campaign data of the ad account as a dictionary
Args:
ad_account: An ad account for which to retrieve the campaign data
Returns:
A dictionary with {campaign_id: {'name': 1, 'attributes': {}}} format
"""
logging.info('get campaign data for account {}'.format(ad_account['account_id']))
campaigns = ad_account.get_campaigns(
fields=['id',
'name',
'adlabels'],
params={'limit': 1000,
'status': ['ACTIVE',
'PAUSED',
'ARCHIVED']})
result = {}
for campaign in campaigns:
result[campaign['id']] = {'name': campaign['name'],
'attributes': parse_labels(
campaign.get('adlabels', []))}
return result
def read_campaign():
# account = AdAccount(ACCOUNT)
account = AdAccount.get_my_account() # > First account associated with the user
print(account)
adsets = account.get_ad_sets(fields=[AdSet.Field.targeting, AdSet.Field.name])
account.remote_read(fields=[AdAccount.Field.name])
print(adsets)
def __init__(self, account_id):
prefs = Preferences.objects.get()
ad_account_id = 'act_%s' % account_id
FacebookAdsApi.init(access_token=prefs.facebook_access_token)
fields = [
'account_id',
'account_name',
'cost_per_total_action',
'impressions',
'total_action_value',
'spend',
]
now = timezone.now()
last_day = calendar.monthrange(now.year, now.month)[1]
params = {
'time_range': {
'since': now.strftime('%Y-%m-01'),
'until': now.strftime('%Y-%m-') + '%s' % last_day
},
'filtering': [],
'level': 'account',
'breakdowns': [],
}
try:
self.data = AdAccount(ad_account_id).get_insights(fields=fields,
params=params)[0]
except:
self.data = None
def get_ad_accounts(self, business_id):
"""Returns list of adaccounts associated with the ads pixel"""
response = self.get_api_assured().call(
'GET',
(self.get_id_assured(), 'shared_accounts'),
params={'business': business_id},
).json()
ret_val = []
if response:
keys = response['data']
for item in keys:
search_obj = AdAccount()
search_obj.update(item)
ret_val.append(search_obj)
return ret_val
def get_campaign_list(account_id):
try:
ad_account = AdAccount(account_id)
campaigns = ad_account.get_campaigns(fields=[
Campaign.Field.name, Campaign.Field.id, Campaign.Field.status
])
active_campaign_hash = {}
for campaign in campaigns:
if 'ACTIVE' in campaign[Campaign.Field.status]:
active_campaign_hash[campaign[Campaign.Field.id]] = campaign[
Campaign.Field.name]
logger.info(active_campaign_hash)
return active_campaign_hash
except exceptions.FacebookError, e:
logger.error('Error %s' % e)
return {}
def get_ad_accounts(self, business_id):
"""Returns list of adaccounts associated with the ads pixel"""
response = self.get_api_assured().call(
'GET',
(self.get_id_assured(), 'shared_accounts'),
params={
'business': business_id
},
).json()
ret_val = []
if response:
keys = response['data']
for item in keys:
search_obj = AdAccount()
search_obj.update(item)
ret_val.append(search_obj)
return ret_val
def api_create(self,
parent_id,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adaccount import AdAccount
return AdAccount(api=self._api, fbid=parent_id).get_insights_async(
fields, params, batch, pending)
def api_create(self,
parent_id,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adaccount import AdAccount
return AdAccount(api=self._api, fbid=parent_id).create_custom_audience(
fields, params, batch, pending)
def api_create(self,
parent_id,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adaccount import AdAccount
return AdAccount(api=self._api,
fbid=parent_id).create_reach_frequency_prediction(
fields, params, batch, pending)
def get_prospecting_campaign_id(self, acc_id):
"""Takes in an account id and searches across the ad accounts campaigns looking for the campaign name Prospecting. If found, return the campaign id."""
account = AdAccount(acc_id).get_campaigns()
for camp in account:
campaign = Campaign(camp['id'])
campaign.remote_read(fields=[
Campaign.Field.name,
])
if campaign['name'] == 'Prospecting':
return camp['id']
def remote_read(
self,
batch=None,
failure=None,
fields=None,
params=None,
success=None,
api_version=None,
):
if self[self.__class__.Field.id]:
_, image_hash = self[self.__class__.Field.id].split(':')
account = AdAccount(fbid=self.get_parent_id_assured())
params = {
'hashes': [
image_hash,
],
}
images = account.get_ad_images(fields=fields, params=params)
if images:
self._set_data(images[0]._data)
def get_customer_audicence():
account = AdAccount('act_259842962')
resp = account.get_custom_audiences(fields=["name"])
print(resp)
return resp
params=params,
)
print 'adaccounts', adaccounts
adaccount_id = adaccounts[0].get_id()
print 'adaccount_id:', adaccount_id, '\n'
# AdCampaign create
fields = [
]
params = {
'name': 'My campaign',
'objective': 'LINK_CLICKS',
'status': 'PAUSED',
}
adcampaign = AdAccount(adaccount_id).create_campaign(
fields=fields,
params=params,
)
print 'adcampaign', adcampaign
adcampaign_id = adcampaign.get_id()
print 'adcampaign_id:', adcampaign_id, '\n'
# AdSet create
fields = [
]
params = {
'name': 'My Reach Ad Set',
'optimization_goal': 'REACH',
'billing_event': 'IMPRESSIONS',
'bid_amount': '2',
'daily_budget': '1000',
'campaign_id': adcampaign_id,
