def get_movie_recomendation():
global response
data = request.get_json(silent=True, force=True)
try:
if data['queryResult']['action'] == str('id_usuario'):
## GET USER
user = int(data['queryResult']['parameters']['id_usuario'])
## GET RECOMMENDATION
get_movie_user = Filtering()
response = get_movie_user.get_rec_movie(user)
response = response.replace("{'", "")
response = response.replace("'}", "")
response = response.replace("', '", " | ")
elif data['queryResult']['action'] == str('movies'):
## GET MOVIE
movie = data['queryResult']['parameters']['movie']
## GET RECOMENDATION
get_movie = Recom()
response = get_movie.obten_recomendacion(movie)
response = response.replace("['", "")
response = response.replace("']", "")
response = response.replace("', '", " | ")
except:
response = "En este momento no puedo entregarte una recomendación, intenta nuevamente"
reply = {"fulfillmentText": response}
return jsonify(reply)
def compare(self):
""" Test a suspicious document for near-duplicate plagiarism with regards to
a source document and return a feature list.
"""
ps = []
detections = []
susp_sent = []
for i in range(len(self.susp_bow)):
for j in range(len(self.src_bow)):
alza_sim = Seeding.alzahrani_similarity(self.susp_bow[i], self.src_bow[j], self.model)
if alza_sim > self.th1:
# print "***"
# print alza_sim
# print self.susp_bow[i]
# print self.src_bow[j]
ps.append((i, j))
# extend faza
(plags, psr) = Extension.integrate_cases(ps, self.src_gap, self.susp_gap, self.src_size, self.susp_size)
(plags2, psr2) = Extension.integrate_cases(ps, self.src_gap + 20, self.susp_gap + 20, self.src_size, self.susp_size)
plags = Extension.similarity3(plags, psr, self.src_bow, self.susp_bow, self.src_gap, self.src_gap_least, self.susp_gap,
self.susp_gap_least, self.src_size, self.susp_size, self.th3, self.model)
plags2 = Extension.similarity3(plags2, psr2, self.src_bow, self.susp_bow, self.src_gap + 20, self.src_gap_least,
self.susp_gap + 20, self.susp_gap_least, self.src_size, self.susp_size, self.th3, self.model)
plags = Filtering.remove_overlap3(self.src_bow, self.susp_bow, plags, self.model)
plags2 = Filtering.remove_overlap3(self.src_bow, self.susp_bow, plags2, self.model)
sum_src = 0
sum_susp = 0
for plag in plags2:
arg1 = (self.src_offsets[plag[0][0]][0], self.src_offsets[plag[0][1]][0] + self.src_offsets[plag[0][1]][1])
arg2 = (
self.susp_offsets[plag[1][0]][0], self.susp_offsets[plag[1][1]][0] + self.susp_offsets[plag[1][1]][1])
sum_src = sum_src + (arg1[1] - arg1[0])
sum_susp = sum_susp + (arg2[1] - arg2[0])
if sum_src >= 3 * sum_susp:
for plag in plags2:
arg1 = (
self.src_offsets[plag[0][0]][0], self.src_offsets[plag[0][1]][0] + self.src_offsets[plag[0][1]][1])
arg2 = (
self.susp_offsets[plag[1][0]][0], self.susp_offsets[plag[1][1]][0] + self.susp_offsets[plag[1][1]][1])
if arg1[1] - arg1[0] >= self.min_plaglen and arg2[1] - arg2[0] >= self.min_plaglen:
detections.append([arg1, arg2])
else:
for plag in plags:
arg1 = (
self.src_offsets[plag[0][0]][0], self.src_offsets[plag[0][1]][0] + self.src_offsets[plag[0][1]][1])
arg2 = (
self.susp_offsets[plag[1][0]][0], self.susp_offsets[plag[1][1]][0] + self.susp_offsets[plag[1][1]][1])
if arg1[1] - arg1[0] >= self.min_plaglen and arg2[1] - arg2[0] >= self.min_plaglen:
detections.append([arg1, arg2])
return detections
def _fit(raw_data, debug_mode=False):
"""Fits a single dictionary of raw data.
This function is meant to be passed as an argument
to multiprocessing map.
:param raw_data: a dictionary of raw data parameters
:returns: a dictionary of fitted parameters
"""
lags = create_lag_list(raw_data)
# We check number of averages < 0 since this will cause invalid
# division in the noise calculation
if raw_data['nave'] <= 0:
noise_pwr = 1.0
else:
raw_data['nave']
noise_pwr = NoisePower.acf_cutoff_pwr(raw_data)
range_list = []
#num_ranges_with_data = len(raw_data['slist'])
for idx, range_number in enumerate(raw_data['slist']):
if raw_data['pwr0'][range_number] != 0:
new_range = Range(idx, range_number, raw_data, lags)
range_list.append(new_range)
Filtering.filter_tx_overlapped_lags(raw_data, lags, range_list)
Filtering.filter_inf_lags(range_list)
Filtering.filter_low_pwr_lags(raw_data, range_list)
Filtering.filter_bad_acfs(raw_data, range_list, noise_pwr)
ACFFitting.acf_pwr_fitting(range_list)
ACFFitting.calculate_phase_and_elev_sigmas(range_list, raw_data)
ACFFitting.acf_phase_unwrap(range_list, raw_data)
ACFFitting.acf_phase_fitting(range_list)
Filtering.filter_bad_fits(range_list)
ACFFitting.xcf_phase_unwrap(range_list)
ACFFitting.xcf_phase_fitting(range_list)
#if debug_mode:
#debug_output(range_list)
determined_parameters = Determinations(raw_data, range_list, noise_pwr)
return determined_parameters.paramater_dict
def __init__(self, channel_len, sampling_freq, hp_thresh, lp_thresh,
notch_thresh):
Saving.__init__(self)
Filtering.__init__(self, sampling_freq, hp_thresh, lp_thresh,
notch_thresh)
self.data_orig = []
self.data_processed = []
self.buffer_process = []
self.loc_start = []
self.loc_start_orig = []
self.__flag_start_bit = 165
self.__flag_end_bit = 90
self.__flag_sync_pulse = [0, 255]
self.__sample_len = 25
self.__channel_len = channel_len
self.__sync_pulse_len = 1
self.__counter_len = 1
self.__ring_column_len = self.__channel_len + self.__sync_pulse_len + self.__counter_len
self.filter_obj = [
Filtering(sampling_freq, hp_thresh, lp_thresh, notch_thresh)
for __ in range(self.__channel_len)
]
def OnSearch(self, event):
matchlist = cf.top_match(cf, loadDict() , '사용자')
ch = 0
gap = -20
fr = wx.Frame(parent=None, title="음식 추천 순위", size=(320, 200))
fr.pnl = wx.Panel(fr)
for m in matchlist:
gap += 20
ch += 1
hl.HyperLinkCtrl(fr.pnl, -1, m[1], pos=(30, 20 + gap), URL=findURL(m[1]))
fr.Centre()
fr.Show(True)
def run_provider(provider, payload, method):
""" Provider thread entrypoint
Args:
provider (str): Provider ID
payload (dict): Search payload from Elementum
method (str): Type of search, can be ``general``, ``movie``, ``show``, ``season`` or ``anime``
"""
log.debug("[%s] Processing %s with %s method" %
(provider, provider, method))
filterInstance = Filtering()
if method == 'movie':
filterInstance.use_movie(provider, payload)
elif method == 'season':
filterInstance.use_season(provider, payload)
elif method == 'episode':
filterInstance.use_episode(provider, payload)
elif method == 'anime':
filterInstance.use_anime(provider, payload)
else:
filterInstance.use_general(provider, payload)
if 'is_api' in definitions[provider]:
results = process(provider=provider,
generator=extract_from_api,
filtering=filterInstance,
has_special=payload['has_special'],
skip_auth=payload['skip_auth'])
else:
results = process(provider=provider,
generator=extract_torrents,
filtering=filterInstance,
has_special=payload['has_special'],
skip_auth=payload['skip_auth'])
got_results(provider, results)
timing = time.monotonic()
def t() -> str: return "%ds" % int(time.monotonic() - timing)
if len(sys.argv) != 6:
sys.stderr.write('Usage: %s <start_ts> <days> <router> <directory> <dbfile>\n' % sys.argv[0])
sys.exit(1)
if sys.argv[1].lower() == 'now':
start_ts = dt.now()
else: start_ts = dt.strptime(sys.argv[1], "%Y-%m-%d %H:%M")
days = int(sys.argv[2])
router = sys.argv[3]
directory = sys.argv[4]
db_file = sys.argv[5]
pid = os.getpid()
print(pid, t(), router, 'load data from file %s' % repr(db_file), flush = True)
storage = Storage(db_file, accounts, directory, False)
reports = AccountsReport(lnames, accounts, storage)
print(pid, t(), router, 'calculate account usage', flush = True)
account_usage: Dict[str, Dict[p.Account, p.Usage]] = {}
for limit_name in lnames:
account_usage[limit_name] = reports.account_usage(start_ts, router, limit_name)
print(pid, t(), router, 'configure firewall', flush = True)
filtering = Filtering(lnames, accounts, account_usage)
filtering.filter(directory, storage.rest_adds)
print(pid, t(), router, 'firewall configured.')
def run_provider(provider, payload, method):
""" Provider thread entrypoint
Args:
provider (str): Provider ID
payload (dict): Search payload from Quasar
method (str): Type of search, can be ``general``, ``movie``, ``show``, ``season`` or ``anime``
"""
log.debug("Processing %s with %s method" % (provider, method))
filterInstance = Filtering()
if method == 'movie':
filterInstance.use_movie(provider, payload)
elif method == 'season':
filterInstance.use_season(provider, payload)
elif method == 'episode':
filterInstance.use_episode(provider, payload)
elif method == 'anime':
filterInstance.use_anime(provider, payload)
else:
filterInstance.use_general(provider, payload)
if 'is_api' in definitions[provider]:
results = process(provider=provider, generator=extract_from_api, filtering=filterInstance)
else:
results = process(provider=provider, generator=extract_torrents, filtering=filterInstance)
got_results(provider, results)
def calculate_info(initial_string, icsd, dim, delta):
print(icsd, dim)
initial_string = initial_string.rstrip()
if dim == 0:
for i in range(11):
initial_string += ";-1"
else:
delta = up_delta
g = open(
"cif_files/data_" + icsd + "-ICSD.cif", "r"
) #assuming all cif files are present in the cif_files folder with that particular format
cif_file = g.read()
g.close()
cif_file = re.sub(r"[^\x00-\x7F]", "",
cif_file) #remove non-ascii characters
cif_file = re.sub(
r"(\(\d+)(\s|\n)", r"\1\)\2",
cif_file) #close any open brackets (throws an error otherwise)
structure = CifParser.from_string(
cif_file,
occupancy_tolerance=100).get_structures(primitive=False)[0]
filtering = Filtering(structure)
filtering.form_neighbor_list()
G = filtering.define_bonds(delta)
delta_check = filtering.check_for_delta(G, dim)
layers_angles_stuff = filtering.calculate_layers_angles_and_stuff(
G, dim)
while not delta_check:
delta = delta - 0.1
if (delta >= low_delta):
G = filtering.define_bonds(delta)
delta_check = filtering.check_for_delta(G, dim)
else:
break
if delta < low_delta:
layers_angles_stuff = filtering.calculate_layers_angles_and_stuff(
filtering.define_bonds(up_delta), dim)
initial_string += ";" + str(up_delta)
else:
layers_angles_stuff = filtering.calculate_layers_angles_and_stuff(
G, dim)
initial_string += ";" + str(delta)
for stuff in layers_angles_stuff[:-2]:
initial_string += ";" + str(stuff)
# bonded lattice
bonded_lattice = {}
for key, value in layers_angles_stuff[-2].items():
points_distorted = value
coord_no = str(layers_angles_stuff[3][key])
if coord_no in points_perfect:
bonded_lattice[key] = {}
for i in range(len(points_perfect[coord_no])):
bonded_lattice[key][lattices[coord_no][i]] = str(
np.round(symmetry_measure(
points_distorted,
points_perfect[coord_no][i])["symmetry_measure"],
decimals=1))
else:
bonded_lattice[key] = -1
# magnetic metal lattice
metal_neigh_lattice = {}
for key, value in layers_angles_stuff[-1].items():
points_distorted = value
coord_no = str(layers_angles_stuff[7][key])
if coord_no in metal_points_perfect:
metal_neigh_lattice[key] = {}
metal_neigh_lattice[key][metal_lattices[coord_no]] = str(
np.round(symmetry_measure(
points_distorted,
metal_points_perfect[coord_no])["symmetry_measure"],
decimals=1))
else:
metal_neigh_lattice[key] = -1
initial_string += ";" + str(bonded_lattice) + ";" + str(
metal_neigh_lattice)
f = open("results_" + str(os.getpid()) + ".txt", "a")
print(initial_string)
f.write(initial_string + "\n")
f.close()
def clear_text(text):
filtering = Filtering()
return filtering.get_feature_vector(filtering.process_text(text))
def test_stopwords(self):
text = "again MacOS win Neco"
filtering = Filtering()
result = filtering.get_feature_vector(filtering.process_text(text))
self.assertNotIn("again", result)
def test_process_text(self):
filtering = Filtering()
text = "WHAT'A LOVELY DAY"
after_text = "what'a lovely day"
result = filtering.process_text(text)
self.assertEqual(after_text, result)
