def __init__(self):
self.lastkeytime = 0
self.listbox = False
self.listwalker = False
self.consolemonitor = False
self.edit = False
self.getApiClient()
self.autocomplete = Autocomplete(self)
def test_assignment_example04():
"""Testing with the example vocabulary."""
from autocomplete import Autocomplete
vocabulary = [
'fix', 'fax', 'fit', 'fist', 'full', 'finch', 'final', 'finial'
]
complete_me = Autocomplete(vocabulary, 4)
assert complete_me('finally') == []
def setUp():
auto = Autocomplete("university")
auto.del_index()
with open("data", "r") as f:
for num, line in enumerate(f, 1):
item = {"uid": num, "score": 1000 - num, "term": line}
print item
auto.add_item(item)
def test_initilize_from_filename(self):
testfile = os.path.abspath('test/input.json')
a = Autocomplete(filename=testfile)
a.rebuild_index()
results = a.search_query(u'你 轻轻')
self.assertEqual(len(results), 2)
self.assertEqual(results[0]['id'], '1')
self.assertEqual(results[1]['id'], '2')
def setUp (self):
self.items=[{"uid":'1', "score":9, "term": u"轻轻地你走了"},
{"uid":'2', "score":10, "term": u"正如你轻轻地来"},
{"uid":'3', "score":8.5, "term":u"你挥一挥衣袖，不带走一片云彩"},
]
self.a=Autocomplete("scope")
self.a.del_index()
for item in self.items:
self.a.add_item (item)
def setUp(self):
self.items=['{"score": "9", "id": "1", "title": "轻轻地你走了"}', \
'{"score": "8", "id": "2", "title": "正如你轻轻地来"}', \
'{"score": "8.5", "id": "3", "title": "你挥一挥衣袖，不带走一片云彩"}']
self.index_mapping = {
'term': 'title',
'id': 'id',
}
self.a = Autocomplete(jsonitems=self.items, mapping=self.index_mapping)
self.a.rebuild_index()
def autocomplete_api(word):
start_time = time.time()
autocomplete = Autocomplete(word)
j, status = autocomplete.get_json()
num_results = autocomplete.get_num_results()
elapsed_time = time.time() - start_time
logging.debug(
f"/autocomplete for '{word}': {num_results} results, time: {elapsed_time:.2f}s"
)
return json_answer_status(j, status)
def test_index_mapping(self):
self.index_mapping = {
'term': lambda x: x.get('title') + x.get('id'),
'id': 'id',
}
self.a = Autocomplete(jsonitems=self.items, mapping=self.index_mapping)
self.a.rebuild_index()
results = self.a.search_query(u'1')
self.assertEqual(len(results), 1)
self.assertEqual(results[0]['id'], '1')
results = self.a.search_query(u'2')
self.assertEqual(len(results), 1)
self.assertEqual(results[0]['id'], '2')
def autocompleteData(string):
list1 = []
list_dict = []
count = 0
if dict_data.get(string):
for index in dict_data[string]:
if count < 5:
list_dict.append({"index": index, "score": 2*len(string)})
count = count+1
if count < 5:
changeInput(string, count, list_dict)
else:
changeInput(string, count, list_dict)
i = 0
for dict in list_dict:
if i < 5:
i = i+1
list1.append(Autocomplete(listString[dict["index"]]["sentence"],
dictFile[listString[dict["index"]]["source"]],
listString[dict["index"]]["offset"], dict["score"]))
return list1
def setUp(self):
self.items = [
{
"uid": '1',
"score": 9,
"term": u"Alex"
},
{
"uid": '2',
"score": 10,
"term": u"Piter"
},
{
"uid": '3',
"score": 8.5,
"term": u"Alexey"
},
]
self.a = Autocomplete("scope")
self.a.del_index()
for item in self.items:
self.a.add_item(item)
def to_expanded(self):
if not self.expanded_cards:
self.expanded_cards = card_fetcher.fetch(False)
self.format = Format.EXPANDED
self.entry = Autocomplete(self.card_names(), selected, root, width = 40)
self.entry.grid(row=0, column=0)
left_padding = 10
root = tk.Tk()
root.title("Pokemon TCG Prize Cam")
create_menu(root)
# a little more than width and height of image
w = (photo_width + left_padding) * 2
h = (photo_height + top_padding) * 3 + 40
x = 80
y = 100
# use width x height + x_offset + y_offset (no spaces!)
root.geometry("%dx%d+%d+%d" % (w, h, x, y))
start_time = dt.now()
state.entry = Autocomplete(state.card_names(), selected, root, width = 40)
state.entry.grid(row=0, column=0)
button = tk.Button(root, text = "Reset Prizes", command = reset_cards, width=35)
button.grid(row=0, column=1)
state.backphoto = get_back_photo()
state.takenphoto = get_taken_photo()
for row in range(1, 4):
for col in range(2):
pc = PrizeCard(tk.Button(root, image=state.backphoto))
pc.button.configure(command=lambda r = row, c = col: prize_click(r, c))
state.PrizeCards.append(pc)
redraw_cards()
root.resizable(False, False)
root.mainloop()
def to_standard(self):
self.format = Format.STANDARD
self.entry = Autocomplete(self.card_names(), selected, root, width = 40)
self.entry.grid(row=0, column=0)
from flask_cors import CORS
from flask_caching import Cache
from connection_pool import ConnectionPool
from autocomplete import Autocomplete
import engine
app = Flask(__name__)
CORS(app)
# tell Flask to use the above defined config
app.config['CACHE_TYPE'] = 'simple'
app.cache = Cache(app)
# creat connection pool object
connection_pool = ConnectionPool()
title_autocomplete = Autocomplete()
@app.cache.memoize(timeout=100)
def get_similar_titles(query):
return title_autocomplete.get_similar_titles(query)
def get_full_recommendations_data(recs):
result = []
# buffered=True allows to read the result as buffered
db_connection = connection_pool.get_pool_connection()
cursor = db_connection.cursor(buffered=True)
for movie in recs:
sql = """ SELECT * FROM full_movies_data WHERE title = %s """
cursor.execute(sql, (movie, ))
def __init__(self, json_dir):
self.json_dir = json_dir
self.index_letters = 0
self.search = Search()
self.autocomplete = Autocomplete()
self.indexletter = IndexLetter()
def long_dict_very_big_max():
"""A trie filled with words from the short dictionary, max_compl = 7."""
return Autocomplete(long_dictionary, max_completions=15)
def test_error_if_not_string():
"""Test that you get a TypeError if you try to input a nonstring."""
with pytest.raises(TypeError):
Breakit = Autocomplete([1, 2, 3])
def short_dict_big_max():
"""A trie filled with words from the short dictionary, max_compl = 7."""
return Autocomplete(short_dictionary, max_completions=7)
def long_dict_trie():
"""A trie filled with words from the short dictionary."""
return Autocomplete(long_dictionary)
def main():
startup.startup()
ac = Autocomplete()
app.run(host="localhost", port=5000)
def test_setup02():
"""Confirming property works.."""
from autocomplete import Autocomplete
words = ['ant', 'an', 'antennae', 'anno', 'antagonize']
t = Autocomplete(words)
assert t('a') == ['an', 'ant', 'antennae', 'antagonize', 'anno']
# implementation adapted from https://www.acmesystems.it/python_http
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse, parse_qs
from autocomplete import Autocomplete
import json
PORT_NUMBER = 8080
ac = Autocomplete(load=True)
# This class will handles any incoming request from
# the browser
class AutocompleteServer(BaseHTTPRequestHandler):
# Handler for the GET requests
def do_GET(self):
query = urlparse(self.path).query
query_components = parse_qs(urlparse(self.path).query)
if "q" in query_components:
phrase = query_components["q"][0]
results = json.dumps(
{"Completions": ac.generate_completions(phrase)})
print(results)
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(results.encode())
print("END OF REQUEST")
from autocomplete import Autocomplete
import sys, os
if __name__ == "__main__":
ac = Autocomplete('test.txt')
while True:
user_input = raw_input("Enter input: ").strip('\n')
if ac.is_word(user_input):
print "lol it's a word"
else:
print ac.closest_word(user_input)
if user_input == ':q':
sys.exit(0)
def test_setup01():
"""Making sure the foundation is solid."""
from autocomplete import Autocomplete
words = ['ant', 'banana', 'fruit', 'queen']
t = Autocomplete(words)
assert t.vocab.contains('ant')
from flask.json import jsonify
from autocomplete import Autocomplete
import startup as startup
import pypiscraper as pypiscraper
app = Flask(__name__)
@app.route("/package_info")
def package_info():
return jsonify(pypiscraper.get_meta(request.args["pkg_name"]))
@app.route("/autocomplete")
def autocomplete():
return jsonify(ac.search(request.args["word"]))
def main():
startup.startup()
ac = Autocomplete()
app.run(host="localhost", port=5000)
if __name__ == "__main__":
startup.startup()
ac = Autocomplete()
app.run(host="localhost", port=5000)
import tornado.ioloop
import tornado.web
import tornadoredis
from tornadoredis import Client as Redis
from tornado import gen
import json
from autocomplete import Autocomplete
CONNECTION_POOL = tornadoredis.ConnectionPool(max_connections=500,
wait_for_available=True)
auto = Autocomplete("university")
class RankApp(tornado.web.Application):
"""docstring for RankApp"""
def __init__(self, arg):
super(RankApp, self).__init__()
self.arg = arg
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hello, world")
class SearchHandler(tornado.web.RequestHandler):
@tornado.web.asynchronous
@gen.engine
def get(self):
