def __init__(self, vk_session, event, keyboard):
self.db = DataBase(data.database['host'], data.database['username'],
data.database['password'],
data.database['database'], data.database['port'])
self.vk_api = vk_session
self.event = event
self.cursor, self.connection = self.db.connect()
self.keyboard = keyboard
def returnPrediction(nameCompany):
ticker = companyTicker[nameCompany]
database = DataBase()
toreturn = {}
toreturn['prediction'] = database.getPredictedClose(ticker)
return toreturn
def run(self):
connection = DataBase().connection()
cursor = connection.cursor()
cursor.execute("truncate collections.bms_showtimes")
connection.commit()
print DataBase().showtimesCountQuery
cursor.execute(DataBase().showtimesCountQuery)
count = cursor.fetchall()
count = count[0][0]
limit = 1
start = 1
stop = 2000
loopCount = 2000
try:
limit = count / loopCount
except:
limit = 15
pass
for i in range(0, limit + 1):
t = threading.Thread(target=self.bms_showtime_count,
args=("thread_name_" + str(i), start, stop))
t.start()
start = stop + 1
stop = start + loopCount - 1
try:
connection.close()
print "Initial Connection Closed"
except:
print "Initial connection Not closed"
def run(self):
connection = DataBase().connection()
cursor = connection.cursor()
cursor.execute(DataBase().trunk_ticket_info)
connection.commit()
cursor.execute(DataBase().ssidcountquery)
count = cursor.fetchall()
count = count[0][0]
print "data==", count
limit = 1
start = 0
stop = 100
loopCount = 100
try:
limit = count / loopCount
except:
limit = 15
pass
print "no of threads==", limit + 1
for i in range(0, limit + 1):
t = threading.Thread(target=self.bms_ssid_count,
args=("thread_name_" + str(i), start, stop))
t.start()
start = start + 100
stop = 100
try:
connection.close()
print "Initial Connection Closed"
except:
print "Initial connection Not closed"
def test_general_search_works(self, mock_new_books):
with mock.patch.object(DataBase.Database, "__init__",
lambda x: None) as mock_db:
mock_new_books.find.return_value = []
self.assertEqual(DataBase.Database().general_search({}), ([], 200))
self.assertEqual(DataBase.Database().general_search("socorro"),
('filter must be an instance of dict, '
'bson.son.SON, or any other type that '
'inherits from collections.Mapping', 500))
def run(self):
connection = DataBase().connection()
cursor = connection.cursor()
# cursor.execute("truncate moviesfyi_stage.bk_movies")
connection.commit()
cursor.execute(DataBase().showtimesCountQuery)
count = cursor.fetchall()
count = count[0][0]
print "data==", count
limit = 1
start = 1
stop = 300
loopCount = 300
try:
limit = count / loopCount
except:
limit = 15
pass
print "no of threads==", limit + 1
for i in range(0, limit + 1):
t = threading.Thread(target=self.bms_movie_count,
args=("thread_name_" + str(i), start, stop))
t.start()
start = stop + 1
stop = start + loopCount - 1
try:
connection.close()
print "Initial Connection Closed"
except:
print "Initial connection Not closed"
def books_by_rating():
"""
A função é chamada na página inicial do front-end quando acessado o site.
:return: tuple, response com a lista de livros ordenada pelas avaliações (estrelas)
"""
response = DataBase.Database().books_by_rating()
return Controller.search.data_treatment(response)
def test_search_by_id_works(self, mock_new_books, mock_conn):
with mock.patch.object(DataBase.Database, "__init__",
lambda x: None) as mock_db:
mock_new_books.find.return_value = []
self.assertEqual(
DataBase.Database().search_by_id("609ec0b6d2334d102f6561bb"),
([], 200))
def save_movie(self, nombre: Movie): # ----> Busca una película
movie_new = APIMovie().getMovie(nombre)
#if movie_new == None:
#print("No existe")
#else:
DataBase().saveMovie(movie_new) #Guardar en la base de datos
def search_movie(self, name:str): # ----> Busca una película y pregunta si quiere guardar
#movie_new = APIMovie().getMovie(name)
movie_titles = APIMovie().get_movie_titles(name)
if movie_titles == None:
print("No se encontro la informacion")
else:
print("Se encontraon los siguientes resultados: \n")
for i in range(len(movie_titles)):
print(movie_titles[i])
n = False
while n == False:
print("¡¡Mi loco!!, escoge el nombre de una película y vuelve a hacer la busqueda sí quieres guardarla :D\n")
op = int(input("Teclea 1 para hacer la busqueda de nuevo y guardarla Ó teclea 2 para regresar al menu:\n"))
if op == 1:
new_name = str(input("Cual fue la película que escogiste? \n"))
new_search = APIMovie().getMovie(new_name) #Se crea el objeto con la película nueva
DataBase().saveMovie(new_search) #Guardar en la base de datos
print("Pelicula guardada, hasta luego :D")
n = True
elif op == 2:
n = True
#print("Al menu")
else:
print("Elige una opcion del menu")
def books_by_released():
"""
A função é chamada na página inicial do front-end quando acessado o site.
:return: tuple, response com a lista de livros ordenada pela data de publicação.
"""
response = DataBase.Database().latest_books_released()
return Controller.search.data_treatment(response)
def books_by_string_search():
"""
A função recebe do front-end uma string digitada pelo usuário e realiza a busca no db.
:return: tuple, response com a lista de livros que contém a busca digitada no front-end
"""
string_search = request.args['search']
log_for_search.generate_log_from_search_engine(
{"string_search": string_search})
response = DataBase.Database().books_by_string_search(string_search)
return Controller.search.data_treatment(response)
def ticketsinfo(self, starts, stops):
connection = DataBase().connection()
cursor = connection.cursor()
date = datetime.date.today()
date = str(date)
date = date.replace("-", "")
query = ""
# print date
seats_ssid = "SELECT theater_code ,showdate,showtime,sessionid FROM collections.bms_showtimes where showdate =CURDATE() AND STR_TO_DATE(showtime,'%l:%i %p') BETWEEN SUBTIME(ADDTIME(current_time(),'5:30:00.00'),5900) AND ADDTIME(ADDTIME(current_time(),'5:30:00.00'),5900) group by sessionid limit " + str(
starts) + " , " + str(stops)
print seats_ssid
cursor.execute(seats_ssid)
results = cursor.fetchall()
# print "length======================================================================================",len(results)
for j in results:
print j[0]
url = "https://in.bookmyshow.com/serv/getData?cmd=GETSHOWINFO&vid=" + j[
0] + "&ssid=" + str(j[3])
print url
r = requests.get(url)
data = r.text
val = ""
myjson = json.loads(data.replace("arrShowInfo=", "")[:-1])
# print "length==",len(myjson)
for mjson in range(len(myjson)):
try:
tid = myjson[mjson][0]
ssid = myjson[mjson][1]
tc_class = myjson[mjson][2]
t_class = myjson[mjson][3]
price = myjson[mjson][4]
screen_name = myjson[mjson][33]
m = myjson[mjson].index(date)
l = myjson[mjson][m:]
totalseats = l[2]
availableseats = l[3]
val = val + "('" + tid + "','" + screen_name + "'," + "'" + ssid + "'," + "'" + tc_class + "'," + "'" + t_class + "'," + "'" + price + "'," + "'" + totalseats + "'," + "'" + availableseats + "'),"
except:
"DNA"
val = val[:-1]
query = DataBase().seats_info + val
# print query
try:
cursor.execute(query)
connection.commit()
if cursor.lastrowid:
print('last insert id', cursor.lastrowid)
else:
print('last insert id not found')
connection.commit()
except:
print query
def show_all_movies(self): # ----> Muestra todas las películas guardadas en la BDD
moviesList = DataBase().showAllMovies()
#if moviesList == "" or moviesList == None:
# print("Aún no hay datos guardados")
#else:
#print("Películas guardadas: \n")
#for item in moviesList:
# print(item)
# print("\n")
print( moviesList)
def show_a_movie(self, name:str): # ----> Muestra una película que esta guardada en la BDD
moviesList = DataBase().showMovie(name)
#if moviesList == "" or moviesList == None: #if name Not in movielist
# print("No existe esta película en la base de datos :(\n")
#else:
#print("Película encontrada: \n")
#for item in moviesList:
# print(item)
# print("\n")
print(moviesList)
def getBmsShowTimes(self, starts, stops):
connection = DataBase().connection()
cursor = connection.cursor()
sql = "SELECT id,theater_url from collections.bms_theaters where theater_url is not null and id between " + str(
starts) + " and " + str(stops)
cursor.execute(sql)
results = cursor.fetchall()
date = datetime.date.today()
date = str(date)
date = date.replace("-", "")
movies_ins = ""
count = 0
for j in results:
testurl = j[1]
url = j[1]
da = "https://in.bookmyshow.com"
url = da + url
r = requests.get(url)
data = r.text
soup = BeautifulSoup(data)
query = ""
list = ""
for list in soup.find_all('a', href="javascript:;"):
try:
list = list['onclick']
if ("blnVistaCine" in list):
list = list
list = list.split("callSeatLayout(")
teatinfo = list[1].split(")")
teatinfo = teatinfo[0].split(",")
theater_code = teatinfo[0]
sessionid = teatinfo[1]
movie_code = teatinfo[2]
showtime = teatinfo[3]
date = date
query = query + "(" + movie_code + ",''," + theater_code + ",''," + "'y','" + date + "'," + showtime + "," + "'y'," + sessionid + "),"
except:
""
query = query[:-1]
insquery = DataBase().show_time_ssid + query
try:
cursor.execute(insquery)
connection.commit()
except:
""
connection.close()
def generate_log_from_search_engine(filters: dict):
"""
A função recebe os itens pesquisados e registra no log de buscas
:param filters: itens pesquisados pelo usuário
:return: True
"""
search = filters.copy()
try:
search["user_id"] = filters["user_id"]
search["created_at"] = datetime.now()
except:
search["created_at"] = datetime.now()
execute = DataBase.Database().search_history.insert_one(search)
if execute.inserted_id:
return True
class MyTest(unittest.TestCase):
myScraper = Scraper()
myDb = DataBase('avatar.db')
collectordb = CollectorDB('collector.db')
imageCorrection = ImageCorrection()
edge_detection = EdgeDetection()
image_warper = ImageWarper()
image_hasher = ImageHasher()
test_image = cv2.imread("warped.jpg")
second_test = cv2.imread("ow.jpg")
def test(self):
# test collector string
self.assertEqual(self.collectordb.check_game("Grand Theft Auto V"),
"Grand Theft Auto V")
# second test
self.assertNotEqual(self.collectordb.check_game("Grand Theft Auto V"),
"Tekken 7")
# checking hamming distance calculation
self.assertEqual(
self.myDb.ham_dst("2d2ec9e064603833", "2d2ec9e064603833"), 0)
self.assertEqual(
self.myDb.ham_dst("2d2bf9e56460f833", "2d2ec9e064603836"), 5)
# no two images should have same hash
self.assertEqual(self.image_hasher.generate_hash(self.test_image),
"2f6c71b19336322a")
self.assertNotEqual(self.image_hasher.generate_hash(self.second_test),
"2f6c71b19336322a")
# retrieving from db should always be a list
self.assertIsInstance(self.myDb.fetch_hash("2d2ec9e064603836"), list)
# cv2 should return images
self.assertIsInstance(self.edge_detection.canny_edge(self.second_test),
np.ndarray)
self.assertTrue(
self.myDb.ham_dst("9897f4b0f0cc0ef8", "dd9237b0704c4ed9"))
def get_all_searches():
response = DataBase.Database().get_history_searches()
return Controller.search.data_treatment(response)
def delete_movie(self, name): # ----> Borra una película que esta guardada en la BDD by ID
moviesList = DataBase().deleteMovie(name)
__author__ = 'Q'
from Database import DataBase
db = DataBase("summer2014courses.db")
print("-------------Assignments---------------------")
db.display_table_by_date("Assignments")
print("-------------Readings------------------------")
db.display_table_by_date("Readings")
print("-------------Tests------------------------")
db.display_table_by_date("Tests")
db.close()
from pony.orm import *
from Database import DataBase
db = DataBase.get_database()
class City(db.Entity):
id = PrimaryKey(int, auto=True)
city_id = Required(int)
name = Required(str)
weather = Set("Weather")
# ---- Query
@staticmethod
@db_session
def get_all():
return select(p for p in City)[:]
@staticmethod
@db_session
def get_by_id(city_id):
city = select(c for c in City if c.city_id == city_id)[:][0]
return city
@staticmethod
@db_session
def get_by_name(name):
city = select(c for c in City if c.name == name)[:][0]
return city
@staticmethod
from Database import DataBase
import numpy
import datetime
try:
id_log = DataBase.callFunction('get_max_id_log')
if id_log[0][0] == None:
id_log = [[0]]
id_res = DataBase.callFunction('get_max_id_slau')
if id_res[0][0] == None:
id_res = [[0]]
max_id = max(id_res[0][0], id_log[0][0]) + 1
except Exception as error:
print(f'Error of calling database procedure: {error}!')
exit(1)
print('Enter file name: ', end='')
FileName = input()
try:
file = open(FileName, 'r')
except BaseException:
print(f'Error opening file {FileName}!')
exit(1)
matrix = []
for line in file:
tm_line = line.split(' ')
tm_arr = []
for item in tm_line:
if not item.isspace() and (item != ''):
# The script is supposed to be run by daemon to collect the weather data for the city
from ApiClient import ApiClient
from config import CONFIG
from Database import DataBase
from models.City import City
from models.Weather import Weather
from utils import unix_to_datetime
import json
db = DataBase()
db.generate()
def request_weather(city):
apiClienet = ApiClient(CONFIG['appid'], city.city_id)
response = apiClienet.weather()
response = json.loads(response.text)
# Save weather to DB if entry for this time does not exist
if len(Weather.get_by_unix(response['dt'])) == 0:
weather_entry = Weather.save(city_id=city.city_id,
desc=response['weather'][0]['main'],
temp_max=response['main']['temp_max'],
temp_min=response['main']['temp_min'],
pressure=response['main']['pressure'],
humidity=response['main']['humidity'],
visibility=response['visibility'],
wind_speed=response['wind']['speed'],
dt=response['dt'])
print("Entry for time {} added successfully".format(
cv2.waitKey(0)
elif name is not "":
myScraper.scrape_game(search_query, name)
except IndexError:
font = cv2.FONT_HERSHEY_COMPLEX
colour = (0, 0, 0)
cv2.putText(frame, 'No game found ', (9, 28), font, 0.55, colour, 2,
cv2.LINE_AA)
if __name__ == '__main__':
# initiate web scraping object
myScraper = Scraper()
# avatar database access object
myDb = DataBase('avatar.db')
# collector database object
collectordb = CollectorDB('collector.db')
# image correction object
imageCorrection = ImageCorrection()
# edge detection object
edge_detection = EdgeDetection()
# image warping object
image_warper = ImageWarper()
# image hashing object
image_hasher = ImageHasher()
# root for Tk object
root = Tk()
topframe = Frame(root)
topLabel = Label(root, text="What would you like to do?")
topLabel.grid(row=0, column=0)
class commands_scripts:
def __init__(self, vk_session, event, keyboard):
self.db = DataBase(data.database['host'], data.database['username'],
data.database['password'],
data.database['database'], data.database['port'])
self.vk_api = vk_session
self.event = event
self.cursor, self.connection = self.db.connect()
self.keyboard = keyboard
def __send_message(self, message, event, user_id):
self.vk_api.messages.send(peer_id=event.obj.message['from_id'],
user_id=user_id,
random_id=get_random_id(),
message=message,
keyboard=self.keyboard)
def abort(self, user_id):
self.db.set_user_state(user_id, 0)
self.__send_message("Я тебя понял, уже отменяю!", self.event, user_id)
if not self.db.get_user_city(user_id):
self.cursor.execute("""UPDATE `user_info`
SET UserCity=NULL, UserRegion=NULL
WHERE UserID={}""".format(user_id))
self.connection.commit()
def add_city(self, user_id):
self.db.set_user_state(user_id, 1)
self.__send_message("Пожалуйста, введи свой город.", self.event,
user_id)
def city_info(self, user_id):
city_info = self.db.get_user_city(user_id)
if city_info:
self.__send_message(
"Город: {}\nРегион: {}".format(city_info[0], city_info[1]),
self.event, user_id)
else:
self.__send_message(
"Ты еще не ввёл свой город. Нажми на кнопку \"Добавить город\"",
self.event, user_id)
def clear_keyboard(self, user_id):
self.__send_message("Клавиатура очищена", self.event, user_id)
def help(self, user_id):
self.__send_message(
"Хочешь добавить город? Жми на кнопку \"Добавить Город\"\n"
"Если ты это уже сделал, то кликни на кнопку \"Погода\"\n"
"Ну, а есди ты вдруг забыл какой город ты ввёл, "
"то спроси у меня, я с радостью тебе помогу, "
"Для этого просто намекни мне нажав \"Мой город\" и я тебе обязательно отвечу. \n"
"Если вдруг справка тебе не помогла, то смело @ferunelli(пиши сюда)",
self.event, user_id)
def hello(self, user_id, user_name):
self.__send_message(
"Привет, {}! \n"
"Я рад, что ты со мной.".format(user_name), self.event, user_id)
def input_city(self, user_id, message):
if message == "отмена":
self.abort(user_id)
else:
with self.cursor as cursor:
cursor.execute("""UPDATE `user_info`
SET UserCity='{}'
WHERE UserID={}""".format(
message.capitalize(), user_id))
self.connection.commit()
self.__send_message(
"Пожалуйста, введи свой регион "
"(А чтобы мне было проще искать, регион должен быть в формате RU, UA, US и т.д.)",
self.event, user_id)
self.db.set_user_state(user_id, 2)
def input_region(self, user_id, message):
if message == "отмена":
self.abort(user_id)
else:
with self.cursor as cursor:
check_weather = weather(self.db.get_user_city(user_id)[0],
data.API,
region=message)
if check_weather.check():
cursor.execute("""UPDATE `user_info`
SET UserRegion='{}'
WHERE UserID={}""".format(
message.upper(), user_id))
self.connection.commit()
self.__send_message(
"Я запомнил, где ты живешь ;-) "
"Я с радостью расскажу тебе про погоду в твоём городе, если ты напишешь"
"\"Погода\"", self.event, user_id)
self.db.set_user_state(user_id, 0)
else:
self.__send_message(
"К сожалению я не смог найти никаких городов с такими данными :-(\n"
"Попробуй ввести другие.", self.event, user_id)
cursor.execute("""UPDATE `user_info`
SET UserCity=NULL, UserRegion=NULL
WHERE UserID={}""".format(user_id))
self.connection.commit()
self.db.set_user_state(user_id, 0)
def start(self, user_id, user_name):
state = self.db.add_user_to_bd(user_id, user_name)
if state:
self.__send_message(
"Привет, {}, ты тут новенький!".format(user_name) +
"Я умею показывать погоду в твоём городе."
"Для начала введи команду \"Добавить Город\", чтобы я знал, какой город тебе интересен.",
self.event, user_id)
else:
self.__send_message(
"Если тебе нужна справка по командам, то введи \"Помощь\"\n"
"Я с радостью тебе всё расскажу :-)", self.event, user_id)
def weather(self, user_id):
city_info = self.db.get_user_city(user_id)
if city_info:
current = weather(city_info[0], data.API, region=city_info[1])
weather_now = current.get_weather_now()
beginning = [
"Что ж, готовься читать, я принес тебе много информации.\n Начнем с того, что",
"В общем,", "Что ж,", "Итак, ",
"Ну поехали, я набрал информацию и теперь готов тебе её доложить,"
]
text = random.choice(beginning) + \
" максимум температура поднимется до {} градусов, " \
"в среднем будет где-то {}. Скорость ветра может быть около {} км/ч, " \
"а влажность будет в районе {}%. " \
"Будет {}. ".format(weather_now['temp_max'],
(weather_now['temp'] + weather_now['temp_min']) / 2,
weather_now['wind_speed'], weather_now['humidity'],
weather_now['weather'])
end = ""
# Погода - температура
if abs(weather_now['temp_max'] - weather_now['temp_min']) > 10:
end = "Скачок между температурами будет немаленький, поэтому будь предусмотрительным и возьми с собой " \
"вещей и на ту и на другую температуру. "
elif weather_now['temp_min'] < -10:
end += "Сегодня очень холодно, оденься как можно теплее. "
elif -10 <= weather_now['temp'] < 0:
end += "Сегодня холодновато. Ухх. Без куртки никак не выйдешь. "
elif 0 <= weather_now['temp'] <= 10:
end += "Эх, я бы не сказал, что очень жарко, надо надеть куртку. Если что, снимешь. "
elif 10 < weather_now['temp'] < 20:
end += "В целом, тепло, но я бы посоветовал тебе что-то с собой прихватить. "
elif weather_now['temp'] > 20:
end += "Достаточно жарко, я бы пошел в футболке. "
# Влажность
if 35 < weather_now['humidity'] < 60:
end += "Думаю, стоит сегодня взять зонт или хотя бы плащ. "
elif weather_now['humidity'] > 60:
end += "Не забудь взять с собой зонт. "
elif 15 < weather_now['humidity'] < 35:
end += "Вот даже не знаю, советовать ли тебе брать зонт." \
" В целом, вероятность дождя не такая уж и большая. "
# Ветер
if weather_now['wind_speed'] > 20:
end += "Также сегодня будет сильный ветер, будь очень аккуратен"
self.__send_message(text + end, self.event, user_id)
else:
self.__send_message(
"К сожалению я ничего пока про тебя не знаю :-(\n"
"Введи команду \"Добавить город\" и расскажи немного о себе.",
self.event, user_id)
def test_latest_books_released_works(self, mock_new_books):
with mock.patch.object(DataBase.Database, "__init__",
lambda x: None) as mock_db:
mock_new_books.find.return_value = []
self.assertEqual(DataBase.Database().latest_books_released(),
([], 200))
import ast
from Database import DataBase
from flask import jsonify
database = DataBase.Database()
def general_search(filters: dict) -> tuple:
"""
Função que valida os dados enviados pelo front-end, conforme filtros selecionados, levando em consideração o formato
das informações (dicionario(s), lista, string) e também se o preço foi filtrado ou não.
:param filters: filtros selecionados pelo usuário
:return: list, result com a lista de livros filtrados
"""
if filters == {}:
return [], 400
price = ""
query = ""
try:
filters['category']
query = "{ '$and': [ { '$or': [ "
for filter in filters:
if isinstance(filters[filter], dict):
if filter == "price":
price += "]} , { '$and' : [{" + "'item_price': { '$gte' :" + f"{filters[filter]['min']}" + "}}, " \
"{" + "'item_price': { '$lte' :" + f"{filters[filter]['max']}" + "}} ] }"
else:
def selected_book():
book_id = request.args["product_id"]
response = DataBase.Database().search_by_id(book_id)
return Controller.search.data_treatment(response)
import data
from Database import DataBase
from vk_server import vk_server
import vk_api
import pymysql
db = DataBase(data.database['host'], data.database['username'],
data.database['password'], data.database['database'],
data.database['port'])
while True:
try:
vk = vk_server(data.vk_token, data.bot_id, db)
vk.start()
except vk_api.exceptions.ApiError:
print("Неверно указаны данные для работы Бота")
break
except pymysql.err.OperationalError:
print("Неверно указаны данные для работы с БД")
break
except:
continue
def test_books_by_string_search_works(self, mock_new_books):
with mock.patch.object(DataBase.Database, "__init__",
lambda x: None) as mock_db:
mock_new_books.find.return_value = []
self.assertEqual(
DataBase.Database().books_by_string_search("Pedro"), ([], 200))
