def memory_search_api():
source = request.args.get('source')
target = request.args.get('target')
project = request.args.get('project')
search = Search(source, target, project)
return Response(search.get_json(), mimetype='application/json')
def run(self):
# Main loop
while True:
# Perform a simulation step of 64 milliseconds
# and leave the loop when the simulation is over
if self.step(64) == -1:
break
#self.forward()
# Read the sensors:
prox = self.get_proximities()
#arg1 = self.get_lights()
#arg2 = self.get_accelleration()
# Process sensor data here.
SearchObject = Search()
output1 = SearchObject.determine_action(prox)
if(output1[0]):
speeds = output1[1]
self.move_wheels(speeds[0],speeds[1],1.0)
else:
self.stop()
#Search.determine_action(True)
#Stagnation.determine_action(True)
# Enter here functions to send actuator commands, like:
print output1
def GET(self):
logging.debug(self.input)
userName = auth.uuap_sso()
products = auth.getProcByName(userName)
if products==None or len(products)==0:
web.config.session.kill()
return render.forbidden(userName)
if self.input == None or len(self.input) == 0:
return render.manage(userName, products, web.ctx.homedomain)
#更新树形菜单
if self.input['oper'] == 'updatelist':
#检查文件夹是否存在，不存在则创建
dirPath = 'data/updateflag'
product = self.input['product']
updateflag = '%s/%s' % (dirPath,product)
if not os.path.exists(dirPath):
os.makedirs(dirPath)
#创建更新标志文件以触发updatelist.sh的更新任务
f = open(updateflag, 'w')
f.close()
while os.path.exists(updateflag):
time.sleep(0.1)
return json.dumps({'code':200,'txt':u'更新成功'})
elif self.input['oper'] == 'search':
s = Search(self.input)
return s.search()
class BookSearchTests(WLTestCase):
def setUp(self):
WLTestCase.setUp(self)
index = Index()
self.search = Search()
index.delete_query(self.search.index.query(uid="*"))
index.index.commit()
with self.settings(NO_SEARCH_INDEX=False):
self.do_doktora = Book.from_xml_file(
get_fixture('do-doktora.xml', opds))
self.do_anusie = Book.from_xml_file(
get_fixture('fraszka-do-anusie.xml', catalogue))
def test_search_perfect_book_author(self):
books = self.search.search_books(self.search.index.query(authors=u"sęp szarzyński"))
assert len(books) == 1
assert books[0].id == self.do_anusie.id
# here we lack slop functionality as well
def test_search_perfect_book_title(self):
books = self.search.search_books(self.search.index.query(title=u"fraszka do anusie"))
assert len(books) == 1
assert books[0].id == self.do_anusie.id
def searchAction(event):
try:
global query
global mTime
mTime = StringVar(None)
query = StringVar(None)
search_ = Search()
query = self.searchEntry1.get()
if query not in (None, '', ' '):
start_time = time.time()
global title_url
title_url = [None]
raw = search_.fetch_url(query)
title_url = search_.process_url(raw)
self.masters.withdraw()
mTime = (time.time() - start_time)
self.guiresults()
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (mTime), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
else:
tkMessageBox.showinfo('Info', 'You must put a keyword')
except Exception as e:
tkMessageBox.showinfo('Info', 'No Internet Connection Try Again Later')
exit()
def searchMatchesFound(self, searchString=None):
""" Helper function used to return the number of search results """
self.startCoverage("searchMatchesFound")
s = Search(self)
result = s.searchMatchesFound(searchString)
self.endCoverage()
return result
def search_projects(request):
'''
comments
'''
if request.method == 'GET':
search = Search(request)
context = search.get_search_context(search.SEARCH_PROJECTS)
return render_to_response('project_search_results.html', context)
def search_json():
keyword = request.data
para = json.loads(keyword)['keyword']
c_log('search', para).save()
target = Search()
if keyword == None:
return 'NONE'
return target.fetch(para, 3, 1) # keyword limit isjson
def get_search_results():
try:
search_text = request.json['search-text']
s = Search( search_text )
results = s.search()
return render_template( 'search_results.html', results=results), 200
except ValueError, e:
return render_template( 'search_error.html', errortext=str(e))
def go_search(query, need_suggest=True):
search = Search()
if (need_suggest):
suggest = search.generate_suggest(query)
else:
suggest = ""
result = search.go(query)
return result, suggest
def search_developers(request):
'''
comments
'''
if request.method == 'GET':
search = Search(request)
context = search.get_search_context(search.SEARCH_DEVELOPERS)
return render_to_response('developer_search_results.html', context)
def ask_for_URLs(self):
""" 1) Envoie une recherche en background de fichiers similaires
2) Lorsque les urls sont arrivées, set_URLs met à jour les urls puis appelle manage_download
3) _ftp.Manage_download ajoute des urls pour aider au download"""
print "Asking for urls"
search = Search(self.file_share.name, self.file_share.protocol)
# Signal
self.resultsReceived.connect(self.set_URLs)
search.do_search(self.resultsReceived.emit)
def autocomplete_api(word):
word = word + u"*"
lang = request.args.get('lang')
if lang is None:
search = Search(word)
else:
search = Search(word, lang)
search.AutoComplete = True
return json_answer(search.get_json())
def get_issues_with_label():
i = 0
y = 0
for label in labels:
issues = Search(search_query + "AND labels = '%s'" % label)
print(label)
print("%s total issues. %s total points.") % (
issues.get_issue_count(), issues.get_point_sum())
i = i + issues.get_point_sum()
y = y + issues.get_issue_count()
print("Total issues: %s Total Points: %s") % (y, i)
def search_files():
keyword = request.GET.get('w')
if len(keyword) > 0:
keyword = keyword.strip()
s = Search(os.getcwd(), keyword.decode("utf-8"), ("*.markdown", "*.md"))
result = s.walk()
result = [x for x in result if x[1] is not None]
result = map(lambda x : [x[0][len(os.getcwd()):len(x[0])], x[1]], result)
return dict(results = result, keyword = keyword, request = request)
def dict_index(lletra):
start = lletra.find('?')
if start != -1:
lletra = lletra[:start]
search = Search(lletra)
search.Index = True
search.Duplicates = False
View = IndexView(lletra)
result = View.do(search)
return result
def run(self):
search = Search(DATABASE_FILE_NAME)
# Search!
result_list = search.search(self.term)
# Create an HTML file and open it in the default browser
name = self.generate_html_file(result_list)
webbrowser.open('file://' + name)
# Re-enable the search button
self.app.button.config(text='Search', state=ACTIVE)
def search_api(word):
lang = request.args.get('lang')
it = request.args.get('it')
if lang is None:
search = Search(word)
else:
search = Search(word, lang)
if it is None and is_tracking_enabled():
save_stats(word, lang)
return json_answer(search.get_json())
class TestSkipListMerging(unittest.TestCase):
def get_skipList(self, length):
lst = SkipList()
data = sorted([random.randint(0, length*4) for i in range(0, length)])
for i in range(0, length):
lst.append(data[i]) # TODO:swap out with SkipList(data)
return lst
def setUp(self):
self.la = self.get_skipList(10)
self.lb = self.get_skipList(20)
self.lc = self.get_skipList(20)
postings_file = "dev_postings.data"
dictionary_file = "dev_dict.data"
self.search = Search(postings_file, dictionary_file)
def list_equality(self, lsta, lstb):
try:
self.assertEqual(len(lsta), len(lstb))
self.assertEqual(lsta.get_list(), lstb.get_list())
except AssertionError as e:
logging.info(lsta)
logging.info(lstb)
print lsta
print lstb
raise e
def test_mergingSingleListShouldReturnTheList(self):
"""
A single skip list should just be casted into a simple list and returned
"""
results = self.search.merge_results(Operation.AND, self.la)
self.list_equality(self.la, results)
def test_mergingTwoListsORshouldReturnUnion(self):
results = self.search.merge_results(Operation.OR, self.la, self.lb)
# results = self.search.merge_two_list(self.la, self.lb, Operation.OR)
la = self.la.get_list()
la.extend(self.lb.get_list())
la = list(set(la))
la.sort()
self.list_equality(results, SkipList(la))
def test_mergingTwoListsOverANDshouldReturnIntersection(self):
results = self.search.merge_results(Operation.AND, self.la, self.lb)
# results = self.search.merge_two_list(self.la, self.lb, Operation.AND)
la = set(self.la.get_list())
lb = set(self.lb.get_list())
ls = la & lb
ls = list(ls)
ls.sort()
self.list_equality(results, SkipList(ls))
def get_next_redo():
from pyasm.biz import Project
namespace = Project.get_project_code()
user_name = Environment.get_user_name()
search = Search("sthpw/transaction_log")
search.add_filter("login", user_name)
search.add_filter("namespace", namespace)
search.add_filter("type", "redo")
search.add_order_by("timestamp")
sobject = search.get_sobject()
return sobject
def results(search_text):
links = []
page_title='Search Result'
search_text = search_text
search_text = search_text.capitalize()
WIKIPEDIA_BASE='https://en.wikipedia.org'
seed = WIKIPEDIA_BASE + str('/wiki/') + str(search_text) # as seed
search = Search(seed)
graph = search.create_graph()
for source, dest in graph:
newDict = {"source": source, "target": dest }
links.append(newDict)
return links
def call_search():
global par_orb,par_color
info = v.get()
path=z.get()
if info=='':
tkMessageBox.showinfo('ERROR','Please enter image name!!!')
elif info !='':
if par_orb==1:
s=Searcher(info)
s.search_image()
elif par_color==1:
path='/home/farhan/project/CBIR/my_contrib/index.csv'
obj=Search(info,path)
obj.main_search()
def get_last(type=None):
#namespace = SearchType.get_project()
from pyasm.biz import Project
namespace = Project.get_project_code()
user_name = Environment.get_user_name()
search = Search("sthpw/transaction_log")
search.add_filter("login", user_name)
search.add_filter("namespace", namespace)
if type:
search.add_filter("type", type)
search.add_order_by("timestamp desc")
sobject = search.get_sobject()
return sobject
def api_organisations():
timer = Timer()
timer.start()
app.logger.debug(request.args)
filter = {}
filter["handelsnaam"] = check_args("handelsnaam")
filter["kvknummer"] = check_args("kvknummer")
filter["straat"] = check_args("straat")
filter["huisnummer"] = check_args("huisnummer")
filter["postcode"] = check_args("postcode")
filter["plaats"] = check_args("plaats")
filter["hoofdvestiging"] = check_args_boolean("hoofdvestiging", True, False)
filter["nevenvestiging"] = check_args_boolean("nevenvestiging", True, False)
filter["rechtspersoon"] = check_args_boolean("rechtspersoon", True, False)
filter["vervallen"] = check_args_boolean("vervallen", False, True)
filter["uitgeschreven"] = check_args_boolean("uitgeschreven", False, True)
app.logger.debug(filter)
if filter["handelsnaam"] == "" and filter["kvknummer"] == "" and filter["straat"] == "" and filter["huisnummer"] == "" and filter["postcode"] == "" and filter["plaats"] == "":
return unprocessable_entity()
else:
if 'startpage' in request.args:
startpage = int(request.args['startpage'])
else:
startpage = 1
if 'maxpages' in request.args:
maxpages = int(request.args['maxpages'])
else:
maxpages = 1
try:
search = Search(filter, startpage, maxpages)
except NoResultsError:
return not_found()
else:
results = search.run()
timer.stop();
results["total_exectime"] = timer.exectime()
results["api_version"] = "v1"
results["release"] = release
resp = jsonify(results)
resp.status_code = 200
return resp
def logreduce():
if request.method == 'POST':
file = request.files['file']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
inputfilename = os.path.join(app.config['UPLOAD_FOLDER'], filename)
print "in logreduce and about to save file", inputfilename
file.save(inputfilename)
datastore = read_lines_from_file(inputfilename)
#insert into elastic search
for line in datastore:
Search.insert(jsonify(line))
app.config['DATA'] = datastore
app.config['LAST_FILENAME'] = inputfilename
return render_template('pages/logreduce.html', dataLoaded=app.config['LAST_FILENAME'])
def get_by_ticket(ticket):
search = Search(TransactionState)
search.add_filter("ticket", ticket)
state = search.get_sobject()
# create the state data for this ticket
if not state:
state = SObjectFactory.create(TransactionState.SEARCH_TYPE)
state.set_value("ticket", ticket)
data = Xml()
data.create_doc("state")
state.set_value("data", data.to_string() )
state.commit()
return state
def hint(request):
prefix = request.GET.get('term', '')
if len(prefix) < 2:
return JSONResponse([])
prefix = remove_query_syntax_chars(prefix)
search = Search()
# tagi beda ograniczac tutaj
# ale tagi moga byc na ksiazce i na fragmentach
# jezeli tagi dot tylko ksiazki, to wazne zeby te nowe byly w tej samej ksiazce
# jesli zas dotycza themes, to wazne, zeby byly w tym samym fragmencie.
tags = search.hint_tags(prefix, pdcounter=True)
books = search.hint_books(prefix)
def is_dupe(tag):
if isinstance(tag, PDCounterAuthor):
if filter(lambda t: t.slug == tag.slug and t != tag, tags):
return True
elif isinstance(tag, PDCounterBook):
if filter(lambda b: b.slug == tag.slug, tags):
return True
return False
tags = filter(lambda t: not is_dupe(t), tags)
def category_name(c):
if c.startswith('pd_'):
c = c[len('pd_'):]
return _(c)
callback = request.GET.get('callback', None)
data = [{'label': t.name,
'category': category_name(t.category),
'id': t.id,
'url': t.get_absolute_url()}
for t in tags] + \
[{'label': b.title,
'category': _('book'),
'id': b.id,
'url': b.get_absolute_url()}
for b in books]
if callback:
return HttpResponse("%s(%s);" % (callback, json.dumps(data)),
content_type="application/json; charset=utf-8")
else:
return JSONResponse(data)
def search(term=''):
fileConfig('config/logging.conf')
prop = PropertyUtil('config/application.conf')
logger = logging.getLogger(__name__)
topics = None
json_data = {}
try:
logger.info('Term = {0}'.format(term))
if prop is not None:
logger.info('Index Name = {0}'.format(prop.elasticSearchIndexName))
search = Search(prop , logger )
if term != '':
data = search.get(term)
json_data = json.dumps(data)
except Exception , error:
logger.error('Exception occurred - {0}'.format(str(error)))
def search():
#rand = random.randrange(0, db.session.query(Tweet).count())
#tweet = db.session.query(Tweet)[rand]
username = "******"
query = "south" #get it from the index page text field
search_obj = Search(username,query)
search_result = search_obj.search()
# ??? how to send a list using jsonfy
return jsonify(
id=tweet.tweet_id,
text=tweet.text,
link=tweet.link,
user_id=tweet.user_id,
screen_name=tweet.screen_name,
retweet_count=tweet.retweet_count,
)
def search(request):
# determine the type of search
query = request.GET.get('q', '')
s = Search(query)
context = {'query': query}
results = s.get_results()
if s.result_type == 'Restaurant':
context['restaurants'] = results
else:
context['locations'] = results
return render_to_response("common/search.html", context,
context_instance=RequestContext(request))
def occurence_not_unique(self, element, mineral_dict):
return len(
Search.search_spec(
element,
eval(periodic().element_with_not_unique_starting().get(
element)), mineral_dict))
from datetime import datetime
from flask import Flask, render_template, request
from search import Search
from naivebayes import NaiveBayes
from imagesearch import ImageSearch
from imagecaption import ImageCaption
from sklearn.model_selection import train_test_split
from zipfile import ZipFile
with ZipFile('pre_processed_data.zip', 'r') as zipObj:
zipObj.extractall()
search = Search()
search.init()
naive_bayes = NaiveBayes()
naive_bayes.init()
imagesearch = ImageSearch()
imagesearch.init()
image_caption = ImageCaption()
image_caption.init()
app = Flask(__name__)
@app.route("/")
def hello():
return '<a href="/search">Search</a><br><a href="/classify">Classify</a><br><a href="/image_search">Image Search</a>'
from crawler import TaskManager
from search import Search
from storage import Directory, Option, Task, User
from storage import LocalStorage, DuplicateDirectoryException, DuplicateUserException
from thumbnail import ThumbnailGenerator
app = Flask(__name__)
app.secret_key = "A very secret key"
storage = LocalStorage(config.db_path)
# Disable flask logging
flaskLogger = logging.getLogger('werkzeug')
flaskLogger.setLevel(logging.ERROR)
tm = TaskManager(storage)
search = Search(config.elasticsearch_index)
def get_dir_size(path):
size = 0
for root, dirs, files in os.walk(path):
for filename in files:
full_path = os.path.join(root, filename)
size += os.path.getsize(full_path)
return size
@app.route("/user/<user>")
def user_manage(user):
def Search(self,
lang,
cond,
headcond=None,
finheaddepcond=None,
depcond2=None,
headdepcond=None,
prevcond=None,
nextcond=None,
secondnextcond=None,
prevornext=False,
samesentencecond=None,
secondpreviouscond=None,
limited=None,
broad=False):
con = self.cons[lang]['db']
thisSearch = Search(con=con)
thisSearch.queried_table = self.cons[lang]['table']
thisSearch.isparallel = False
thisSearch.toplevel = "sentence_id"
thisSearch.limited = False
thisSearch.ConditionColumns.append(cond)
thisSearch.broad = broad
thisSearch.non_db_data = None
thisSearch.headcond = headcond
thisSearch.secondpreviouscond = secondpreviouscond
thisSearch.prevcond = prevcond
thisSearch.nextcond = nextcond
if prevornext:
#In situations where it is enough for either of the surrounding words to fulfill a criterion
thisSearch.prevornext['ison'] = True
thisSearch.samesentencecond = samesentencecond
thisSearch.secondnextcond = secondnextcond
thisSearch.headdepcond = headdepcond
thisSearch.finheaddepcond = finheaddepcond
thisSearch.depcond2 = depcond2
thisSearch.Run(False)
self.searches.append(thisSearch)
#Store the results in a more comfortable way
SimplifyResultSet(thisSearch)
logging.info(thisSearch.absolutematchcount)
self.searches.append(thisSearch)
return thisSearch
action='store_true',
help="Delete existing listing.")
parser.add_argument(
'--print',
nargs='?',
const=1,
type=int,
help=
"Print 10 listings per page, pass integer argument for print select page"
)
return parser.parse_args() # Return parsed arguments.
# Below is the part of main.py that will execute.
if __name__ == "__main__":
searcher = Search()
editor = ListingEditor()
raw_args = parse_args()
Sorter = QuickSort()
arg_list = {}
path_active = "data_files/active_listings.json"
path_matched = "data_files/matched_listings.json"
path_sorted = "data_files/price_sorted_listings.json"
for key in vars(raw_args): # Key refers to item being detailed by user.
value = getattr(raw_args, key) # Value of item, this is users input.
arg_list[key] = value
#Check if the argument for print is 0, or an error will occur
if arg_list['print'] == 0:
class QueryReofrmulatorEnv(Env):
def __init__(self, DATA_DIR, dset, is_train, verbose, reward='RECALL'):
# this method returns simulator, state/action vocabularies, and the maximum number of actions
n_words = 100 # 374000 # words for the vocabulary
vocab_path = os.path.join(
DATA_DIR, 'data/D_cbow_pdw.pkl'
) # Path to the python dictionary containing the vocabulary.
wordemb_path = os.path.join(
DATA_DIR, 'data/D_cbow_pdw.pkl'
) # Path to the python dictionary containing the word embeddings.
dataset_path = os.path.join(
DATA_DIR, 'data/msa_dataset.hdf5'
) # path to load the hdf5 dataset containing queries and ground-truth documents.
docs_path = os.path.join(
DATA_DIR,
'data/msa_corpus.hdf5') # Path to load the articles and links.
docs_path_term = os.path.join(
DATA_DIR,
'data/msa_corpus.hdf5') # Path to load the articles and links.
############################
# Search Engine Parameters #
############################
n_threads = 1 # 20 # number of parallel process that will execute the queries on the search engine.
index_name = 'index' # index name for the search engine. Used when engine is 'lucene'.
index_name_term = 'index_terms' # index name for the search engine. Used when engine is 'lucene'.
use_cache = False # If True, cache (query-retrieved docs) pairs. Watch for memory usage.
max_terms_per_doc = 15 # Maximum number of candidate terms from each feedback doc. Must be always less than max_words_input .
self.vocab = utils.load_vocab(vocab_path, n_words)
vocabinv = {}
for k, v in self.vocab.items():
vocabinv[v] = k
self.reward = reward
self.is_train = is_train
self.search = Search(engine=lucene_search.LuceneSearch(
DATA_DIR, self.vocab, n_threads, max_terms_per_doc, index_name,
index_name_term, docs_path, docs_path_term, use_cache))
t0 = time()
dh5 = dataset_hdf5.DatasetHDF5(dataset_path)
self.qi = dh5.get_queries(dset)
self.dt = dh5.get_doc_ids(dset)
print("Loading queries and docs {}".format(time() - t0))
self.reset()
'''for _, train_index in kf:
qi, qi_i, qi_lst, D_gt_id, D_gt_url = self.get_samples(qi, dt, vocab, train_index, self.search.engine, max_words_input=self.search.max_words_input)
# share the current queries with the search engine.
current_queries = qi_lst
i=3
print 'Input Query: ', qi[i].replace('\n', '\\n')
print 'Target Docs: ', str(D_gt_url[i])
print 'Input Query Vocab: ', utils.idx2text(qi_i[i], vocabinv)
n_iterations = 2 # number of query reformulation iterations.
for n_iter in range(n_iterations):
print("current_queries", len(current_queries), current_queries)
if n_iter < self.search.q_0_fixed_until:
ones = np.ones((len(current_queries), self.search.max_words_input))
if n_iter > 0:
# select everything from the original query in the first iteration.
reformulated_query = np.concatenate([ones, ones], axis=1)
else:
reformulated_query = ones
print 'reformulated_query', reformulated_query.shape
#reformulated_query is our action!!!
metrics, D_i_, D_id_, D_gt_m_ = self.search.perform(reformulated_query, D_gt_id, self.is_train, current_queries)
print "D_id_", D_id_
print 'Iteration', n_iter
print ' '.join(self.search.metrics_map.keys())
print metrics.mean(0)
print
print 'Retrieved Docs: ', str([self.search.engine.id_title_map[d_id] for d_id in D_id_[i]])
print
print 'Reformulated Query:', self.search.reformulated_queries[n_iter][i]
print
print 'Query ANS: ',
for kk, word in enumerate(current_queries[i][:reformulated_query.shape[1]]):
if word not in vocab and word != '':
word += '<unk>'
if reformulated_query[0, kk] == 1:
word = word.upper()
print str(word),
print
print'''
def get_samples(self,
input_queries,
target_docs,
vocab,
index,
engine,
max_words_input=200):
qi = [utils.clean(input_queries[t].lower()) for t in index]
D_gt_title = [target_docs[t] for t in index]
D_gt_id_lst = []
for j, t in enumerate(index):
#print("j",j)
D_gt_id_lst.append([])
for title in D_gt_title[j]:
#print("title", title)
if title in engine.title_id_map:
D_gt_id_lst[-1].append(engine.title_id_map[title])
#else:
# print 'ground-truth doc not in index:', title
D_gt_id = utils.lst2matrix(D_gt_id_lst)
qi_i, qi_lst_ = utils.text2idx2(qi, vocab, max_words_input)
#print("qi_i", qi_i)
#print("qi_lst_", qi_lst_)
qi_lst = []
for qii_lst in qi_lst_:
# append empty strings, so the list size becomes <dim>.
qi_lst.append(qii_lst +
max(0, max_words_input - len(qii_lst)) * [''])
return qi, qi_i, qi_lst, D_gt_id, D_gt_title
def _seed(self, seed=None):
self.np_random, seed = seeding.np_random(seed)
return [seed]
def step(self, action):
done = False
reformulated_query, current_queries, D_gt_id = action
metrics, D_i_, D_id_, D_gt_m_ = self.search.perform(
reformulated_query, D_gt_id, self.is_train, current_queries)
print "D_id_", D_id_
i = 3
print "ALALALA ", [
self.search.engine.id_title_map[d_id] for d_id in D_id_[i]
]
text = [[self.search.engine.id_title_map[d_id] for d_id in D_id_[i]]
for i in range(D_id_.shape[0])]
actions = current_queries
metric_idx = self.search.metrics_map[self.reward.upper()]
reward = metrics[metric_idx]
if (len(actions) == 0): # or self.counsteps > 10):
done = True
return [text, actions], reward, done, {}
def reset(self):
"""
Resets the state of the environment, returning an initial observation.
Outputs
-------
observation : the initial observation of the space. (Initial reward is assumed to be 0.)
"""
t0 = time()
#for now lets get one sample with all.
kf = utils.get_minibatches_idx(len(self.qi),
len(self.qi),
shuffle=True)
_, train_index = kf[
0] #iterate if len(kf)>1 --> for _, train_index in kf:
print "kf", kf, len(self.qi)
print("Got minibatch index {}".format(time() - t0))
qi, qi_i, qi_lst, D_gt_id, D_gt_url = self.get_samples(
self.qi,
self.dt,
self.vocab,
train_index,
self.search.engine,
max_words_input=self.search.max_words_input)
current_queries = qi_lst
n_iterations = 1 # number of query reformulation iterations.
if n_iterations < self.search.q_0_fixed_until:
ones = np.ones((len(current_queries), self.search.max_words_input))
reformulated_query = ones
if n_iterations > 0:
# select everything from the original query in the first iteration.
reformulated_query = np.concatenate([ones, ones], axis=1)
print 'reformulated_query', reformulated_query.shape
# reformulated_query is our action!!!
actions = reformulated_query, current_queries, D_gt_id
[text, actions], reward, done, found = self.step(action)
print "text", text
print "actions", actions
print "rew", reward
return [text, actions]
def __del__(self):
pass
def get_tokenizers(self):
state_tokenizer = nltk.word_tokenize
action_tokenizer = nltk.word_tokenize
return state_tokenizer, action_tokenizer
def main():
parser = argparse.ArgumentParser(
description="GitHub search helper. Program will ask for a input query. "
"e.g., 'UnsupportedEncodingException UTf-8 in:file"
"language:java' and will replace ' ' with '+'")
parser.add_argument("--type",
"-t",
help="How much of the process do you want to run? "
"(1) Full "
"(2) Only find potential repos "
"(3) Search repos for code",
type=int,
default=1)
query = input("What is your search query? ")
query = query.replace(" ", "+")
search = input("What is the code you are searching for? ")
search = prepare_search(search)
pipeline = Search("query_config.ini", query, search)
run_type = parser.parse_args().type
if run_type == 1:
pipeline.find_repos()
pipeline.find_code_in_repo()
elif run_type == 2:
pipeline.find_repos()
elif run_type == 3:
pipeline.find_code_in_repo()
else:
pipeline.check_search_rate()
from node import Node from problem import Problem from search import Search p = Problem() s = Search(p) path = s.BFS().path path.reverse() print(path)
class alltubefilmy:
def __init__(self):
log.info('Starting alltubefilmy.pl')
self.cm = mrknow_pCommon.common()
self.parser = mrknow_Parser.mrknow_Parser()
self.pp = mrknow_Pageparser.mrknow_Pageparser()
self.up = mrknow_urlparser.mrknow_urlparser()
self.player = mrknow_Player.mrknow_Player()
self.search = Search(url='%(quoted)s',
service='alltubefilmy',
listItemsFun=self.listsItemsOther)
def listsMainMenu(self, table):
for num, val in table.items():
self.add('alltubefilmy', 'main-menu', val, 'None', 'None', 'None',
'None', 'None', True, False)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def listsCategoriesMenu(self):
HEADER = {
'Accept-Language': 'pl,en-US;q=0.7,en;q=0.3',
'Referer': mainUrl,
'User-Agent': HOST
}
query_data = {
'url': catUrl,
'use_host': False,
'use_host': False,
'use_header': True,
'header': HEADER,
'use_cookie': False,
'use_post': False,
'return_data': True
}
link = self.cm.getURLRequestData(query_data)
soup = BeautifulSoup(link)
linki_ost = soup.find('ul', {"class": "filter-list filter-category"})
#print("link",link)
print("M1", linki_ost)
if linki_ost:
linki_all = linki_ost.findAll('li')
for mylink in linki_all:
print("m", mylink.text, mylink['data-id'])
#murl = catUrl + match1[i][0].replace('.html','')
self.add('alltubefilmy', 'categories-menu', mylink.text,
mylink.text, 'None',
catUrl + 'kategoria[' + mylink['data-id'] + ']+',
'None', 'None', True, False, str(1),
mylink['data-id'])
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def getSearchURL(self, key):
if key != None:
url = mainUrl + '/search?search_query=' + urllib.quote_plus(
key) + '&x=0&y=0'
return url
else:
return False
#req = urllib2.Request(url)
#req.add_header('User-Agent', HOST)
#openURL = urllib2.urlopen(req)
#readURL = openURL.read()
def listsItemsOther(self, key):
log(key)
query_data = {
'url': 'http://alltube.tv/szukaj',
'use_host': False,
'use_cookie': False,
'use_post': True,
'return_data': True
}
post_data = {'search': key}
link = self.cm.getURLRequestData(query_data, post_data)
#log(link)
if 'Seriale:' in link:
link = re.compile('<h4>Filmy:</h4>(.*?)<h4>Seriale:</h4>',
re.DOTALL).findall(link)[0]
log(link)
soup = BeautifulSoup(link)
linki_ost = soup.findAll('div', {"class": "item-block clearfix"})
log("link %s" % link)
if linki_ost:
for mylink in linki_ost:
log("Link2 %s" % mylink.a.h3.text)
self.add('alltubefilmy', 'playSelectedMovie', 'None',
mylink.a.h3.text, mylink.a.img['src'],
mylink.a['href'], 'aaaa', 'None', False, True)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def GetImage(self, url):
query_data = {
'url': url,
'use_host': False,
'use_cookie': False,
'use_post': True,
'return_data': True
}
link = self.cm.getURLRequestData(query_data)
match2 = re.compile(
'<div class="span2">\n <img src="(.*?)" alt=""/>\n \n </div>',
re.DOTALL).findall(link)
if len(match2) > 0:
return match2[0]
else:
return ""
def listsItems(self, url, strona='', kategoria=''):
if strona == '':
strona = 1
nowastrona = int(strona) + 1
if kategoria == 'None':
myurl = catUrl + 'strona[' + str(nowastrona) + ']+'
else:
myurl = catUrl + 'kategoria[' + kategoria + ']+' + 'strona[' + str(
nowastrona) + ']+'
HEADER = {
'Accept-Language': 'pl,en-US;q=0.7,en;q=0.3',
'Referer': mainUrl,
'User-Agent': HOST
}
query_data = {
'url': url,
'use_host': False,
'use_header': True,
'header': HEADER,
'use_cookie': False,
'use_post': False,
'return_data': True
}
link = self.cm.getURLRequestData(query_data)
soup = BeautifulSoup(link)
linki_ost = soup.findAll('div',
{"class": "col-xs-12 col-sm-6 col-lg-4"})
#print("link",link)
if linki_ost:
#linki_all = soup.findAll('div', {"class": "series"})
for mylink in linki_ost:
#print("m",mylink)
#print("M2",mylink.a['href'])
#print("M3",mylink.img['src'])
print("M4", url, strona, mylink.h3.text)
#add(self, service, name, category, title, iconimage, url, desc, rating, folder = True, isPlayable = True):
self.add('alltubefilmy', 'playSelectedMovie', 'None',
mylink.h3.text, mylink.img['src'], mylink.a['href'],
'aaaa', 'None', False, True)
# add(self, service, name, category, title, iconimage, url, desc, rating, folder = True, isPlayable = True,strona=''):
self.add('alltubefilmy', 'categories-menu', 'Następna strona',
'Następna strona', 'None', myurl, 'None', 'None', True, False,
str(nowastrona), kategoria)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def listsItemsA(self, url):
query_data = {
'url': url,
'use_host': False,
'use_cookie': False,
'use_post': True,
'return_data': True
}
link = self.cm.getURLRequestData(query_data)
match = re.compile('<li class="letter">(.*?)</li>',
re.DOTALL).findall(link)
print(match)
if len(match) > 0:
for i in range(len(match)):
self.add('alltubefilmy', 'page-menu', 'None', match[i], 'None',
mainUrl, 'aaaa', 'None', True, False)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def listsItemsS(self, url, strona):
query_data = {
'url': url,
'use_host': False,
'use_cookie': False,
'use_post': True,
'return_data': True
}
link = self.cm.getURLRequestData(query_data)
match0 = re.compile(
'<li data-letter="' + strona + '"><a href="(.*?)">(.*?)</a></li>',
re.DOTALL).findall(link)
print("Match", match0)
#match1 = re.compile('<li><a href="(.*?)">(.*?)</a></li>\n', re.DOTALL).findall(match[0])
#print match1
if len(match0) > 0:
for i in range(len(match0)):
title = match0[i][1]
self.add('alltubefilmy', 'items-menu', 'None',
self.cm.html_special_chars(title), 'None',
match0[i][0], 'aaaa', 'None', True, False)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def listsItemsOst(self, url):
HEADER = {
'Accept-Language': 'pl,en-US;q=0.7,en;q=0.3',
'Referer': mainUrl,
'User-Agent': HOST
}
query_data = {
'url': url,
'use_host': False,
'use_host': False,
'use_header': True,
'header': HEADER,
'use_cookie': False,
'use_post': False,
'return_data': True
}
link = self.cm.getURLRequestData(query_data)
soup = BeautifulSoup(link)
linki_ost = soup.find('div', {"class": "col-sm-9"})
#print("link",link)
if linki_ost:
linki_all = soup.findAll('div', {"class": "series"})
for mylink in linki_all:
print("m", mylink)
print("M2", mylink.a['href'])
myimage = mylink.img['src']
mytitle = mylink.contents[1].text
myhref = mylink.a['href']
#myseries = mylink.contents[2].findAll('li')
#for myitem in myseries:
self.add('alltubefilmy', 'playSelectedMovie', 'None', mytitle,
myimage, myhref, 'aaaa', 'None', False, True, '')
self.add('alltubefilmy', 'playSelectedMovie', 'None', mytitle, myimage,
myhref, 'aaaa', 'None', False, True, '')
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def listsItemsTop(self, url):
query_data = {
'url': url,
'use_host': False,
'use_cookie': False,
'use_post': True,
'return_data': True
}
link = self.cm.getURLRequestData(query_data)
match = re.compile(
'<!-- popularne dzisiaj -->\n(.*?)<!-- /popularne dzisiaj -->',
re.DOTALL).findall(link)
print match
# <td class="title" tyle="width:200px;"><a href=" "> </a></td>\n <td class="episode">\n <a href=" "><span class="w"> </span> </a>\n </td>
match1 = re.compile(
'<td class="title" tyle="width:200px;"><a href="(.*?)">(.*?)</a></td>\n <td class="episode">\n <a href="(.*?)"><span class="w">(.*?)</span>(.*?)</a>\n </td>',
re.DOTALL).findall(match[0])
if len(match1) > 0:
for i in range(len(match1)):
#print ("M",match1[i])
self.add(
'alltubefilmy', 'playSelectedMovie', 'None',
self.cm.html_special_chars(match1[i][1].strip() + ' ' +
match1[i][3].strip() + ' ' +
match1[i][4].strip()), 'None',
mainUrl[:-1] + match1[i][2], 'aaaa', 'None', False, False,
'')
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def listsItemsPage(self, url):
if not url.startswith("http://"):
url = mainUrl + url
if self.getSizeAllItems(url) > 0 and self.getSizeItemsPerPage(url) > 0:
a = math.ceil(
float(self.getSizeAllItems(url)) /
float(self.getSizeItemsPerPage(url)))
for i in range(int(a)):
num = i + 1
title = 'Lista ' + str(num)
destUrl = url + sort_asc + '&page=' + str(num)
self.add('alltubefilmy', 'items-menu', 'None', title, 'None',
destUrl, 'None', 'None', True, False)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def listsSeasons(self, url, img):
query_data = {
'url': url,
'use_host': False,
'use_cookie': False,
'use_post': True,
'return_data': True
}
link = self.cm.getURLRequestData(query_data)
match = re.compile(
'<button data-action="scrollTo" data-scroll="(.*?)" class="btn btn-new cf sezonDirect" style="width:85px; font-size:13px;margin: 3px;" href="#" rel="1">(.*?)</button>',
re.DOTALL).findall(link)
#print match
if img == '' or img == None:
img = 'None'
for i in range(len(match)):
self.add('alltubefilmy', 'items-menu', 'None', match[i][1], img,
url, 'None', 'None', True, False, match[i][0])
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def searchInputText(self):
text = None
k = xbmc.Keyboard()
k.doModal()
if (k.isConfirmed()):
text = k.getText()
return text
def add(self,
service,
name,
category,
title,
iconimage,
url,
desc,
rating,
folder=True,
isPlayable=True,
strona='',
kategoria=''):
u = sys.argv[
0] + "?service=" + service + "&name=" + name + "&category=" + category + "&title=" + title + "&url=" + urllib.quote_plus(
url) + "&icon=" + urllib.quote_plus(
iconimage) + "&strona=" + urllib.quote_plus(
strona) + "&kategoria=" + urllib.quote_plus(kategoria)
#log.info(str(u))
if name == 'main-menu' or name == 'categories-menu':
title = category
if iconimage == '':
iconimage = "DefaultVideo.png"
liz = xbmcgui.ListItem(title,
iconImage="DefaultFolder.png",
thumbnailImage=iconimage)
if isPlayable:
liz.setProperty("IsPlayable", "true")
liz.setInfo(type="Video", infoLabels={"Title": title})
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),
url=u,
listitem=liz,
isFolder=folder)
def handleService(self):
params = self.parser.getParams()
name = self.parser.getParam(params, "name")
category = self.parser.getParam(params, "category")
url = self.parser.getParam(params, "url")
title = self.parser.getParam(params, "title")
icon = self.parser.getParam(params, "icon")
strona = self.parser.getParam(params, "strona")
kategoria = self.parser.getParam(params, "kategoria")
img = self.parser.getParam(params, "img")
print("DANE", kategoria, strona, url, title, name, icon)
if name == None:
self.listsMainMenu(MENU_TAB)
elif name == 'main-menu' and category == 'Ostatnio dodane':
log.info('Jest Ostatnio dodane: ')
self.listsItems(catUrl, 1, 'None')
elif name == 'main-menu' and category == 'Kategorie':
log.info('Jest Kategorie: ')
self.listsCategoriesMenu()
elif name == 'categories-menu':
log.info('Jest categories-menu: ')
self.listsItems(url, strona, kategoria)
elif name == 'page-menu' and category == 'None':
log.info('Jest Alfabetycznie Litera: ' + title)
self.listsItemsS(catUrl, title)
elif name == 'serial-menu' and category == 'None':
log.info('Jest Serial Menu: ')
self.listsSeasons(url, img)
elif name == 'items-menu' and category == 'None':
log.info('Jest Sezon: ')
self.listsItems(url, strona)
elif name == 'main-menu' and category == 'Top dzisiaj':
log.info('Jest Top 30: ')
self.listsItemsTop(catUrl)
# elif name == 'main-menu' and category == 'Ostatnie dodane seriale':
# self.listsItemsTop(catUrl,'Ostatnie dodane seriale', 'Ostatnie dodane odcinki')
elif name == 'main-menu' and category == 'Ostatnio dodane odcinki':
log.info('Jest Gorące: ')
self.listsItemsOst(catUrl)
#elif name == 'main-menu' and category == "Szukaj":
# key = self.searchInputText()
# if key != None:
# self.listsItemsOther(key)
elif self.search.handleService(
force=(name == 'main-menu' and category == 'Szukaj')):
return
elif name == 'categories-menu' and category != 'None':
log.info('url: ' + str(url))
self.listsItems(url, strona, filtrowanie)
if name == 'playSelectedMovie':
self.player.LOAD_AND_PLAY_VIDEO(url, title, '')
import numpy as np
from asm1.model.hex_board import HexBoard
import trueskill as ts
"""EXTRA TIME FOR DIJKSTRA EVALUATION"""
def play_game_and_time(player1, player2, board_size = 3):
board = HexBoard(board_size)
player2.color = HexBoard.get_opposite_color(player1.color)
current_player = player1 if player1.color == HexBoard.BLUE else player2
turn_time = {player1:[], player2: []}
while not board.game_over:
start_time = time.time()
next_move = current_player.generate_move(board)
turn_time[current_player].append(time.time() - start_time)
board.place(next_move, current_player.color)
current_player = player1 if player1.color == HexBoard.get_opposite_color(current_player.color) else player2
return np.mean(turn_time[player1]), np.mean(turn_time[player2])
player_random_3 = Search(**{'species': 'ai', 'color': 'red', 'method': 'alphabeta', 'evaluation': 'random', 'search_depth': 3})
player_dijkstra_3 = Search(**{'species': 'ai', 'color': 'blue', 'method': 'alphabeta', 'evaluation': 'dijkstra', 'search_depth': 3})
player_dijkstra_4 = Search(**{'species': 'ai', 'color': 'blue', 'method': 'alphabeta', 'evaluation': 'dijkstra', 'search_depth': 4})
player_mcts = Search(**{'species': 'ai', 'color': 'blue', 'method': 'mcts', 'evaluation': 'mcts', 'search_depth': 4,
'rating': ts.Rating(), 'search_iterations': 100, 'Cp': 2})
player_tt_random_3 = Search(**{'species': 'ai', 'color': 'red', 'method': 'alphabeta', 'evaluation': 'random', 'search_depth': 3, "transposition":True})
player_random_3_time, player_dijkstra_3_time = play_game_and_time(player_random_3, player_dijkstra_3, board_size=4)
player_mcts_time, player_dijkstra_4_time = play_game_and_time(player_mcts, player_dijkstra_4, board_size=4)
print("Taking a turn with Dijkstra 3 evaluation function takes: ", player_dijkstra_3_time," seconds for board size of 4")
print("Taking a turn with random evaluation function takes: ", player_random_3_time," seconds")
print("Taking a turn with dijikstra 4 takes: ", player_dijkstra_4_time," seconds")
print("Taking a turn with mcts: ", player_mcts_time," seconds")
def test_cache_usage(self):
s = Search()
print("\nInitial cache length: ", len(s.lru_cache))
s.string_search("power")
self.assertEqual(1, len(s.lru_cache),
"Cache not storing recently searched term")
def drop_down_callback(self, event):
s = Search(tree=self.tree)
s.search_by_county(county_name=self.drop_down.get())
def occurence_unique(self, element, mineral_dict):
return len(Search.search(element, mineral_dict))
from node import Node
from problem import Problem
from search import Search
p = Problem()
s = Search(p)
r = s.IDFS(maxDepth=14)
print(r.status)
path = r.path
path.reverse()
print(path)
print("number of expansions : ")
print(r.expandedNodes)
print("depth : ")
print(r.depth)
def equals(self, state):
return self.value == state.value
def dict_key(self):
return str(self.missionaries) + "," + str(self.cannibals) + "," + str(self.boat)
def applyOperators(self):
valid_successors = []
if self.send_1m().value in LEGAL_STATES:
valid_successors.append(self.send_1m())
if self.send_2m().value in LEGAL_STATES:
valid_successors.append(self.send_2m())
if self.send_1c().value in LEGAL_STATES:
valid_successors.append(self.send_1c())
if self.send_2c().value in LEGAL_STATES:
valid_successors.append(self.send_2c())
if self.send_1m_1c().value in LEGAL_STATES:
valid_successors.append(self.send_1m_1c())
if self.return_1c().value in LEGAL_STATES:
valid_successors.append(self.return_1c())
if self.return_1m().value in LEGAL_STATES:
valid_successors.append(self.return_1m())
if self.return_1m_1c().value in LEGAL_STATES:
valid_successors.append(self.return_1m_1c())
return valid_successors
Search(MissionaryState(3, 3, 1), MissionaryState(0, 0, 0), True)
print("----------------------------------------------------------------------------------------------------------------")
ImprovedSearch(MissionaryState(3, 3, 1), MissionaryState(0, 0, 0), True)
'''
Artificial Intelligence I
Assignment 1
Author: Bo Lin
Date of created: 09/09/2019
Date of modified: 09/10/2019
'''
import sys
from utils import get_input
from search import Search
if __name__ == "__main__":
graph, origin_city, destination_city = get_input(sys.argv)
searcher = Search(graph)
num_node_expanded, num_node_generate, max_node_in_memory, distance, node = searcher.search(
origin_city, destination_city)
output = ""
if node is not None:
route = [node.name]
while node.parent is not None:
route.append(node.parent.name)
node = node.parent
route = route[::-1]
for i in range(len(route) - 1):
start = route[i]
end = route[i + 1]
output += "%s to %s, %.2f\n" % (start, end,
graph[start].get_neighbor_cost(end))
else:
def access_log(self):
'''Method containing the main loop to run the program.'''
menu = Menu()
entry = Entry()
utils = Utilities()
search = Search()
validation = Validation()
current_menu = constants.MAIN_MENU
if not os.path.exists(constants.FILENAME):
with open(constants.FILENAME, 'a') as file:
writer = csv.DictWriter(file, fieldnames=constants.FIELDNAMES)
writer.writeheader()
while True:
utils.clear_screen()
menu.display(current_menu)
choice = menu.get_user_choice()
if current_menu == constants.MAIN_MENU:
if not validation.is_valid_input(choice, menu='csq'):
continue
if choice == 'c':
utils.clear_screen()
entry.create_new_entry()
elif choice == 's':
current_menu = constants.SEARCH_MENU
elif choice == 'q':
break
elif current_menu == constants.SEARCH_MENU:
if not validation.is_valid_input(choice, menu='edtprm'):
continue
if choice == 'e':
search.search('Please enter a date to search: ', 'date')
elif choice == 'd':
search.search(
'Please enter two comma separated dates to search'
'\n(ex. 01/15/1982, 12/11/2017): ', 'date_range')
elif choice == 't':
search.search(
'Please enter a time to search: ', 'time_spent')
elif choice == 'p':
search.search(
'Please enter a word or phrase to search: ',
'exact_match')
elif choice == 'r':
search.search(
'Please enter a word or phrase to search: ', 'regex')
elif choice == 'm':
current_menu = constants.MAIN_MENU
def makeSearch(ConditionColumns,
database,
dbtable,
headcond=None,
depcond=None,
headdepcond=None,
secondnextcond=None,
finheaddepcond=None,
depcond2=None,
nextcond=None,
prevcond=None,
prevornext=False,
appendconditioncolumns=True,
isparallel=False,
extralog='',
limited=None,
monoling=False,
samesentencecond=None,
secondpreviouscond=None,
non_db_data=None,
group=None,
broad=False,
trmeta=False):
logging.info('Starting the search..')
if extralog:
logging.info(extralog)
thisSearch = Search(database, askname=False)
if trmeta:
thisSearch.sql_cols = "tokenid, token, lemma, pos, feat, head, deprel, align_id, id, sentence_id, text_id, translation_id"
thisSearch.isparallel = isparallel
thisSearch.limited = limited
if monoling:
thisSearch.toplevel = "sentence_id"
else:
thisSearch.toplevel = "align_id"
if appendconditioncolumns:
thisSearch.ConditionColumns.append(ConditionColumns)
else:
thisSearch.ConditionColumns = ConditionColumns
thisSearch.headcond = headcond
thisSearch.depcond = depcond
thisSearch.depcond2 = depcond2
thisSearch.headdepcond = headdepcond
thisSearch.finheaddepcond = finheaddepcond
thisSearch.prevcond = prevcond
thisSearch.nextcond = nextcond
thisSearch.samesentencecond = samesentencecond
thisSearch.secondnextcond = secondnextcond
thisSearch.secondpreviouscond = secondpreviouscond
thisSearch.non_db_data = non_db_data
thisSearch.groupname = group
thisSearch.queried_table = dbtable
if prevornext:
#In situations where it is enough for either of the surrounding words to fulfill a criterion
thisSearch.prevornext['ison'] = True
if broad:
thisSearch.broadcontext = True
thisSearch.BuildSubQuery()
thisSearch.Find()
logging.info('Search committed')
thisSearch.SimplifyResultSet()
return thisSearch
def test_repr(self):
s = Search("used")
self.assertEqual(s.__repr__(), 'You have searched for 0 used car(s)')
def makeNondbSearch(ConditionColumns,
headcond=None,
depcond=None,
headdepcond=None,
secondnextcond=None,
finheaddepcond=None,
depcond2=None,
nextcond=None,
prevcond=None,
prevornext=False,
appendconditioncolumns=True,
isparallel=False,
extralog='',
limited=None,
monoling=False,
samesentencecond=None,
secondpreviouscond=None,
non_db_data=None):
logging.info('Starting the search..')
if extralog:
logging.info(extralog)
thisSearch = Search(askname=False, pseudo=True)
thisSearch.isparallel = isparallel
thisSearch.limited = limited
if monoling:
thisSearch.toplevel = "sentence_id"
if appendconditioncolumns:
thisSearch.ConditionColumns.append(ConditionColumns)
else:
thisSearch.ConditionColumns = ConditionColumns
thisSearch.headcond = headcond
thisSearch.depcond = depcond
thisSearch.depcond2 = depcond2
thisSearch.headdepcond = headdepcond
thisSearch.finheaddepcond = finheaddepcond
thisSearch.prevcond = prevcond
thisSearch.nextcond = nextcond
thisSearch.samesentencecond = samesentencecond
thisSearch.secondnextcond = secondnextcond
thisSearch.secondpreviouscond = secondpreviouscond
thisSearch.non_db_data = non_db_data
if prevornext:
#In situations where it is enough for either of the surrounding words to fulfill a criterion
thisSearch.prevornext['ison'] = True
thisSearch.Find()
logging.info('Search committed')
return thisSearch
16 17 18 25 26 27 34 35 36 43 44 45
46 47 48
49 50 51
52 53 54
The middle square for each side defines the color for that side
The facelet string must be in side order U, R, F, D, L, B
- Side U is Ye, replace all instances of Ye with U
- Side R is Rd, replace all instances of Rd with R
etc, etc
We are left with:
U = LLUFURFRF
R = RFBRRBLBU
F = UBDLFDDFD
D = RDFDDURRL
L = DURDLFBLB
B = LUBLBBFUU
Which you pass to Search.solution() as one big string
LLUFURFRFRFBRRBLBUUBDLFDDFDRDFDDURRLDURDLFBLBLUBLBBFUU
'''
parser = argparse.ArgumentParser()
parser.add_argument('facelet', help='Facelet string', default=None)
args = parser.parse_args()
cube = Search()
print cube.solution(args.facelet, maxDepth=21, timeOut=600, useSeparator='')
def test_create_search(self):
s = Search('used')
self.assertEqual('used', s.search_type)
self.assertListEqual([], s.cars)
def testInitlizeWithoutParams(self):
search = Search("ImportError: No module named")
self.assertNotEqual(len(search.results), 0)
print(search.results)
import os
import sys
from search import Search as sh
from whoosh.analysis import StemmingAnalyzer
from whoosh.fields import Schema,TEXT
address=input("enter the root file address: ")
files=os.listdir(address)
dir_name=input("enter the index dir name: ")
schema=Schema(title=TEXT(stored=True),content=TEXT(analyzer=StemmingAnalyzer()))
index_addr=os.path.join(address,dir_name)
ix=sh.create_index(index_addr,schema)
for file in files:
if(os.path.splitext(file)[1] == '.txt'):
file_address=os.path.join(address,file)
with open(file_address) as f:
line = f.readline()
while line:
info=line.split(" ")
key=info[0]+info[1]
sh.addDoc(ix,key,info[2])
line = f.readline()
def __init__(self, json_handler):
self.SEEK_search = Search(json_handler)
from datetime import date, timedelta
#parse the configuration file
config = ParseConfig("config.ini")
baseURL = config.retrieveBaseUrl()
apikey = config.retrieveApiKey()
#parse the user input file
userinput = ParseUserInput("userinput.json")
location = userinput.getLocation()
#check_in and chek_out date
check_in = date.today()
check_out = check_in + timedelta(1)
#create the request
userRequest = HotelAirportSearchRequest(apikey, location, check_in, check_out)
userRequest = userinput.setOptionalRequestParameters(userRequest)
#call search with the request and the base url
src = Search(baseURL)
print(src.getRequestURL(userRequest.getRequestParameters()))
#parse the response
rsp = HotelAirportSearchResponse(
src.getJsonResponse(userRequest.getRequestParameters()))
rsp.writeResponseOnFile("hotels_full_details.json")
rsp.writeMinDetailsResponseOnFile("hotels_min_details.json")
rsp.generateHtmlFromJsonResponse("hotels_min_details.html")
class Macro:
def __init__(self):
pyautogui.PAUSE = round(uniform(1.5, 2.3), 2)
self.listener = Listener()
self.search = Search()
self.bglistener = None
self.waypoints = []
self.end = False
def __repr__(self):
return f"{len(self.waypoints)} waypoint(s) in macro"
def _on_release(self, key):
if key == keyboard.Key.esc:
self.end = True
self.bglistener.stop()
print("Ending macro ...")
return False
def start(self):
self.end = False
self.bglistener = keyboard.Listener(on_release=self._on_release)
self.bglistener.start()
print("Macro started ...")
while not self.end:
for waypoint in self.waypoints:
while True:
is_success = self.moveTo(waypoint)
if is_success:
break
print("Macro ended ...")
def show_waypoints(self):
print(f"Current waypoints:")
print(f"---------------------------------")
for i in range(0, len(self.waypoints)):
print(f"{i} : {self.waypoints[i]}")
print(f"---------------------------------")
def delete_waypoint(self, index):
self.waypoints.pop(index)
print(f"---------------------------------")
for i in range(0, len(self.waypoints)):
print(f"{i} : {self.waypoints[i]}")
print(f"---------------------------------")
def add_waypoint(self):
region = self.listener.listen()
if not None in region:
image = self.search.find_image(region=region)
if image:
self.waypoints.append({
"position": (region[0], region[1]),
"box": (region[2], region[3]),
"image": image,
})
def moveTo(self, waypoint, random=True):
try:
pyautogui.PAUSE = round(uniform(1.5, 3.0), 2)
print(pyautogui.PAUSE)
if not random:
pyautogui.moveTo(waypoint["position"], duration=0.2)
if self.search.find_image(image=waypoint["image"]):
randX = randint(
waypoint["position"][0],
waypoint["position"][0] + waypoint["box"][0],
)
randY = randint(
waypoint["position"][1],
waypoint["position"][1] + waypoint["box"][1],
)
randPosition = (randX, randY)
pyautogui.moveTo(randPosition, duration=0.2)
return True
else:
print("\033[91mWaypoint image not found ...\033[0m")
return False
except:
pass
def main():
filename = 'open'
searchMethod = 'gbfs'
Maze,start,dst = readFile('data/'+ filename+'Maze.txt')
model = Search(Maze,start,dst)
if searchMethod == 'bfs':
model.search(h_bfs,None)
elif searchMethod == 'dfs':
model.search(h_dfs,None)
elif searchMethod == 'gbfs':
model.search(h_gbfs,f)
elif searchMethod == 'astar':
model.search(h_astar,f)
model.plot(filename,searchMethod)
def test_get_file_count(self):
s = Search()
file_locs = s.get_dirfiles()
self.assertEqual(3, len(file_locs),
"Failed to read all files from the directory")
__status__ = "In Development"
from ingest import IngestFile
from search import Search
from configparser import ConfigParser
import logging
logging.basicConfig(filename='run.log',
level=logging.DEBUG) # make config driven later
logging.info('---Start Run---')
config = ConfigParser()
config.read('melchior.conf')
igf = IngestFile()
isf = Search()
filename = 'somefile.txt' # temporary for testing purposes
try:
logging.info('Trying to load file:' + filename)
igf.loadFile(filename)
logging.info('Successfully loaded file:' + filename)
except my:
print("failed to load file")
"""
wordset = ['goat','success','Please','smite','Conan','how']
score = 0
wt = 1 # this is temporary
for word in wordset:
