def main():
usage = "Usage: %prog [options]"
version = "%prog " + __version__
parser = OptionParser(usage=usage, version=version)
parser.add_option('--latlng', action='store', dest='latlng', default=None)
parser.add_option('--address', action='store', dest='address', default=None)
parser.add_option('-t', '--log_timing', action='store_true', dest='log_timing', default=False)
parser.add_option('-r', '--log_raw_source_results', action='store_true', dest='log_raw_source_results', default=False)
parser.add_option('-s', '--log_source_results', action='store_true', dest='log_source_results', default=False)
parser.add_option('-c', '--log_clusters', action='store_true', dest='log_clusters', default=False)
parser.add_option('-v', '--log_all', action='store_true', dest='log_all', default=False)
parser.add_option('--notimeout', action='store_true', dest='no_timeout', default=False)
(options, args) = parser.parse_args()
global shouldLogRawSourceResults
shouldLogRawSourceResults = options.log_all or options.log_raw_source_results
global shouldLogSourceResults
shouldLogSourceResults = options.log_all or options.log_source_results
global shouldLogTiming
shouldLogTiming = options.log_all or options.log_timing
global shouldLogClusters
shouldLogClusters = options.log_all or options.log_clusters
global shouldDisableTimeout
# With verbose logging we disable the timeout because it takes so long it causes us to miss sources.
shouldDisableTimeout = options.log_all or options.no_timeout
queryParams = {}
if options.latlng:
lat, lng = options.latlng.split(',')
queryParams['coords'] = float(lat), float(lng)
elif options.address:
queryParams['coords'] = Geocoder().addressToLatLng(options.address)
if len(args) < 2 or args[0] not in Constants.categories:
categories = '[ %s ]' % (', '.join(Constants.categories))
print '\nUSAGE:\n\nEntitySearch.py <category> <search terms>\n\nwhere <category> is one of:', categories, '\n'
return 1
searcher = EntitySearch()
results = searcher.searchEntities(args[0], ' '.join(args[1:]), **queryParams)
for result in results:
print "\n\n"
print "TITLE:", format_for_print(result.title)
subtitle = result.subtitle
if isinstance(result, PlaceEntity) and result.formatAddress():
subtitle = result.formatAddress()
print "SUBTITLE:", format_for_print(subtitle)
print "SEARCH ID:", result.search_id
print result
from libs.CountedFunction import printFunctionCounts
printFunctionCounts()
def main():
usage = "Usage: %prog --entity_id=<id> OR %prod --search_id=<id> OR %prod <query> <subcategory?> <index?>"
version = "%prog " + __version__
parser = OptionParser(usage=usage, version=version)
parser.add_option('--entity_id', action='store', dest='entity_id', default=None)
parser.add_option('--search_id', action='store', dest='search_id', default=None)
(options, args) = parser.parse_args()
if options.entity_id and options.search_id:
print '--entity_id and --search_id are mutually exclusive!'
id_provided = options.entity_id or options.search_id
if id_provided and len(args) > 1:
print '--entity_id and --search_id cannot be used with query arguments!'
if options.entity_id:
from api.db.mongodb.MongoEntityCollection import MongoEntityCollection
entity = MongoEntityCollection().getEntity(options.entity_id)
elif options.search_id:
entity = getEntityFromSearchId(options.search_id)
else:
query = buildQueryFromArgs(args)
from api.MongoStampedAPI import MongoStampedAPI
cursor = MongoStampedAPI()._entityDB._collection.find(query)
if cursor.count() == 0:
print("Could not find a matching entity for query: %s" % query)
return
entity = MongoStampedAPI()._entityDB._convertFromMongo(cursor[0])
print( "Before:\n%s" % pformat( entity.dataExport() ) )
container = FullResolveContainer()
decorations = {}
container.enrichEntity( entity, decorations )
print( "After:\n%s" % pformat( entity.dataExport() ) )
if len(decorations) > 0:
print( "With decorations:")
for k,v in decorations.items():
print( "%s decoration:" % k )
try:
print( "%s" % pformat(v.dataExport()) )
except Exception:
print( "%s" % pformat(v) )
from libs.CountedFunction import printFunctionCounts
printFunctionCounts()
def __run_eval_for_category(self, category):
if category == 'all':
categories = ('app', 'book', 'film', 'music', 'place')
searchIds = []
for cat in categories:
searchIds.extend(self.__get_search_ids_for_category(cat))
else:
searchIds = self.__get_search_ids_for_category(category)
resolutionResult = {}
formattedErrors = []
resolver = FullResolveContainer.FullResolveContainer()
for searchId in searchIds:
try:
entity, original = self.__convertSearchId(searchId, resolver)
proxyList = self.__getResolverObjects(entity)
resolutionResult[searchId] = (entity, original, proxyList)
except Exception:
formattedErrors.append(traceback.format_exc())
printFunctionCounts()
outputMessage = """
/---------------------------------------------
| Resolution results for %s written to:
| %s
\\---------------------------------------------
"""
tmpPrefix = category + '-' + FLAGS.output_prefix
with tempfile.NamedTemporaryFile(prefix=tmpPrefix, delete=False) as output:
pickle.dump(resolutionResult, output)
if formattedErrors:
print('\n\nENCOUNTERED %i ERRORS\n\n' % len(formattedErrors))
print('\n\n'.join([''.join(formattedError) for formattedError in formattedErrors]))
print('\n\n')
print outputMessage % (category, output.name)
