Example #1
0
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
Example #2
0
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
Example #3
0
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=[
Example #4
0
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()
Example #5
0
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
Example #6
0
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