def amazon_api(asin, url, marketplace = 'US', retries=0):
try:
if (retries < 2):
amazon = AmazonAPI(settings.AWS_KEY_1, settings.AWS_SECRET_1, settings.AWS_API_1, region=marketplace)
if (retries >= 2 and retries < 4):
amazon = AmazonAPI(settings.AWS_KEY_2, settings.AWS_SECRET_2, settings.AWS_API_2, region=marketplace)
if (retries >= 4 and retries < 6):
amazon = AmazonAPI(settings.AWS_KEY_3, settings.AWS_SECRET_3, settings.AWS_API_3, region=marketplace)
if (retries >= 6 and retries < 8):
amazon = AmazonAPI(settings.AWS_KEY_3, settings.AWS_SECRET_3, settings.AWS_API_4, region=marketplace)
if (retries >= 8 and retries < 10):
amazon = AmazonAPI(settings.AWS_KEY_3, settings.AWS_SECRET_3, settings.AWS_API_5, region=marketplace)
product = amazon.lookup(ItemId=asin)
model_product = ProductRecord(
title=product.title,
product_url='<missing product url>',
listing_url=url,
price=str(product.price_and_currency[1])+str(product.price_and_currency[0]),
primary_img=product.large_image_url,
product_indexing=None,
crawl_time=datetime.now(),
asin=asin.upper()
)
if (product.asin != asin):
return None
return model_product
except Exception as e:
if (retries <= 10):
return amazon_api(asin, url, marketplace, retries+1)
return None
def test_region(self):
amazon = AmazonAPI(AMAZON_ACCESS_KEY, AMAZON_SECRET_KEY,
AMAZON_ASSOC_TAG)
assert_equals(amazon.region, 'US')
# old 'region' parameter
amazon = AmazonAPI(AMAZON_ACCESS_KEY, AMAZON_SECRET_KEY, AMAZON_ASSOC_TAG, region='UK')
assert_equals(amazon.region, 'UK')
# kwargs method
amazon = AmazonAPI(AMAZON_ACCESS_KEY, AMAZON_SECRET_KEY, AMAZON_ASSOC_TAG, Region='UK')
assert_equals(amazon.region, 'UK')
def get_queryset(self): # pragma: no cover
# Not covering this as we have no good way to mock a request to
# the amazon api as they use request signatures. - Devon Bleibtrey
amazon = AmazonAPI(settings.AMAZON_PROMOTION_API_KEY,
settings.AMAZON_PROMOTION_API_SECRET_KEY,
settings.AMAZON_ASSOCIATE_TAG)
queryset = []
query_param = self.request.query_params.get("query", "")
if query_param:
try:
products = amazon.search_n(n=15,
Keywords=query_param,
SearchIndex="All")
except SearchException:
raise ValidationError("Sorry, we found no products "
"matching your query.")
for product in products:
price, currency = product.price_and_currency
has_reviews, iframe = product.reviews
queryset.append({
"title": product.title,
"image": product.large_image_url,
"price": price,
"currency": currency,
"asin": product.asin,
"url": product.offer_url,
"has_reviews": has_reviews,
"iframe": iframe
})
return queryset
def ProcessQueryAmazon(keys, query):
try:
amazon = AmazonAPI(keys[0][0], keys[0][1], keys[0][2])
products = amazon.search_n(100, Keywords=query, SearchIndex='All')
tempList = []
if products is not None:
for item in products:
tempDict = {}
tempDict[CStaticConsts.siteName] = CStaticConsts.Amazon
tempDict[CStaticConsts.title] = item.title
# Some of the amazon price/currency are null
# so just populate the field with NA
if not item.price_and_currency[1]:
tempDict[CStaticConsts.currencyType] = 'NA'
else:
tempDict[CStaticConsts.
currencyType] = item.price_and_currency[1]
if not item.price_and_currency[0]:
tempDict[CStaticConsts.itemPrice] = 'NA'
else:
tempDict[CStaticConsts.
itemPrice] = item.price_and_currency[0]
tempDict[CStaticConsts.productUrl] = item.offer_url
tempList.append(tempDict)
return tempList
except urllib.error.HTTPError as e:
print('Error getamazonlistings: ', e)
except Exception as e:
print('Error: getamazonlistings threw exception. Message: ', e)
def setUp(self):
self.amazon = AmazonAPI(AMAZON_ACCESS_KEY,
AMAZON_SECRET_KEY,
AMAZON_ASSOC_TAG,
CacheReader=cache_reader,
CacheWriter=cache_writer,
MaxQPS=0.5)
def __init__(self, product_name):
self.product_name = product_name
keys = pandas.read_csv('accessKeys.csv').iloc[0]
self.amazon = AmazonAPI(keys['access_key'],
keys['access_secret'],
837361066829,
region=REGION)
def update_product(product):
url = product.product_url
AMAZON_ACCESS_KEY = 'AKIAIZPHCO56EZACZHBA'
AMAZON_SECRET_KEY = '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'
AMAZON_ASSOC_TAG = '1015f-21'
region = url.split("amazon.")[1].split("/")[0]
if "/dp/" in url:
ASIN = url.split("/dp/")[1].strip("/").split("/")[0]
elif "/gp/" in url:
ASIN = url.split("/gp/product/")[1].strip("/").split("/")[0]
print(ASIN)
amazon = AmazonAPI(AMAZON_ACCESS_KEY,
AMAZON_SECRET_KEY,
AMAZON_ASSOC_TAG,
region=region.upper())
products = amazon.lookup(ItemId=ASIN)
price, currency = products.price_and_currency
graph = Graph(product_id=product,
updated_at=datetime.now(),
current_price=price)
graph.save()
return
def __enter__(self):
self.API = AmazonAPI(
self.account["ACCESS_KEY"],
self.account["SECRET_KEY"],
self.account["ASSOC_TAG"],
region = self.account["REGION"] if "REGION" in self.account else "US")
return self
def amazon_api_test(country, second=0):
if not second:
return AmazonAPI(amazon_id_1['asso_id'],
amazon_id_1['asso_key'],
amazon_id_1[country],
region=country.upper())
elif second == 1:
return AmazonAPI(amazon_id_2['asso_id'],
amazon_id_2['asso_key'],
amazon_id_2[country],
region=country.upper())
else:
return AmazonAPI(amazon_id_3['asso_id'],
amazon_id_3['asso_key'],
amazon_id_3[country],
region=country.upper())
def process_list():
file = open('azsearch/listtosearch.txt', 'r')
amazon = AmazonAPI(ACCESS_KEY, SECRET_KEY, ASSOC_ID)
for line in file:
print("Processing: " + line)
process_file(line, amazon)
time.sleep(60)
def setup(config):
"""Initializes this module from openlibrary config.
"""
global config_loanstatus_url, \
config_ia_access_secret, config_bookreader_host, \
config_ia_ol_shared_key, config_ia_ol_xauth_s3, \
config_internal_tests_api_key, config_ia_loan_api_url, \
config_http_request_timeout, config_amz_api, amazon_api, \
config_ia_availability_api_v1_url, config_ia_availability_api_v2_url, \
config_ia_ol_metadata_write_s3, config_ia_xauth_api_url, \
config_http_request_timeout, config_ia_s3_auth_url
config_loanstatus_url = config.get('loanstatus_url')
config_bookreader_host = config.get('bookreader_host', 'archive.org')
config_ia_loan_api_url = config.get('ia_loan_api_url')
config_ia_availability_api_v1_url = config.get(
'ia_availability_api_v1_url')
config_ia_availability_api_v2_url = config.get(
'ia_availability_api_v2_url')
config_ia_xauth_api_url = config.get('ia_xauth_api_url')
config_ia_access_secret = config.get('ia_access_secret')
config_ia_ol_shared_key = config.get('ia_ol_shared_key')
config_ia_ol_auth_key = config.get('ia_ol_auth_key')
config_ia_ol_xauth_s3 = config.get('ia_ol_xauth_s3')
config_ia_s3_auth_url = config.get('ia_s3_auth_url')
config_ia_ol_metadata_write_s3 = config.get('ia_ol_metadata_write_s3')
config_internal_tests_api_key = config.get('internal_tests_api_key')
config_http_request_timeout = config.get('http_request_timeout')
config_amz_api = config.get('amazon_api')
try:
amazon_api = AmazonAPI(config_amz_api.key, config_amz_api.secret,
config_amz_api.id)
except AttributeError:
amazon_api = None
def test_amazon_api_defaults_to_US(self):
"""Test Amazon API defaults to the US store."""
amazon = AmazonAPI(
_AMAZON_ACCESS_KEY,
_AMAZON_SECRET_KEY,
_AMAZON_ASSOC_TAG
)
assert_equals(amazon.api.Region, "US")
def __init__(self, aws_access_key, aws_secret_key, associate_tag, region):
self.aws_access_key = aws_access_key
self.aws_secret_key = aws_secret_key
self.associate_tag = associate_tag
self.amazon = AmazonAPI(self.aws_access_key,
self.aws_secret_key,
self.associate_tag,
region=region)
def __init__(self, search_word):
self.search_word = search_word
self.AMAZON_ACCESS_KEY = "AKIAJBVSXYPBD6LUXTSQ"
self.AMAZON_SECRET_KEY = "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"
self.AMAZON_ASSOC_TAG = "wawwawwaw1204-20"
self.amazon = AmazonAPI(self.AMAZON_ACCESS_KEY, self.AMAZON_SECRET_KEY,
self.AMAZON_ASSOC_TAG)
self.AsinList = []
self.extracted_data = []
def crawl_movie(id):
amazon = AmazonAPI("AKIAILGCGSOAJBIYFIQA",
"xz53Hn0stSpZ2LpqRejomhnZflsqNt/Yhq58VOAK",
"ericpan2018-20")
movie = amazon.lookup(ItemId=id)
with open('/home/eric/Data/poster/' + id + '.jpg', 'wb') as f:
f.write(requests.get(movie.large_image_url).content)
print(movie.title)
return movie.title
def __init__(self):
super(AmazonApi, self).__init__()
self.responsegroup = "Images,ItemAttributes,Offers"
self.amazon = AmazonAPI(AMAZON_ACCESS_KEY,
AMAZON_SECRET_KEY,
AMAZON_ASSOC_TAG,
region="CN",
ErrorHandler=self.error_handler)
self.sql = """
def app_results(query):
amazon = AmazonAPI(AWS_KEY, SECRET_KEY, ASSOC_TAG)
products = amazon.search(Keywords=query, SearchIndex='All')
if referrer == 'dashboard':
return render_template("amazon_bottlenose2.html", products=products)
else:
form = AddProductForm()
return render_template("amazon_bottlenose_add.html",
products=products,
form=form)
def amazon_api(country):
if country in ['us', 'fr', 'it', 'jp']:
number = int(time.time() * 10) % 3
amazon_id = (amazon_id_1, amazon_id_2, amazon_id_3)[number]
return AmazonAPI(amazon_id['asso_id'],
amazon_id['asso_key'],
amazon_id[country],
region=country.upper())
elif country in ['ca', 'es']:
number = int(time.time() * 10) % 2
amazon_id = (amazon_id_2, amazon_id_3)[number]
return AmazonAPI(amazon_id['asso_id'],
amazon_id['asso_key'],
amazon_id[country],
region=country.upper())
else:
return AmazonAPI(amazon_id_1['asso_id'],
amazon_id_1['asso_key'],
amazon_id_1[country],
region=country.upper())
def obtain_products(name, num):
AMAZON_ACCESS_KEY = 'AKIAIGKWJJGRKVVHTNFA'
AMAZON_SECRET_KEY = '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'
AMAZON_ASSOC_TAG = '5566399-20'
amazon = AmazonAPI(AMAZON_ACCESS_KEY, AMAZON_SECRET_KEY, AMAZON_ASSOC_TAG)
# get the images from top 10 from this categor
products = amazon.search_n(num, Keywords=name, SearchIndex='All')
return products
def retrieve_amazon_data(id='00000000000', type=TYPE):
amazon = AmazonAPI(AMAZON_ACCESS_KEY, AMAZON_SECRET_KEY, AMAZON_ASSOC_TAG)
try:
product = amazon.lookup(ItemId=id, IdType=type, SearchIndex='Books')
except:
return None
try:
return product.isbn
except AttributeError: # So probably not a book then?
return None
def get_products(keyword):
amazon = AmazonAPI(config['access_key'], config['secret_key'],
config['associate_tag'])
products = amazon.search(Keywords=keyword, SearchIndex='Books')
html_list = []
for book in products: # probably limits itself to 50 books
html = '''<div class='product-box'><a target="_blank" href="{}"><img src="{}" width="120" height="160" alt="No Img Available"></a><div class="product-title"><h3>{}</h3><p class="product-price">{} {}<br></p></div></div>'''.format(
book.detail_page_url, book.large_image_url, book.title,
book.price_and_currency[1], book.price_and_currency[0])
html_list.append(html)
return ''.join(html_list[:10])
def lookup_item_by_keyword(self):
"""
Returns all results of items given by amazon's search for the supplied keyword
:param keyword: the keyword to search by
:return:
"""
amazon = AmazonAPI(secrets.AMAZON_ACCESS_KEY,
secrets.AMAZON_SECRET_KEY, secrets.AMAZON_ASSOC_TAG)
products = amazon.search(
Keywords=self.keyword, SearchIndex='Apparel', MaxQPS=0.9
) # might have to remove Sort='salesrank' sort since it grabs tons of different products
return products
def amazon_strips():
amazon = AmazonAPI('AKIAJLW4JVOUA6L62PKQ', 'z0+px3hgEbAR5zqTjSJL70k+JyiS87ps4qEbgA7g', 'insulinfirst-20')
prod = amazon.search(Keywords='diabetes blood test strips', SearchIndex='All')
rows_logged = 0
for i in prod:
product = Product()
# product manufacturer
prod_manufacturerer = i.publisher
product.product_manufacturer = prod_manufacturerer
# description of product / Product Name
prod_name = i.title
product.product_name = prod_name
# Price of Product
prod_price = i.price_and_currency[0]
product.product_price = prod_price
# Image of product
image = i.medium_image_url
product.product_image = image
# offer url
url = i.offer_url
product.product_url = url
website = 'Amazon'
product.product_dealer = website
prod_type = 'Test Strips'
product.product_type = prod_type
prod_description = ''
product.product_description = prod_description
try:
quantity = re.findall(r"[-+]?\d*\.\d+|\d+", prod_name)[-1]
pps = format(float(prod_price) / float(quantity), '.2f')
if float(pps) > 2:
pps = 1000
product.product_price_per_strip = pps
except IndexError:
pass
rows_logged += 1
db.session.add(product)
db.session.commit()
print("logged {} rows".format(rows_logged))
def __init__(self):
try:
self.connection = AmazonAPI(
settings.AMAZON_ACCESS_KEY, settings.AMAZON_SECRET_KEY,
settings.AMAZON_ASSOCIATE_TAG
)
logger.info(u'Established Amazon API connection')
except:
self.connection = None
logger.error(traceback.format_exc())
logger.error(u'Failed to establish Amazon API connection')
self.total_count = 0
def __init__(self, amazon_config, bot_db_configs, app_db_configs):
self.logger = logging.getLogger('gearstack_rbt.{0}'.format(
GearTypeRetriever.__name__))
self.amazon_config = amazon_config
self.geartype_retrieved_dao = GearTypeRetrievedDAO(
bot_db_configs=bot_db_configs)
self.geartype_dao = GearTypeDAO(app_db_configs=app_db_configs)
self.amazon = AmazonAPI(
aws_key=amazon_config['api_access_key'],
aws_secret=amazon_config['api_secret_key'],
aws_associate_tag=amazon_config['associate_tag'])
self.cats_to_ignore = config_utils.fetch_data_config('ignore_cats')
def __init__(self, credentials_filename):
creds = []
with open(credentials_filename, 'rb') as fi:
reader = csv.reader(fi)
for row in reader:
creds.append(row)
self.tasks = Queue.Queue(len(creds))
for cred in creds:
amazon = AmazonAPI(cred[0],
cred[1],
self.affiliate_id,
MaxQPS=0.95)
AmazonWorker(self.tasks, amazon)
def amazon_product(asin, keyword, marketplace='US'):
try:
amazon = AmazonAPI(settings.AWS_KEY,
settings.AWS_SECRET,
settings.AWS_API,
region=marketplace)
search_item = asin + ' ' + keyword
products = amazon.search_n(1, Keywords=search_item, SearchIndex='All')
if len(products) != 0:
return True
return False
except:
return False
def setUp(self):
"""Set Up.
Initialize the Amazon API wrapper. The following values:
* AMAZON_ACCESS_KEY
* AMAZON_SECRET_KEY
* AMAZON_ASSOC_TAG
Are imported from a custom file named: 'test_settings.py'
"""
self.amazon = AmazonAPI(AMAZON_ACCESS_KEY, AMAZON_SECRET_KEY,
AMAZON_ASSOC_TAG)
def run(self):
if self.repeat:
self._schedule_next_run()
self.amazon = AmazonAPI(app.config['AMAZON_ACCESS_KEY'],
app.config['AMAZON_SECRET_KEY'],
app.config['AMAZON_ASSOC_TAG'],
region='US')
for book in Book.query.all():
try:
self._sync_book_with_amazon(book)
except:
pass
def amazon_api_request():
item_id = request.json.get('item_id')
brand = request.json.get('brand')
model = request.json.get('model')
item = Item.query.filter_by(id=item_id).first()
amazon = AmazonAPI(AMAZON_ACCESS_KEY, AMAZON_SECRET_KEY, AMAZON_ASSOC_TAG)
browse_modes = [
"679270011", "679350011", "679307011", "679380011", "679380011",
"679280011", "679357011"
]
if item:
# loop through browseNodes
for node in browse_modes:
try:
products = amazon.search_n(
1,
Brand=brand,
Title=model,
SearchIndex='SportingGoods',
ResponseGroup='VariationSummary, Large',
BrowseNode=node)
product_info = {
'title': products[0].title,
'small_image_url': products[0].small_image_url,
'medium_image_url': products[0].medium_image_url,
'asin': products[0].asin,
}
item.small_image_url = products[0].small_image_url
item.medium_image_url = products[0].medium_image_url
item.offer_url = products[0].offer_url
if item.asin and products[0].asin not in item.asin:
item.asin = item.asin + ',' + products[0].asin
else:
item.asin = products[0].asin
item.thumbnail_cache = datetime.utcnow()
db.session.commit()
return json.dumps(product_info)
except:
pass
else:
# error
error = {'error': 'amazon api exception'}
return json.dumps(error)
