def init(cls, app_id, app_secret, access_token, account_id=None):
session = FacebookSession(app_id, app_secret, access_token)
api = cls(session)
cls.set_default_api(api)
if account_id is not None:
cls.set_default_account_id(account_id)
def campaigns_with_insights(start, end):
response = []
try:
my_session = FacebookSession(my_app_id, my_app_secret, my_access_token)
my_api = FacebookAdsApi(my_session)
FacebookAdsApi.set_default_api(my_api)
me = objects.AdUser(fbid='me')
my_accounts = list(me.get_ad_accounts())
my_account = my_accounts[0]
fields = [
AdsInsights.Field.clicks, AdsInsights.Field.spend,
AdsInsights.Field.impressions, AdsInsights.Field.unique_clicks,
AdsInsights.Field.cost_per_unique_click,
AdsInsights.Field.cost_per_inline_link_click
]
params = {
'time_range': {
'since': start,
'until': end
},
'effective_status': ["ACTIVE"]
}
campaigns = my_account.get_campaigns(
params=params, fields=[Campaign.Field.name, Campaign.Field.status])
headers = [
"Name",
'Cost',
"Impressions",
"Clicks",
"Unique Clicks",
"Cost per unique click",
]
for i in campaigns:
try:
campaign = Campaign(i['id'])
campaign_data = campaign.get_insights(params=params,
fields=fields)
campaign_dict = {
'id':
i['id'],
'name':
i['name'],
'Cost':
campaign_data[0]['spend'],
"Clicks":
campaign_data[0]['clicks'],
"Unique_Clicks":
campaign_data[0]['unique_clicks'],
"Cost_per_unique_click":
campaign_data[0]['cost_per_unique_click'],
"Impressions":
campaign_data[0]['impressions']
}
response.append(campaign_dict)
except:
pass
except:
pass
return {'headers': headers, 'rows': response}
def insights(start, end):
response = {}
try:
my_session = FacebookSession(my_app_id, my_app_secret, my_access_token)
my_api = FacebookAdsApi(my_session)
FacebookAdsApi.set_default_api(my_api)
me = objects.AdUser(fbid='me')
my_accounts = list(me.get_ad_accounts())
my_account = my_accounts[0]
fields = [
AdsInsights.Field.clicks, AdsInsights.Field.spend,
AdsInsights.Field.impressions, AdsInsights.Field.unique_clicks,
AdsInsights.Field.cost_per_unique_click,
AdsInsights.Field.cost_per_inline_link_click
]
params = {
'time_range': {
'since': start,
'until': end
},
}
temp = my_account.get_insights(params=params, fields=fields)
try:
cost_per_click = float(temp[0]['spend']) / float(temp[0]['clicks'])
except:
cost_per_click = 0
response = [{
'field': 'Impressions',
'value': temp[0]['impressions']
}, {
'field': 'Cost',
'value': temp[0]['spend']
}, {
'field': 'Clicks',
'value': temp[0]['clicks']
}, {
'field': 'Unique Clicks',
'value': temp[0]['unique_clicks']
}, {
'field': 'Cost per unique click',
'value': temp[0]['cost_per_unique_click']
}, {
'field': 'Cost per Click',
'value': cost_per_click
}]
except:
pass
return response
def init(cls,
app_id=None,
app_secret=None,
access_token=None,
account_id=None,
api_version=None):
session = FacebookSession(app_id, app_secret, access_token)
api = cls(session, api_version)
cls.set_default_api(api)
if account_id:
cls.set_default_account_id(account_id)
return api
def init(cls,
app_id=None,
app_secret=None,
access_token=None,
account_id=None,
api_version=None,
pool_maxsize=10,
max_retries=0):
session = FacebookSession(app_id, app_secret, access_token,
pool_maxsize, max_retries)
api = cls(session, api_version)
cls.set_default_api(api)
if account_id:
cls.set_default_account_id(account_id)
return api
def setUp(self):
fbads_session = FacebookSession(
settings.SAMPLE_TEST['APP_ID'],
settings.SAMPLE_TEST['APP_SECRET'],
settings.SAMPLE_TEST['TOKEN'],
)
fbads_api = FacebookAdsApi(fbads_session)
FacebookAdsApi.set_default_api(fbads_api)
self.account_id = settings.SAMPLE_TEST['ACCOUNT_ID']
self.page_id = settings.SAMPLE_TEST['PAGE_ID']
self.form_id = '436706799859690' # For Lead Ads
image_files = [
"adimage0.png", "adimage1.jpg", "adimage2.jpg", "adimage3.jpg"
]
self.images = map(
lambda image_path: os.path.abspath(
os.path.join(os.path.dirname(__file__), image_path)),
image_files)
self.app_info = {
"app_name": "DiDiAds",
"appstore_link":
"https://play.google.com/store/apps/details?id=com.facebook.se.apac.example.liyuhk.didiadsa",
"app_deep_link": "example://detail/1234",
"fbapplication_id": "743337925789686",
"fbpage_id": "1426815194312958",
"fboffsitepixel_id": "null"
}
self.basic_targeting = {
"geo_locations": {
"countries": ["US"]
},
}
self.mobile_targeting = {
"geo_locations": {
"countries": ["US"]
},
"user_os": ["Android"],
"device_platforms": ["mobile"],
"publisher_platforms": ["facebook"],
"facebook_positions": ["feed"],
}
# Base custom audience id that can be used for creating LALs etc.
self.ca_id = "6034234313285"
def mine_suggestions(suggestion_data, max_suggestions=2000):
"""
Mine suggestions for all interests provided, add suggestions
to queue, keep mining until we hit the max.
:param suggestion_data: list of suggested interest names
:param max_suggestions: max number of suggestions to mine
:return:: new_suggestion_data: Name, ID info for all new suggestions.
"""
access_token, user_id, app_id, app_secret = load_facebook_auth()
session = FacebookSession(app_id, app_secret, access_token)
api = FacebookAdsApi(session)
new_suggestion_data = pd.DataFrame()
suggestion_queue = []
suggestion_queue += suggestion_data
suggestions_per_query = 1
relevant_cols = ['id', 'name', 'topic', 'path', 'audience']
while(new_suggestion_data.shape[0] < max_suggestions and
len(suggestion_queue) > 0):
s = suggestion_queue[:suggestions_per_query]
print('total data=%d; processing suggestions %s'%
(new_suggestion_data.shape[0], ','.join(s)))
suggestion_queue = suggestion_queue[suggestions_per_query:]
params = {
'type' : 'adinterestsuggestion',
'interest_list' : s,
}
s_results = TargetingSearch.search(params=params, api=api)
s_df = pd.DataFrame(s_results)
s_df = s_df.loc[:, set(relevant_cols) & set(s_df.columns)]
# temp: restrict to top-k results to stay on-topic
s_df = s_df.iloc[:25, :]
# remove duplicates
if(s_df.shape[0] > 0):
if(new_suggestion_data.shape[0] > 0):
s_df = s_df[~s_df.loc[:, 'id'].isin(new_suggestion_data.loc[:, 'id'])]
new_suggestion_data = new_suggestion_data.append(s_df)
# add new names to suggestion data
suggestion_queue += s_df.loc[:, 'name'].values.tolist()
return new_suggestion_data
def get_session_user(request):
user = None
# check the userid and access token in the session
# if exists get the user and install on the request
# if not exists, redirect to login page with next
fb_userid = request.session.get('fbuserid', None)
token = request.session.get('token', None)
if (fb_userid is not None and token is not None):
logger.debug("Found fb_userid in session. Getting User object")
user = FBAuthBackend().get_user(fb_userid)
if user is not None:
logger.debug("Got the User object")
# TODO we should move these lines to the sample code
# to make samples more self-contained
fbads_session = FacebookSession(
settings.FACEBOOK_APP_ID,
settings.FACEBOOK_APP_SECRET,
token)
fbads_api = FacebookAdsApi(fbads_session)
# Set the user agent for the API requests from default
# "fb-python-ads-api-sdk-%s" % SDK_VERSION, to
# "fb-python-ads-muse-%s" % SDK_VERSION,
fbads_api.HTTP_DEFAULT_HEADERS['User-Agent'] = \
"fb-python-ads-muse-" + fbads_api.SDK_VERSION
FacebookAdsApi.set_default_api(fbads_api)
request.fbads_api = fbads_api
logger.debug("Added fbads_api to request")
else:
logger.info("The fb_userid in session did not map to a valid user.")
clear_session_user(request)
else:
logger.debug("fb_userid and/or token not found in session")
FacebookAdsApi.set_default_api(None)
return user
def init(
cls,
app_id=None,
app_secret=None,
access_token=None,
account_id=None,
api_version=None,
proxies=None,
timeout=None,
api_container=None,
):
if api_container:
api = api_container.get_api()
else:
session = FacebookSession(app_id, app_secret, access_token, proxies,
timeout)
api = cls(session, api_version)
api_container = api_utils.ApiContainer([api])
cls.set_default_api(api)
cls.set_default_api_container(api_container)
if account_id:
cls.set_default_account_id(account_id)
return api
Upload a video to adaccount
"""
sdk_path = os.path.abspath(os.path.join(__file__, os.pardir))
sys.path.insert(1, sdk_path)
config_filename = os.path.join(sdk_path, '.credentials/facebook.json')
config_file = open(config_filename)
config = json.load(config_file)
config_file.close()
# Setup session and api objects
session = FacebookSession(
config['app_id'],
config['app_secret'],
config['access_token'],
)
FacebookAdsApi.set_default_api(FacebookAdsApi(session))
if __name__ == '__main__':
business = Business('1628260363868706')
ad_accounts = list(business.get_owned_ad_accounts())
print ad_accounts
# # create video object
# video = AdVideo(parent_id=config['act_id'])
# video_path = os.path.join(
# os.path.dirname(__file__),
def __init__(self): session = FacebookSession(fb_app_id, fb_app_secret, fb_extended_token) api = FacebookAdsApi(session) FacebookAdsApi.set_default_api(api) self.me = User(fbid='me') self.getAccounts()
from facebookads.session import FacebookSession
from facebookads.api import FacebookAdsApi
from facebookads import objects
from facebookads.objects import AdUser, AdCampaign
import os
my_app_id = os.environ.get('FB_APP_ID')
my_app_secret = os.environ.get('FB_SECRET_KEY')
my_access_token = os.environ.get('FB_ACCESS_TOKEN')
my_session = FacebookSession(my_app_id, my_app_secret, my_access_token)
my_api = FacebookAdsApi(my_session)
FacebookAdsApi.set_default_api(my_api)
me = objects.AdUser(fbid='me')
my_accounts = list(me.get_ad_accounts())
my_account = my_accounts[1]
print(">>> Campaign Stats")
for campaign in my_account.get_ad_campaigns(fields=[AdCampaign.Field.name]):
for stat in campaign.get_stats(fields=[
'impressions',
'clicks',
'spent',
'unique_clicks',
'actions',
]):
print(campaign[campaign.Field.name])
for statfield in stat:
print("\t%s:\t\t%s" % (statfield, stat[statfield]))
class Adapter:
""" An object designed to make managing custom audiences a little easier.
:params account: str, account id
:params table: str, table name from database
return :: container.Adapter object
"""
__session = FacebookSession(config.APP_ID, config.APP_SECRET,
config.ACCESS_TOKEN)
__api = FacebookAdsApi(__session)
def __init__(self, account=None, table='customers'):
FacebookAdsApi.set_default_api(self.__api)
if account:
self._account = 'act_{}'.format(account)
self.__api.set_default_account_id = self._account
self._audiences = AdAccount(self._account).get_custom_audiences(
fields=[CustomAudience.Field.name, CustomAudience.Field.id])
self._responses = []
def _get_audience(self, audience_name):
""" This retrieves an audience object based on a string name.
:params audience_name: str, name of audience
"""
for audience in list(self.audiences):
if audience['name'] == audience_name:
audience_id = audience['id']
target = CustomAudience(audience_id)
return target
def _batch_users(self, obj, size=2500):
""" This returns a generator that returns a list
of lists of a specific size.
:params obj: list, users list that needs to be batched
:params size: int, the batch size
"""
for chunk in range(0, len(obj), size):
try:
yield obj[chunk:chunk + size]
except IndexError:
yield obj[chunk:len(obj)]
def create_audience(self, name, desc=None):
""" This creates an audience object.
:params name: str, name of audience
:params desc: str, description of audience
"""
if name in [audience['name'] for audience in self.audiences]:
raise ValueError(
'Attempted to add audience. Audience with same name exists.')
audience = CustomAudience(parent_id=self._account)
audience[CustomAudience.Field.subtype] = CustomAudience.Subtype.custom
audience[CustomAudience.Field.name] = '{}'.format(name)
if desc:
audience[CustomAudience.Field.description] = desc
audience.remote_create()
def delete_audience(self, name):
""" This deletes an audience object.
:params name: str, name of audience
"""
if name not in [audience['name'] for audience in self.audiences]:
raise ValueError(
'Attempted to remove audience. Audience does not exist.')
for audience in list(self.audiences):
if audience['name'] == name:
delete_id = audience['id']
audience = CustomAudience(delete_id)
audience.remote_delete()
def add_users(self, name, users):
""" This bulk adds users to an audience object.
:params name: str, name of audience
:params users: list, list of users
"""
if not len(users):
return print('Attempted to add users. No users in the list.')
print('Adding {} users to {}'.format(len(users), name))
if not isinstance(users, list):
raise TypeError
target = self._get_audience(name)
if len(users) > 10000: # User add limit is ~10000.
batches = self._batch_users(users)
for batch in batches:
post_ = target.add_users(CustomAudience.Schema.email_hash,
batch,
is_raw=True)
pprint.pprint(post_._body)
else:
post_ = target.add_users(CustomAudience.Schema.email_hash,
users,
is_raw=True)
def remove_users(self, name, users):
""" This bulk deletes users from an audience object.
:params name: str, name of audience
:params users: list, list of users
"""
if not len(users):
return print('Attempted to remove users. No users in the list.')
print('Removing {} users to {}'.format(len(users), name))
if not isinstance(users, list):
raise TypeError
target = self._get_audience(name)
if len(users) > 500: # User delete limit is 500 < x < 1000.
batches = self._batch_users(users, size=500)
for batch in batches:
target.remove_users(CustomAudience.Schema.email_hash, batch)
else:
target.remove_users(CustomAudience.Schema.email_hash, users)
@property
def audiences(self):
return AdAccount(self._account).get_custom_audiences(
fields=[CustomAudience.Field.name, CustomAudience.Field.id])
def __str__(self):
return '<[Adapter Object]>'
def __repr__(self):
return '<Adapter Object [{}]>'.form(self._account)
