def apiCall(keyword, pages, category):
# For the range
pages = pages + 1
# Initialize the two lists used to store the data
prices = []
times = []
result = []
# I acknowledge that this is incredibly slow to get data but ebay will only allow 100 items to be returned per page so I have to call multiple pages
for x in range(1, pages):
try:
api = Finding(appid=str(os.environ['api_key']), config_file=None)
response = api.execute(
'findCompletedItems', {
'keywords': keyword,
'categoryId': category,
'paginationInput': {
'pageNumber': x
}
})
result = response.dict()['searchResult']['item']
except ConnectionError as e:
print(e)
print(e.response.dict())
for x in result:
# Add to relevant fields to their respective lists
prices.append(float(x['sellingStatus']['currentPrice']['value']))
# Convert the string to datetime object
times.append(
datetime.strptime(x['listingInfo']['endTime'],
"%Y-%m-%dT%H:%M:%S.%fZ"))
return prices, times
def search_ebay():
searchword = request.args.get('q', '')
for i in colours:
searchword = searchword.replace(i, '')
try:
api = Connection(appid=EBAY_APPID, config_file=None)
response = api.execute('findItemsAdvanced', {'keywords': searchword})
# print int(response.dict()['searchResult']['_count']) == 0
if int(response.dict()['searchResult']['_count']) == 0:
return jsonify({"error": "No results found"})
item = response.reply.searchResult.item[0]
# print dir(item)
pro = "\n\n\n---------------------------------\n"
pro += "Ebay item name:" + item.title + "\n"
pro += "Price: " + item.sellingStatus.currentPrice.value + item.sellingStatus.currentPrice._currencyId
pro += "\n---------------------------------\n"
write_to_file(pro)
print pro
return jsonify({
"name":
item.title,
"price":
item.sellingStatus.currentPrice.value + ' ' +
item.sellingStatus.currentPrice._currencyId
})
except ConnectionError as e:
print e
return jsonify(e.response.dict())
def run():
user_UPC = get_UPC()
while True:
try:
'''
input_dictionary contains all the parameters that will be passed to the execute method
of the Finding class to search ebay via UPC.
productID defines the search for UPCs.
paginationInput defines the search response size.
ListingType restricts the search to listing types that are associated with 'buy it now' options.
LocatedIn restricts the search the the US.
sortOrder is set to return the the listings in order from cheapest to more expensive.
'''
input_dictionary = {
'productId': {
'#text': user_UPC,
'@attrs': {
'type': 'UPC'
}
},
'paginationInput': {
'entriesPerPage': 100,
'pageNumber': 1
},
'itemFilter': [{
'name': 'ListingType',
'value': ['FixedPrice', 'StoreInventory', 'AuctionWithBIN']
},
{
'name': 'LocatedIn',
'value': 'US'
}
],
'sortOrder': 'PricePlusShippingLowest'
}
api = Finding(appid=config.api_key, config_file=None)
response = api.execute('findItemsByProduct', input_dictionary)
response_dictionary = response.dict()
response_search = SearchResponse(response_dictionary)
subject = 'Your daily search results for: {}.'.format(user_UPC)
try:
msg = response_search.prettify_listings_list()
except KeyError:
print('Sorry no results were found for that UPC, please try a different one.')
continue
send_email(subject=subject, msg=msg)
print('Sleeping for 24 hours. Press \'ctrl + c\' at anytime to exit.')
'''KeyboardInterrupt exception facilitates the ability to exit the program at anytime when the program is
run from the terminal.'''
try:
sleep(int(config.wait_time_in_seconds))
except KeyboardInterrupt:
exit()
except ConnectionError as e:
print(e)
print(e.response.dict())
print('Something went wrong, please try again later.')
exit()
def ProcessQueryEbay(apikey, query):
try:
tempList = []
api = Connection(appid=apikey, config_file=None)
response = api.execute('findItemsAdvanced', {'keywords': query})
if hasattr(response.reply.searchResult, 'item'):
for item in response.reply.searchResult.item:
tempDict = {}
tempDict[CStaticConsts.siteName] = CStaticConsts.Ebay
tempDict[CStaticConsts.title] = item.title
tempDict[
CStaticConsts.
currencyType] = item.sellingStatus.currentPrice._currencyId
tempDict[CStaticConsts.
itemPrice] = item.sellingStatus.currentPrice.value
tempDict[CStaticConsts.productUrl] = item.viewItemURL
tempList.append(tempDict)
return tempList
except ConnectionError as e:
print(e)
print(e.response.dict())
except Exception as e:
print('Error: getebaylistings threw exception. Message: ', e)
def apiCall(keywords, min, max, listing):
api = Connection(config_file=r'ebay.yaml', debug=True, siteid="EBAY-US")
request = {
'keywords':
keywords,
'itemFilter': [{
'name': 'MinPrice',
'value': min
}, {
'name': 'MaxPrice',
'value': max
}, {
'name': 'ListingType',
'value': listing
}],
'paginationInput': {
'entriesPerPage': 10,
'pageNumber': 1
},
'sortOrder':
'PricePlusShippingLowest'
}
return api.execute('findItemsByKeywords', request)
def __init__(self, config):
self._config = config
self._client = Connection(domain=self._config['domain'], debug=False,
appid=self._config['appid'],
config_file=None,
siteid=self._config['siteid'])
self._logger = logging.getLogger(__name__)
def get_items(appid, search_keyword, categoryId):
results = []
try:
api = Connection(appid=appid, config_file=None)
response = api.execute('findItemsAdvanced', {
'keywords': search_keyword
}).json()
item_dict = json.loads(response)
items = item_dict['searchResult']['item']
for item in items:
c_id = item['primaryCategory']['categoryId']
if c_id != categoryId:
continue
autoPay = bool_to_bit(item['autoPay'])
currentPrice = float(
item['sellingStatus']['currentPrice']['value'])
condition = float(item['condition']['conditionId'])
results.append({
'input': (autoPay, condition),
'price': currentPrice
})
except ConnectionError as e:
print(e)
print(e.response.dict())
return results
def get_ebay_postings(city):
api = Finding(config_file='ebay.yaml')
n_pages = 20
posting_ids = []
for n_page in range(n_pages):
api_request = {
'itemFilter': [{
'name': 'HideDuplicateItems',
'value': True
}],
'paginationInput': {
'entriesPer': 100,
'pageNumber': n_page + 1
},
'sortOrder': 'StartTimeNewest',
'categoryId': '177831',
'Country': 'US',
'ListingStatus': 'Active'
}
response = api.execute('findItemsAdvanced', api_request)
items = response.reply.searchResult.item
for item in items:
posting_ids.append(item.itemId)
return posting_ids
def category(id):
from ebaysdk.finding import Connection as Finding
from ebaysdk.exception import ConnectionError
api = Finding(
domain = 'svcs.ebay.com',
appid=app_id,
config_file=None,
siteid="EBAY-US"
)
callData = {
"categoryId": id,
"outputSelector": ["GalleryInfo","PictureURLLarge"]
}
response = api.execute('findItemsByCategory', callData)
print(response)
data = "<html><head><script>window._epn = {campaign:5338177835};</script><script src=\"https://epnt.ebay.com/static/epn-smart-tools.js\"></script></head><body><ul>"
for i in response.dict()["searchResult"]["item"]:
#{'itemId': '231505660468', 'title': 'Police Magnum mace pepper spray 1/2oz hot pink actuator self defense protection', 'globalId': 'EBAY-US', 'primaryCategory': {'categoryId': '79849', 'categoryName': 'Pepper Spray'}, 'galleryURL': 'http://thumbs1.ebaystatic.com/m/mYIVyE88preQeEP4Zxe1kNw/140.jpg', 'galleryInfoContainer': {'galleryURL': [{'_gallerySize': 'Large', 'value': 'http://thumbs1.ebaystatic.com/m/mYIVyE88preQeEP4Zxe1kNw/140.jpg'}, {'_gallerySize': 'Medium', 'value': 'http://thumbs1.ebaystatic.com/m/mYIVyE88preQeEP4Zxe1kNw/96.jpg'}, {'_gallerySize': 'Small', 'value': 'http://thumbs1.ebaystatic.com/m/mYIVyE88preQeEP4Zxe1kNw/80.jpg'}]}, 'viewItemURL': 'http://www.ebay.com/itm/Police-Magnum-mace-pepper-spray-1-2oz-hot-pink-actuator-self-defense-protection-/231505660468', 'paymentMethod': 'PayPal', 'autoPay': 'false', 'postalCode': '32829', 'location': 'Orlando,FL,USA', 'country': 'US', 'shippingInfo': {'shippingServiceCost': {'_currencyId': 'USD', 'value': '0.0'}, 'shippingType': 'Free', 'shipToLocations': 'Worldwide', 'expeditedShipping': 'false', 'oneDayShippingAvailable': 'false', 'handlingTime': '1'}, 'sellingStatus': {'currentPrice': {'_currencyId': 'USD', 'value': '4.99'}, 'convertedCurrentPrice': {'_currencyId': 'USD', 'value': '4.99'}, 'sellingState': 'Active', 'timeLeft': 'P25DT10H17M37S'}, 'listingInfo': {'bestOfferEnabled': 'false', 'buyItNowAvailable': 'false', 'startTime': '2015-03-15T00:21:19.000Z', 'endTime': '2017-09-30T00:21:19.000Z', 'listingType': 'StoreInventory', 'gift': 'false', 'watchCount': '118'}, 'returnsAccepted': 'true', 'condition': {'conditionId': '1000', 'conditionDisplayName': 'New'}, 'isMultiVariationListing': 'false', 'pictureURLLarge': 'http://i.ebayimg.com/00/s/MTUxMlgxMDc5/z/DpsAAOSwU-pXs2n1/$_1.JPG', 'topRatedListing': 'true'}
print(i)
if "pictureURLLarge" in i:
data+='<li><a href="'+i["viewItemURL"]+'">'+i['title']+'<img src="'+i["pictureURLLarge"]+'" /></a></ul>'
data += "</ul></body></html>"
return Response(body=data, status_code=404, headers={'Content-Type':'text/html'})
def searchEbay(searchTerms, page_num=1):
ebay_pricelist = pd.DataFrame()
try:
api = Finding(config_file='ebay.yaml', debug=False, siteid="EBAY-US")
request = {
'keywords': searchTerms,
'itemFilter': {
'name': 'condition',
'value': 'used'
},
'paginationInput': {
'entriesPerPage': ITEMS_PER_PAGE, # max = 100
'pageNumber': page_num
},
}
response = api.execute('findItemsByKeywords', request)
if int(response.dict()['searchResult']["_count"]) != 0:
for item in response.dict()['searchResult']['item']:
price = item['sellingStatus']['convertedCurrentPrice']['value']
name = item['title']
info_to_keep = {'price': price, 'name': name}
ebay_pricelist = ebay_pricelist.append(info_to_keep,
ignore_index=True)
ebay_pricelist['price'] = ebay_pricelist['price'].astype(float)
except ConnectionError as e:
print(e)
print(e.response.dict())
return ebay_pricelist
def runQuery(page):
try:
api = Connection(appid=ebayAppID, config_file=None)
response = api.execute(
'findItemsAdvanced', {
'keywords':
'pokemon online code',
'itemFilter': [{
'name': 'ListingType',
'value': ['FixedPrice', 'AuctionWithBIN']
}, {
'name': 'FreeShippingOnly',
'value': 'true'
}, {
'name': 'MinPrice',
'value': '5',
'paramName': 'Currency',
'paramValue': 'USD'
}, {
'name': 'MaxPrice',
'value': '50',
'paramName': 'Currency',
'paramValue': 'USD'
}],
'paginationInput': {
'entriesPerPage': 50,
'pageNumber': page
},
'sortOrder':
'StartTimeNewest'
})
except ConnectionError as e:
print(e)
print(e.response.dict())
return response.dict()
def findOne(d, fh):
try:
api = Finding(appid="EdisonLi-syrup-PRD-c8e35c535-b071148d",
config_file=None)
response = api.execute(
'findItemsAdvanced', {
'keywords': d['keywords'],
'itemFilter': d['itemFilter'],
'paginationInput': {
'entriesPerPage': '25',
'pageNumber': '1'
},
'sortOrder': 'PricePlusShippingLowest'
})
fh.write('<h3> Keywords: ' + d['keywords'] + '</h3>\n')
fh.write('<table border="1">\n')
for item in response.reply.searchResult.item:
fh.write(
"<tr><th>%s</th><th>%s %s</th><th>%s</th><th><a href=%s>click</a></th>\n"
% (item.itemId, item.sellingStatus.currentPrice.value,
item.sellingStatus.currentPrice._currencyId, item.title,
item.viewItemURL))
fh.write('</table>\n')
except ConnectionError as e:
print(e)
print(e.response.dict())
def ebay_api(search):
try:
api = Connection(appid='nyetmoi-zooccs-PRD-ef8fc7c73-6322fe73', config_file=None)
response = api.execute('findItemsAdvanced', {'keywords': search})
items = response.reply.searchResult.item
avg = 0
cost = 0
urls = []
flagged =[]
for i in range(len(items)):
cost += float(items[i].sellingStatus.currentPrice.value)
urls.append(items[i].viewItemURL)
avg = float(cost)/len(items)
print len(items)
signed_variances = []
for i in range(len(items)):
signed_variances.append(float(items[i].sellingStatus.currentPrice.value)-avg)
#signed_variances.sort()
second_avg = sum(signed_variances)/len(items)
signed_second_variances = []
for i in range(len(items)):
signed_second_variances.append(((signed_variances[i]-second_avg)/avg))
if (signed_second_variances[-1]>7.5):
flagged.append(items[i])
signed_second_variances.sort()
print len(flagged)
#print signed_second_variances
return flagged
except ConnectionError as e:
print e
print e.response.dict()
def commence_search(card_list, setname, grade):
for card_name in card_list:
try:
api = Connection(appid='vincentc-pokemon-PRD-5f95f0a8e-eb74953b',
config_file=None)
response = api.execute('findItemsByKeywords',
{'keywords': 'mew ex play promo'})
assert (response.reply.ack == 'Success')
assert (type(response.reply.timestamp) == datetime.datetime)
assert (type(response.reply.searchResult.item) == list)
item = response.reply.searchResult.item
search_results = response.dict()
item = response.reply.searchResult.item[0]
assert (type(item.listingInfo.endTime) == datetime.datetime)
assert (type(response.dict()) == dict)
#print (len(k['searchResult']['item']))
print(search_results['searchResult']['item'][0]['itemId'])
except ConnectionError as e:
print(e)
print(e.response.dict())
pass
def get_json_data(self, keyword, price_from, price_to):
"""
Method returns a dictionary with data collected
keyword: str - the name of the product user wants to find
price_from: str - start of the price range
price_to: str - end of the price range
return: dict
"""
try:
api = Finding(config_file='ebay.json',
appid='Volodymy-Expendit-PRD-3196809ca-9c1b019a')
# allows to set the price range
itemFilter = [{
"name": "MaxPrice",
"value": str(price_to),
"paramName": "Currency",
"paramValue": "USD"
}, {
"name": "MinPrice",
"value": str(price_from),
"paramName": "Currency",
"paramValue": "USD"
}]
request = {'keywords': keyword, 'itemFilter': itemFilter}
response = api.execute('findItemsAdvanced', request)
return response.dict()['searchResult']['item']
except KeyError:
return None
def __init__(self, id_dict, config):
self.id_dict = id_dict
self.err_cnt = 0
self.tm_last_err = 0
self.dict_needs_update = 0
self.crnt_found_items = 0
self.crnt_srch_key = ''
self.crnt_srch_type = ''
self.stats = {}
self.delay = config['delay']
self.srch_conf_lst = config['srch']
self.ids_file = config['ids']
self.stats_file = config['stats']
self.err_file = config['errlog']
self.appid = config['rbt']['appid']
self.ya_host = config['rbt']['ya_host']
self.ya_port = config['rbt']['ya_port']
self.ya_usr = config['rbt']['ya_usr']
self.ya_pwd = config['rbt']['ya_pwd']
self.from_email = config['rbt']['from_email']
self.to_email = config['rbt']['to_email']
self.api = Connection(appid=self.appid, config_file=None)
def get_search_items(query, cat, limit=10, page=1):
key_name = "seaarch_" + "query_" + str(cat) + "_" + str(limit) + "_" + str(
page)
result = get_cache(key_name)
if result:
items = json.loads(result)
else:
start = time.time()
api = Finding(domain='svcs.ebay.com',
appid=config.app_id,
config_file=None,
siteid="EBAY-US")
callData = {
"categoryId": cat,
"outputSelector": ["GalleryInfo", "PictureURLLarge"],
"paginationInput": {
"entriesPerPage": limit,
"pageNumber": page
},
"keywords": urllib.request.unquote(query)
}
items = api.execute('findItemsAdvanced', callData).dict()
send_metric("search_items", time.time() - start)
set_cache(key_name, json.dumps(items))
return items
def fetch_product(self, identifier):
self.api = Connection(appid=self.appID, config_file=None)
args = {
'keywords': identifier
}
response = self.api.execute('findItemsAdvanced', args)
return response if response.reply.ack == "Success" else None
def FindingAPI(search_input, pageNumber):
try:
api = Finding(config_file='config/ebay.yaml')
api_dictionary = {
'keywords': search_input,
#'itemFilter' : [
#{'name': 'Condition', 'value': 'Used'},
#{'name': 'MinPrice', 'value': '200', 'paramName': 'Currency', 'paramValue': 'USD'},
#{'name': 'MaxPrice', 'value': '400', 'paramName': 'Currency', 'paramValue': 'USD'},
#],
'pageinationInput': {
'entriesPerPage': '100',
'pageNumber': pageNumber
},
'sortOrder': 'CurrentPriceHighest'
}
# Execute api HTTP request to ebay and provide dictionary parameters
response = api.execute('findCompletedItems', api_dictionary)
# Return diction of the HTTP response
response = response.dict()
return response
except ConnectionError as e:
print e
print e.response.dict()
def call_Ebay_API(page_num, search_keywords, try_count=1):
try:
api = Connection(appid='MattDass-FLCompar-PRD-12442a3e5-6825c4fa',
config_file=None)
response = api.execute(
'findItemsAdvanced', {
'keywords': search_keywords,
'paginationInput': {
'pageNumber': page_num
}
})
dictstr = api.response.dict()
df = pd.DataFrame(dictstr)
# for i in dictstr['searchResult']['item']:
# post_JSON_API(i)
pool = ThreadPool(10)
pool.map(post_JSON_API, dictstr['searchResult']['item'])
if page_num <= dictstr['paginationOutput']['totalPages']:
page_num = page_num + 1
else:
page_num = 0
return page_num
except Exception as e:
print e
if try_count <= 3:
time.sleep(10)
try_count += 1
call_Ebay_API(page_num, try_count)
else:
raise ValueError(
"No luck. Tried connecting 3 times and it still didn't work")
def find_it(search):
api = Connection(config_file='ebay.yaml', debug=DEBUG, siteid="EBAY-US")
response = api.execute('findItemsByKeywords', search)
if response.reply.paginationOutput.totalEntries != "0":
for item in response.reply.searchResult.item:
print("Title: %s, Price: %s" %
(item.title, item.sellingStatus.currentPrice.value))
def ebay_api_data(input_list, time_string, real=1):
if (real == 1):
f = open('./data/' + time_string[:-6] + 'ebay_gc', 'w+')
else:
f = open('./data/' + time_string[:-6] + 'all_ebay_gc', 'w+')
f.write("[")
res = dict()
size = len(input_list)
try:
api = Finding(appid="YuHUANG-insightd-PRD-04d8cb02c-4739185d")
for i in xrange(0, size):
cur_list = input_list[i]
# print cur_list[0]
if (cur_list[0] != 'soak-&-sleep'):
response = api.execute(
'findItemsAdvanced',
{'keywords': cur_list[0] + ' Gift Card'})
join_string = str(response.dict())
if (i != size - 1):
f.write(json.dumps(response.dict()))
f.write(",\n")
else:
f.write(json.dumps(response.dict()))
f.write("\n")
f.write("]")
f.close()
except ConnectionError as e:
print(e)
print(e.response.dict())
def find_items_on_ebay():
api = Connection(appid='Balasubr-hacktech-PRD-916e5579d-aa3f3d9b',
config_file=None)
n_items = int(f_request.args.get('n_items'))
response = api.execute(
'findItemsAdvanced', {
'keywords': f_request.args.get('item'),
'outputSelector': 'SellerInfo',
'itemFilter': [{
'name': 'TopRatedSellerOnly',
'value': 'true'
}]
})
#response = api.execute('GetCharities', {'Query': 'food'})
assert (response.reply.ack == 'Success')
assert (type(response.reply.timestamp) == datetime.datetime)
assert (type(response.reply.searchResult.item) == list)
item = response.reply.searchResult.item[0]
assert (type(item.listingInfo.endTime) == datetime.datetime)
assert (type(response.dict()) == dict)
result = response.dict()['searchResult']['item'][:10]
result = sorted(response.dict()['searchResult']['item'][:n_items],
key=lambda x: add_shipping_cost(x))
# print(result)
return jsonify(result)
def __init__(self, api_key, keyword):
self.api_key, self.keyword = api_key, keyword
# defin which site we wish to connect to and feed in our api-key
self.api = Connection(siteid='EBAY-US',
appid=self.api_key,
config_file=None)
# create a live db cursor
self.cursor = database_connection()
# establish lists for appending data to
self.active_product_ids = []
self.active_product_nick = []
self.active_product_titles = []
self.active_product_prices = []
self.active_product_cat_names = []
self.active_product_cat_ids = []
self.active_product_img_thumb = []
self.active_product_img_url = []
self.active_product_lst_type = []
self.active_product_con = []
self.active_product_loc = []
self.active_product_start = []
self.active_product_end = []
self.active_product_watch_count = []
self.active_product_depth = []
self.depthCountStorage = []
# outline our search body paramaters
self.search_body_pages = {
'keywords':
keyword,
'itemFilter': [
# US only sellers -- can also limit by feedback score, business type, top-rated status, charity, etc.
{
'name': 'MinPrice',
'value': '1',
'paramName': 'Currency',
'paramValue': 'USD'
},
{
'name': 'MaxPrice',
'value': '99999999',
'paramName': 'Currency',
'paramValue': 'USD'
},
# pre-filter to only actionable items (non-bids, etc.)
{
'name': 'ListingType',
'value':
['FixedPrice', 'StoreInventory', 'AuctionWithBIN']
},
],
'paginationInput': {
'entriesPerPage': '100',
# always 1, as we want to pull the maximum number of pages given a maximum of 100 results per page
'pageNumber': '1'
},
# can filter this to multiple different options as well (Best Offer, Most Watched, etc.)
'sortOrder':
'PricePlusShippingLowest'
}
def findItemsAdvanced(keywords):
api = Finding(appid=myAppId, config_file=None)
response = api.execute(
'findItemsAdvanced', {
'keywords': keywords,
'categoryId': category,
'sortOrder': 'PricePlusShippingLowest'
})
return response.dict()
def ebay_find(keyword):
from ebaysdk.finding import Connection as Finding
api = Finding(domain='svcs.sandbox.ebay.com',
appid="MethodDa-MethodDa-SBX-e2ccbdebc-b7307a8f",
config_file=None)
response = api.execute('findItemsAdvanced', {'keywords': keyword})
ebay_dict = response.dict()
return ebay_dict
def commence_search(query):
try:
search_term = query
api = Connection(appid=APP_ID, config_file=None)
response = api.execute('findItemsByKeywords',
{'keywords': search_term})
assert (response.reply.ack == 'Success')
assert (type(response.reply.timestamp) == datetime.datetime)
assert (type(response.reply.searchResult.item) == list)
item = response.reply.searchResult.item
search_results = response.dict()
item = response.reply.searchResult.item[0]
assert (type(item.listingInfo.endTime) == datetime.datetime)
assert (type(response.dict()) == dict)
#print (len(k['searchResult']['item']))
#print (search_results['searchResult']['item'][0]['itemId'])
#print (search_results['searchResult']['item'][1]['itemId'])
item_list = [0] * len(search_results['searchResult']['item'])
index = 0
for listing in search_results['searchResult']['item']:
listing = {
'id':
listing['itemId'],
'title':
listing['title'],
'currency':
listing['sellingStatus']['convertedCurrentPrice']
['_currencyId'],
'price':
listing['sellingStatus']['convertedCurrentPrice']['value'],
'start':
listing['listingInfo']['startTime'],
'end':
listing['listingInfo']['endTime'],
'offerEnabled':
listing['listingInfo']['bestOfferEnabled'],
'buyItNowAvailable':
listing['listingInfo']['buyItNowAvailable'],
'state':
listing['sellingStatus']['sellingState']
}
item_list[index] = listing
index += 1
return item_list
except ConnectionError as e:
print(e)
print(e.response.dict())
def find_cards():
"""
List a large number of professionally-graded cards from Ebay.
Parameters:
-------
None
Returns:
--------
None
Populates the data/page_jsons directory with 100 pages (10,000 total cards)
for each of the 10 PSA grades. Each page is represented as a pickled JSON object,
example psa_grade_1_page_1.pkl.
These pages should then be used to acquire the images associated with each card, as well
as to provide a unique identifier for each image and a label.
Labels are acquired by searching for key terms, e.g. "PSA 9" returns cards graded 9/10 by experts
"""
# Connect to Ebay API. TODO: add your own API keys.
client_id = "" # TODO add your own API key.
dev_id = "" # TODO add your own API key.
client_secret = "" # TODO add your own API key
api = Connection(appid=client_id, config_file=None)
# Downlaod Pages of Ebay API data for each grade.
grades = range(1, 11) # By default, get data for grades 1, 2, .... 10.
for grade in grades:
for page_num in range(1, 100):
# get data.
# note: by default we search for baseball cards only, but this can be expanded,
# try e.g. "basketball cards", etc.
# note that some items do not have large enough images available ("PictureURLLarge") and are ignored.
params = {
"categoryName": "Baseball Cards",
"keywords" : "psa {}".format(grade),
"paginationInput" :
{
"entriesPerPage" : 100, # max 100.
"pageNumber" : page_num
},
"outputSelector" : "PictureURLLarge" # important: if not selected, returned images are too small.
}
response = api.execute("findItemsAdvanced", params)
j = response.json()
# save
of_p = "psa_grade_{}_page_{}.pkl".format(grade, page_num)
of_p = os.path.join("page_jsons", of_p)
print(of_p)
with open(of_p, "wb") as of:
pickle.dump(j, of)
def main(argv):
try:
api = Finding(appid="SpencerH-sand-PRD-245ed6035-eb73f8e2",
config_file=None)
keywords = argv[0]
response = api.execute('findItemsAdvanced', {'keywords': keywords})
data = response.dict()
data = data['searchResult']['item']
maximum = 0
minimum = sys.maxsize
price_lst = []
output = []
for product in data:
a = dict()
a['title'] = product['title']
a['galleryURL'] = product['galleryURL']
a['currencyId'] = product['sellingStatus']['currentPrice'][
'_currencyId']
price = float(product['sellingStatus']['currentPrice']['value'])
a['value'] = price
price_lst.append(price)
if price < minimum:
minimum = price
if price > maximum:
maximum = price
output.append(a)
avg = numpy.mean(price_lst)
median = numpy.median(price_lst)
meanSmallestDiff = sys.maxsize
medianSmallestDiff = sys.maxsize
for i in range(0, len(price_lst)):
curPrice = float(output[i]['value'])
if curPrice == maximum:
maxIndex = i
if curPrice == minimum:
minIndex = i
if numpy.abs(curPrice - avg) < meanSmallestDiff:
meanSmallestDiff = numpy.abs(curPrice - avg)
meanIndex = i
if numpy.abs(curPrice - median) < medianSmallestDiff:
medianSmallestDiff = numpy.abs(curPrice - median)
medIndex = i
final = dict()
final['maximum'] = output[maxIndex]
final['minimum'] = output[minIndex]
final['median'] = output[medIndex]
final['mean'] = output[meanIndex]
with open('result.json', 'w') as fp:
json.dump(final, fp)
except ConnectionError as e:
print(e)
print(e.response.dict())
def collect_api_data(cur):
"""
query the API and store results
"""
# load gmail config
with open('/home/curtis/etc/gmail') as f:
gmail = json.load(f)
# set starting values for counters
page_num = 1
cnt = 0
while True:
try:
api = Finding(domain='svcs.ebay.com', config_file='/home/curtis/etc/ebay.yaml')
r = api.execute('findCompletedItems', {'categoryId': '6161', 'paginationInput': {'pageNumber': page_num}})
response = r.dict()
if response['ack'] == "Success" and 'item' in response['searchResult'].keys():
logger.info("Retreived page: {}".format(page_num))
for ad in response['searchResult']['item']:
try:
cur.execute("INSERT INTO ebay_api_raw (itemid, ad) VALUES (%s, %s)", [int(ad['itemId']), json.dumps(ad)])
cnt += 1
except Exception as e:
break
else:
logger.info("Issue at page: {} ".format(page_num))
logger.info("Issue: {}".format(response))
break
except ConnectionError as e:
logger.info("Connection error: {}".format(e.response))
break
page_num += 1
# print number of new records inserted into DB
logger.info("Number of new records inserted: {}".format(cnt))
# send email
user = gmail['gmail_user']
pwd = gmail['gmail_pwd']
recipient = '*****@*****.**'
subject = '{} new records from the eBay API'.format(cnt)
body = ''
send_email(user, pwd, recipient, subject, body)
