class DatabaseCursor:
def __init__(self):
# Services
self.__logger = Logger()
self._path_service = PathService()
self._configurator = Configurator()
self._exceptions_handler = ExceptionsHandler()
# Data
self._wd = os.getcwd()
self._request_url = None
self.databases_public_keys = None
self.__logger.info('DatabaseCursor was successfully initialized.',
__name__)
def _load_config(self):
path_to_config = os.path.join(self._path_service.path_to_configs,
'database_cursor.json')
if os.path.exists(path_to_config):
with open(path_to_config, 'r', encoding='utf-8') as file:
config = json.load(file)
self._request_url = config['request_url']
self.databases_public_keys = config['database_public_keys']
else:
self.__logger.error(
"Can't load config for DatabaseCursor (doesn't exist).",
__name__)
def __update_connection(self, ngram):
path_to_db = None
if ngram.count(' ') == 0:
path_to_db = self._path_service.get_path_to_database('unigrams.db')
elif ngram.count(' ') == 1:
path_to_db = self._path_service.get_path_to_database('bigrams.db')
elif ngram.count(' ') == 2:
path_to_db = self._path_service.get_path_to_database('trigrams.db')
if path_to_db and os.path.exists(path_to_db):
self.__logger.info(f'Connected to database: {path_to_db}',
__name__)
return sqlite3.connect(path_to_db)
else:
self.__logger.warning(f'Database lost: {path_to_db}', __name__)
self.__logger.info('Trying to download database from cloud...',
__name__)
self._configurator.download_database(path_to_db)
self.__logger.info(f'Connected to database: {path_to_db}',
__name__)
if os.path.exists(path_to_db):
return sqlite3.connect(path_to_db)
else:
self.__logger.fatal("Database doesn't exist.", __name__)
def get_entry(self, ngram):
connection = self.__update_connection(ngram)
cursor = connection.cursor()
request = ("""
SELECT * FROM 'Data' WHERE Ngram='%s'
""") % ngram
self.__logger.info(f'Request to DB: {request.strip()}', __name__)
try:
cursor.execute(request)
self.__logger.info('Request is OK.', __name__)
except BaseException as exception:
connection.close()
self.__logger.error(
self._exceptions_handler.get_error_message(exception),
__name__)
return
result = cursor.fetchone()
self.__logger.info(f'Received data: {str(result)}', __name__)
if result:
connection.close()
return result[1], result[2]
else:
connection.close()
def entry_exists(self, ngram):
connection = self.__update_connection(ngram)
cursor = connection.cursor()
request = ("""
SELECT * FROM 'Data' WHERE Ngram='%s'
""") % ngram
self.__logger.info(f'Request to DB: {request.strip()}', __name__)
try:
cursor.execute(request)
self.__logger.info('Request is OK.', __name__)
except BaseException as exception:
connection.close()
self.__logger.error(
self._exceptions_handler.get_error_message(exception),
__name__)
return
if cursor.fetchone():
connection.close()
self.__logger.info('Entry exists.', __name__)
return True
else:
connection.close()
self.__logger.info("Entry doesn't exist.", __name__)
return False
class Configurator(metaclass=Singleton):
def __init__(self):
# Services
self.__logger = Logger()
self._path_service = PathService()
self._exceptions_handler = ExceptionsHandler()
# Data
self._config = dict()
self._wd = os.getcwd()
self._path_to_databases = None
self._request_url = None
self._vector_model_public_key = None
self._databases_public_keys = None
self._load_public_keys()
self.__logger.info('Configurator was successfully initialized.',
__name__)
def _load_public_keys(self):
path_to_config = os.path.join(self._path_service.path_to_configs,
'configurator.json')
if os.path.exists(path_to_config):
with open(path_to_config, 'r', encoding='utf-8') as file:
config = json.load(file)
self._request_url = config['request_url']
self._vector_model_public_key = config['vector_model_public_key']
self._databases_public_keys = config['databases_public_keys']
else:
self.__logger.error(
"Can't load config for Configrurator (doesn't exist).",
__name__)
def download_database(self, path_to_db):
database_name = os.path.split(path_to_db)[1]
if database_name:
try:
download_url = requests.get(
self._request_url,
params={
'public_key':
self._databases_public_keys[database_name]
}).json()["href"]
with open(path_to_db, 'wb') as database_file:
database_file.write(requests.get(download_url).content)
self._config[path_to_db] = 'downloaded'
except BaseException as exception:
self.__logger.error(
self._exceptions_handler.get_error_message(exception),
__name__)
self._config[path_to_db] = 'error'
def download_vector_model(self):
self._path_service.set_path_to_vector_model(
os.path.join(self._path_service.path_to_databases,
'ruscorpora_upos_skipgram_300_10_2017.bin.gz'))
try:
download_url = requests.get(self._request_url,
params={
'public_key':
self._vector_model_public_key
}).json()["href"]
with open(self._path_service.path_to_vector_model,
'wb') as vec_model:
vec_model.write(requests.get(download_url).content)
self._config[
'ruscorpora_upos_skipgram_300_10_2017.bin.gz'] = 'downloaded'
except BaseException as exception:
self.__logger.error(
self._exceptions_handler.get_error_message(exception),
__name__)
self._config[
'ruscorpora_upos_skipgram_300_10_2017.bin.gz'] = 'error'
def configure_system(self):
self._config['datetime'] = str(datetime.now())
for database in ['unigrams.db', 'bigrams.db', 'trigrams.db']:
path_to_database = self._path_service.get_path_to_database(
database)
if not path_to_database or not os.path.exists(path_to_database):
self.__logger.warning('Database not found: %s' % str(database),
__name__)
self.download_database(
os.path.join(self._path_service.path_to_databases,
database))
else:
self._config[database] = 'exists'
if not self._path_service.path_to_vector_model or not os.path.exists(
self._path_service.path_to_vector_model):
self.__logger.warning('Vector model not found.', __name__)
self.download_vector_model()
else:
self._config[
'ruscorpora_upos_skipgram_300_10_2017.bin.gz'] = 'exists'
self._create_config()
def _create_config(self):
with open(os.path.join('Logs', 'config.json'), 'w',
encoding='utf-8') as config:
json.dump(self._config, config, indent=4)