def list_custom_audiences():
FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
my_account = AdAccount(f'act_{ad_account}')
fields = ['account_id'
,'approximate_count'
,'customer_file_source'
,'data_source'
,'delivery_status'
,'description'
,'household_audience'
,'id'
,'is_household'
,'is_snapshot'
,'is_value_based'
,'name'
,'operation_status'
,'permission_for_actions'
,'retention_days'
,'seed_audience'
,'sharing_status'
,'subtype'
,'time_content_updated'
,'time_created'
,'time_updated'
]
audiences = my_account.get_custom_audiences(fields=fields)
return audiences
def main():
db = Db(dbconfig)
FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
for account in accounts:
my_account = AdAccount(fbid=account)
adcampaigns = fetch_campaigns(my_account)
adsets = fetch_adsets(my_account)
ads = fetch_ads(my_account)
delete_from_db(db, 'ams_ad_compaign_stat_h',
'stat_dt="{}"'.format(yesterday))
delete_from_db(db, 'ams_ad_set_stat_h',
'stat_dt="{}"'.format(yesterday))
delete_from_db(db, 'ams_ad_stat_h', 'stat_dt="{}"'.format(yesterday))
'''
for adcampaign in adcampaigns:
print(adcampaign)
replace_into_db(db, 'ams_ad_compaign', adcampaign)
campaign_stats = fetch_campaign_data(adcampaign['facebook_ad_campaign_id'])
for campaign_stat in campaign_stats:
insert_into_db(db, 'ams_ad_compaign_stat_h', campaign_stat)
'''
for adset in adsets:
# 如果广告组数据为当天创建或更新，则插入
print(adset)
replace_into_db(db, 'ams_ad_set', adset)
adset_stats = fetch_adset_data(adset['facebook_adset_id'])
for adset_stat in adset_stats:
print(adset_stat)
insert_into_db(db, 'ams_ad_set_stat_h', adset_stat)
def input_config(self, config):
logging.info('Loading Facebook config file: {}'.format(config))
self.configfile = os.path.join(config_path, config)
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 init_api(access_token):
'''
initiates the facebook api
args:
access_token : long-lived access token (provided from backend) <STRING>
'''
FacebookAdsApi.init(access_token=access_token)
def view_ad(request):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
my_account = AdAccount('act_' + user_id)
adsets = my_account.get_ad_sets()
adset_id = []
for i in range(len(adsets)):
adset_id.append(adsets[i]["id"])
for adset in adset_id:
ad_set = AdSet(adset)
fields = [
Ad.Field.name,
Ad.Field.id,
]
ad_iter = ad_set.get_ads(fields=fields)
ad_data = []
for ad in ad_iter:
result = {}
result["id"] = ad[Ad.Field.id]
result["name"] = ad[Ad.Field.name]
ad_data.append(result)
context = {'ads': ad_data}
return render(request, 'fbapp/view_ad.html', context)
def view_adset(request):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
my_account = AdAccount('act_' + user_id)
adsets = my_account.get_ad_sets()
adset_id = []
for i in range(len(adsets)):
adset_id.append(adsets[i]["id"])
adset_data = []
for id in adset_id:
adset = AdSet(fbid=id)
fields = [
AdSet.Field.name,
AdSet.Field.effective_status,
AdSet.Field.campaign_id,
AdSet.Field.status,
]
adset.remote_read(fields=fields)
result = {}
result["id"] = id
result["name"] = adset[AdSet.Field.name]
result["campid"] = adset[AdSet.Field.campaign_id]
result["status"] = adset[AdSet.Field.status]
result["data_1"] = "ACTIVE"
result["data_2"] = "PAUSED"
adset_data.append(result)
context = {'adsets': adset_data}
return render(request, 'fbapp/view_adset.html', context)
def get_location():
location_query = request.form['location_query']
# reference: https://developers.facebook.com/docs/marketing-api/targeting-search#geo
params = {
'q': location_query,
'type': 'adgeolocation',
'location_types': ['city'], # only city results
'limit': 5,
"country_code": "US", # only search results from US
}
FacebookAdsApi.init(access_token=g.user['access_token'],
api_version='v3.3')
data = TargetingSearch.search(params=params)
list = []
for i in range(len(data)):
#{'name':"Charleston, SC, United States", 'type': 'city'}
str = data[i]["name"] + ", " + data[i]["region"] + ", " + data[i][
"country_code"]
list.append({
'name': str,
'type': data[i]["type"],
'key': data[i]["key"]
})
return jsonify(list)
def list_ad_set():
FacebookAdsApi.init(access_token=my_access_token)
fields = [
'account_id',
'attribution_spec',
'bid_strategy',
'billing_event',
'budget_remaining',
'campaign',
'campaign_id',
'configured_status',
'created_time',
'creative_sequence',
'daily_budget',
'destination_type',
'effective_status',
'id',
'lifetime_budget',
'lifetime_imps',
'name',
'optimization_goal',
'pacing_type',
'recommendations',
'recurring_budget_semantics',
'source_adset_id',
'start_time',
'status',
'targeting',
'updated_time',
'use_new_app_click',
]
return Campaign(f'act_{ad_account}').get_ad_sets(fields=fields)
def view_campaign(request):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
my_account = AdAccount('act_' + user_id)
campaigns = my_account.get_campaigns()
camp_id = []
for i in range(len(campaigns)):
camp_id.append(campaigns[i]["id"])
campaign_data = []
for id in camp_id:
campaign = Campaign(fbid=id)
fields = [
Campaign.Field.id,
Campaign.Field.name,
Campaign.Field.status,
]
campaign.remote_read(fields=fields)
result = {}
result["id"] = campaign[Campaign.Field.id]
result["name"] = campaign[Campaign.Field.name]
result["status"] = campaign[Campaign.Field.status]
result["data_1"] = "ACTIVE"
result["data_2"] = "PAUSED"
campaign_data.append(result)
context = {'campaigns': campaign_data}
return render(request, 'fbapp/view_campaign.html', context)
def manager(adaccount):
FacebookAdsApi.init(cfg.my_app_id, cfg.my_app_secret, cfg.my_access_token, proxies=proxies)
my_account = AdAccount(adaccount)
db_model = GetFacebook(cfg.dbconfig)
print('asss')
# ad_campaign_object = GetCampaigns(my_account, db_model)
# ad_set_object = GetAdsets(my_account, db_model)
# ad_object = GetAds(my_account, db_model)
creative_object = GetCreative(my_account, db_model)
print('fghhh')
# adcampaigns = ad_campaign_object.fetch_campaigns()
# worker_basic(ad_campaign_object.handle_campaign, adcampaigns)
# active_campaigns = db_model.get_active_campaigns()
# active_campaigns = [active_campaign[0] for active_campaign in active_campaigns]
# print(active_campaigns)
# worker_stat(ad_campaign_object.handle_campaign_data, active_campaigns)
# adsets = ad_set_object.fetch_ad_sets()
# worker_basic(ad_set_object.handle_ad_sets, adsets)
# active_adsets = db_model.get_active_adsets()
# active_adsets = ['23842905693710040']
# active_campaigns = [active_adset[0] for adset in adsets]
# worker_stat(ad_set_object.handle_adset_data, active_adsets)
# ads = ad_object.fetch_ads()
# worker_basic(ad_object.handle_ads, ads)
creative_object = GetCreative(my_account, db_model)
creatives = creative_object.fetch_adcreative()
worker_basic(creative_object.handle_creatives, creatives)
def create_adset(request):
if request.method == 'GET':
access_token=request.headers['token']
campaignId = request.GET.get('campignId')
app_secret = 'db4b3037cd105cfd23b6032aecd2c3ff'
app_id = '263805807945856'
id = 'act_2770121319724389'
CAMPAIGN_ID = campaignId
FacebookAdsApi.init(access_token=access_token)
fields = []
params = {
'name': 'My Reach Ad Set',
'optimization_goal': 'REACH',
'billing_event': 'IMPRESSIONS',
'end_time': '2020-5-19T23:43:36-0800',
'bid_amount': '2',
'daily_budget': 20979,
'campaign_id': '23844605998330207',
'status': 'PAUSED',
'targeting': {'facebook_positions':['feed'],'geo_locations':{'countries':['IN']},'user_os':['iOS']},
}
adsets= AdAccount(id).create_ad_set(
fields=fields,
params=params,
)
return Response(adsets)
else:
return HttpResponse('not found')
def list_campaigns():
FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
my_account = AdAccount(f'act_{ad_account}')
fields = [
'account_id',
'budget_rebalance_flag',
'budget_remaining',
'buying_type',
'can_create_brand_lift_study',
'can_use_spend_cap',
'configured_status',
'created_time',
'effective_status',
'id',
'name',
'objective',
'recommendations',
'source_campaign',
'source_campaign_id',
'spend_cap',
'start_time',
'status',
'updated_time',
]
return my_account.get_campaigns(fields=fields)
def removebg(request):
if request.method=='GET':
# access_token='bb8bbe1bee5159f369d60e626700ed747d9468ad'
access_token=request.headers['token']
adds=[]
app_secret = 'db4b3037cd105cfd23b6032aecd2c3ff'
app_id = '263805807945856'
# id = 'act_2770121319724389'
id = request.GET.get('userId')
FacebookAdsApi.init(access_token=access_token)
fields = [
'name',
'objective',
]
params = {
'effective_status': ['ACTIVE','PAUSED'],
}
add=AdAccount(id).get_campaigns(
fields=fields,
params=params)
data1=[]
for i in add:
data={
'id':i['id'],
'name':i['name']
}
data1.append(data)
print(data1)
return JsonResponse(data1, safe=False)
else:
return HttpResponse('not found')
def create_adset(request, camid):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
my_account = AdAccount('act_' + user_id)
adset = AdSet(parent_id=my_account.get_id_assured())
adset[AdSet.Field.name] = 'Ad Set created by afnan -' + str(
random.randint(1, 10))
adset[AdSet.Field.promoted_object] = {
'application_id': app_id,
}
adset[AdSet.Field.campaign_id] = camid
adset[AdSet.Field.daily_budget] = 10000
adset[AdSet.Field.billing_event] = AdSet.BillingEvent.impressions
adset[AdSet.Field.bid_amount] = 2
adset[AdSet.Field.status] = 'PAUSED'
adset[AdSet.Field.targeting] = {
Targeting.Field.geo_locations: {
'countries': ['US'],
},
Targeting.Field.publisher_platforms: ['facebook', 'audience_network'],
Targeting.Field.device_platforms: ['mobile'],
Targeting.Field.user_os: [
'IOS',
],
}
adset.remote_create()
result = {"id": adset.get_id()}
return redirect('view-adset')
def auth(cls):
"""
Prepare for Ads API calls and return a tuple with act_id
and page_id. page_id can be None but act_id is always set.
"""
config = cls.load_config()
if cls._is_authenticated:
return config['act_id'], config.get('page_id', None)
if config['app_id'] and config['app_secret'] \
and config['act_id'] and config['access_token']:
FacebookAdsApi.init(
config['app_id'],
config['app_secret'],
config['access_token'],
config['act_id'],
)
cls._is_authenticated = True
return config['act_id'], config.get('page_id', None)
else:
required_fields = set(
('app_id', 'app_secret', 'act_id', 'access_token'))
missing_fields = required_fields - set(config.keys())
raise FacebookError(
'\n\tFile config.json needs to have the following fields: {}\n'
'\tMissing fields: {}\n'.format(
', '.join(required_fields),
', '.join(missing_fields),
))
def update_ad_set_targeting(request):
if request.method == 'POST':
print('----------------------------------')
access_token=request.headers['token']
received_json_data = json.loads(request.body)
latitude = received_json_data['lati']
latitude = float(latitude)
print(latitude)
longitude = received_json_data['long']
longitude = float(longitude)
print(longitude)
adsetId = request.GET.get('adsetId')
app_secret = 'db4b3037cd105cfd23b6032aecd2c3ff'
app_id = '263805807945856'
ADSET_ID = adsetId
FacebookAdsApi.init(access_token=access_token)
fields = ['targeting']
print(fields)
params = {
'targeting': {'geo_locations':{'custom_locations':[
{
"radius":30,
"latitude":latitude,
"longitude":longitude
}]},},
}
updateadset= AdSet(ADSET_ID).api_update(
fields=fields,
params=params,
)
print(updateadset)
return Response(updateadset)
else:
return HttpResponse('not found')
def image_upload(image_path):
files = list()
image_path = unidecode(image_path)
print(image_path)
if not os.path.isfile(f'samples/images/{image_path}.png'):
for file in os.listdir('samples/images/'):
if file.startswith(image_path.split('_')[0]):
files.append(file)
for file in os.listdir('samples/images/'):
if file.startswith(image_path[0:3]):
files.append(file)
if not files:
for file in os.listdir('samples/images/'):
if file.startswith(image_path[0]):
files.append(file)
# pprint(files)
# image_path = input('Set valid path: ')
image_path = files[0]
FacebookAdsApi.init(access_token=my_access_token)
image = AdImage(parent_id=f'act_{ad_account}')
if image_path.endswith('.png'):
image[AdImage.Field.filename] = f'samples/images/{image_path}'
else:
image[AdImage.Field.filename] = f'samples/images/{image_path}.png'
image.remote_create()
image_hash = image[AdImage.Field.hash]
return image_hash
def create_ad_set(campaign_id, audience_id, audience_name):
try:
FacebookAdsApi.init(access_token=my_access_token)
fields = []
params = {
AdSet.Field.name: audience_name,
AdSet.Field.campaign_id: campaign_id,
AdSet.Field.daily_budget: 5000,
AdSet.Field.start_time: int(time.time()),
AdSet.Field.end_time: int(time.time() + 100000),
AdSet.Field.optimization_goal: AdSet.OptimizationGoal.video_views,
AdSet.Field.billing_event: AdSet.BillingEvent.video_views,
AdSet.Field.bid_amount: 100,
AdSet.Field.targeting: {
"geo_locations": {
"countries": ["UA"],
},
"age_min": 18,
"age_max": 65,
"publisher_platforms": ['facebook'],
"custom_audiences": [{
"id": audience_id
}]
},
Targeting.Field.device_platforms: ['mobile', 'desktop'],
}
return AdAccount(f'act_{ad_account}').create_ad_set(fields=fields,
params=params)
except Exception as e:
print(type(e))
def update_campaign(campaign_id, params):
"""
Update a campaign
:param campaign_id: a string or int representing the campaign id
:param params: a dict containing parameters and values to update
:return: the exit status of the process if operation is successful
-1 otherwise
"""
FacebookAdsApi.init(access_token=FacebookConstants.access_token)
cmd = "curl -X POST \\\n"
for k, v in params.items():
cmd += " -F '{}={}' \\\n".format(k, v)
cmd += " -F 'access_token={}' \\\n".format(
FacebookConstants.access_token)
cmd += " https://graph.facebook.com/v3.3/{}".format(campaign_id)
try:
# TODO: use subprocess module instead of os.system
res = os.system(cmd)
except Exception as e:
print(e)
return -1
return res
def delete_campaigns(delete_strategy, before_date=None, object_count=None):
"""
Delete campaigns according to params
NOTE: Not very useful for now; use `delete_campaign_by_id` instead
:param delete_strategy: a string representing delete strategy
:param before_date: a datetime, only delete campaigns before this date
:param object_count: a int representing the object count
:return: an object containing list of deleted ids and objects left to delete count if operation is successful
None otherwise
"""
FacebookAdsApi.init(access_token=FacebookConstants.access_token)
fields = []
params = {
'before_date': before_date,
'delete_strategy': delete_strategy,
'object_count': object_count
}
try:
res = AdAccount(FacebookConstants.account_id).delete_campaigns(
fields=fields, params=params)
except Exception as e:
print(e)
return None
return res
def update_ad_set_date(request):
if request.method == 'POST':
print('----------------------------------')
access_token=request.headers['token']
received_json_data = json.loads(request.body)
endDate = received_json_data['end_time']
startDate = received_json_data['start_time']
print('-----------' + endDate)
adsetId = request.GET.get('adsetId')
app_secret = 'db4b3037cd105cfd23b6032aecd2c3ff'
app_id = '263805807945856'
ADSET_ID = adsetId
FacebookAdsApi.init(access_token=access_token)
fields = ['start_time','end_time']
print('><><>>',fields)
params = {
'start_time':startDate,
'end_time':endDate,
}
updateadset= AdSet(ADSET_ID).api_update(
fields=fields,
params=params,
)
print(updateadset)
return Response(updateadset)
else:
return HttpResponse('not found')
def __init__(self):
self.accs_fields = ["name", "id", "timezone_id"]
self.camps_fields = [
"name",
"account_id",
"objective",
]
self.insights_fields = [
"impressions",
"reach",
"spend",
"cpm",
"clicks",
"cpc",
"ctr",
"actions",
"cost_per_action_type",
]
self.insights_params = dict(
time_increment=7,
time_range=dict(
since=self.year_n_week_start,
until=today,
),
)
self.access_token = json.load(open("../access/facebook.json", "r"))
FacebookAdsApi.init(access_token=self.access_token)
def ewah_execute(self, context):
time_range = {
"since": self.data_from.strftime("%Y-%m-%d"),
"until": self.data_until.strftime("%Y-%m-%d"),
}
FacebookAdsApi.init(**self.credentials)
params = {
"time_range": time_range,
"time_increment": self.time_increment,
"level": self.level,
"limit": self.pagination_limit,
}
if self.breakdowns:
params.update({"breakdowns": ",".join(self.breakdowns)})
for account_id in self.account_ids:
if self.execution_waittime_seconds:
self.log.info("Delaying execution by {0} seconds...".format(
str(self.execution_waittime_seconds), ))
now = datetime_utcnow_with_tz()
while datetime_utcnow_with_tz() < (now + timedelta(
seconds=self.execution_waittime_seconds)):
time.sleep(1)
account_object = AdAccount("act_{0}".format(str(account_id)))
self.log.info(
("Requesting data for account_id={0} between {1} and {2}."
).format(
str(account_id),
time_range["since"],
time_range["until"],
))
async_job = account_object.get_insights_async(
fields=self.insight_fields,
params=params,
)
job_remote_read = async_job.api_get()
done_status = [
"Job Completed",
"Job Failed",
"Job Skipped",
]
while not (job_remote_read.get("async_status") in done_status):
self.log.info(
"Asnyc job completion: {0}% (status: {1})".format(
str(job_remote_read.get("async_percent_completion")),
str(job_remote_read.get("async_status")),
))
time.sleep(self.async_job_read_frequency_seconds)
job_remote_read = async_job.api_get()
time.sleep(1)
assert job_remote_read.get("async_status") == "Job Completed"
data = self._clean_response_data(
async_job.get_result(params={"limit":
self.pagination_limit}, ))
self.upload_data(data)
def delete_ad(request, adid):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
ad = Ad(adid)
ad.remote_delete()
return redirect('view_ad')
def delete_campaign(request, camid):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
campaign = Campaign(camid)
campaign.remote_delete()
return redirect('view-campaign')
def video_upload(file_path):
FacebookAdsApi.init(access_token=my_access_token)
video = AdVideo(parent_id=f'act_{ad_account}')
video[AdVideo.Field.filepath] = file_path
video[AdVideo.Field.name] = 'my_new_vid'
video.remote_create()
video.waitUntilEncodingReady()
time.sleep(10)
return video['id']
def update_campaign(request, campid, status):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
campaign = Campaign(campid)
campaign[Campaign.Field.status] = status
campaign.remote_update()
return redirect('view-campaign')
def add_users_mk(ca_id, users):
FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
audience = CustomAudience(ca_id)
schema = [
CustomAudience.Schema.MultiKeySchema.email,
]
audience.add_users(schema, users, is_raw=True)
return audience.get_id()
def get_page_insight(request):
my_app_id = SocialApp.client_id
my_app_secret = '0e51c739872e518f388fbf1439b6d7e7'
my_access_token = 'EAAt6AfVaOUABAJZBOoHMic2IZAADP3QpJyRwev57FUJIvkSUtAo5ZATcmYLb7EgqOLZB0RAhHKYupyxnbmRlDzjRJDtSKKjCnR6KaVw0n3HnHM6FsKf4We9ynZBVjrBs9GfDdSm4y94bZCcJjLHv56npCfrHWn3WBRePPs6mD4WwZDZD'
FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
me = AdUser(fbid='me')
my_pages = me.get_pages(fields=[Page.Field.name, Page.Field.id])
my_ad_account = me.get_ad_accounts(
fields=[AdAccount.Field.name, AdAccount.Field.id])
pass
def _add_batch_to_custom_audience(app_id, app_secret, access_token, audience_id, schema,
batch, added_so_far, total_rows):
# Since this method runs in parallel, we need to re-initialize the Facebook API each time
# to avoid SSL-related errors. Basically, the FacebookAdsApi python framework isn't
# built to run in parallel.
FacebookAdsApi.init(app_id, app_secret, access_token)
# Note that the FB SDK handles basic normalization and hashing of the data
CustomAudience(audience_id).add_users(schema, batch, is_raw=True)
logger.info(f"Added {added_so_far+len(batch)}/{total_rows} users to custom audience...")
# shall be included in all copies or substantial portions of the software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
from facebook_business.adobjects.adaccount import AdAccount
from facebook_business.adobjects.campaign import Campaign
from facebook_business.api import FacebookAdsApi
access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<AD_ACCOUNT_ID>'
FacebookAdsApi.init(access_token=access_token)
fields = [
]
params = {
'name': 'Video Views campaign',
'objective': 'VIDEO_VIEWS',
'status': 'PAUSED',
}
print AdAccount(id).create_campaign(
fields=fields,
params=params,
)
repo_dir = os.path.join(this_dir, os.pardir)
sys.path.insert(1, repo_dir)
from facebook_business.objects import AdAccount, AsyncJob
from facebook_business.api import FacebookAdsApi
import time
import os
import json
this_dir = os.path.dirname(__file__)
config_filename = os.path.join(this_dir, 'config.json')
config_file = open(config_filename)
config = json.load(config_file)
config_file.close()
api = FacebookAdsApi.init(access_token=config['access_token'])
account_id = config['act_id']
account = AdAccount(account_id)
# Both Insights and Reportstats
i_async_job = account.get_insights(params={'level': 'ad'}, is_async=True)
# Insights
while True:
job = i_async_job.remote_read()
print("Percent done: " + str(job[AsyncJob.Field.async_percent_completion]))
time.sleep(1)
if job:
print("Done!")
break
this_dir = os.path.dirname(__file__)
config_filename = os.path.join(this_dir, os.pardir, os.pardir, 'config.json')
import sys
sys.path.insert(1, os.path.join(this_dir, os.pardir, os.pardir))
config_file = open(config_filename)
config = json.load(config_file)
config_file.close()
from facebook_business.api import FacebookAdsApi
from facebook_business.objects import ProductCatalog, Product
FacebookAdsApi.init(
config['app_id'],
config['app_secret'],
config['access_token'],
)
if __name__ == '__main__':
catalog_id = '<INSERT_YOUR_CATALOG_ID_HERE>'
catalog = ProductCatalog(catalog_id)
fields = [
Product.Field.id,
Product.Field.name,
Product.Field.price,
Product.Field.url,
Product.Field.availability
]
"""
get products cost more than $99.99.