def match_genres(self) -> Tuple[List[str], float]:
db_genres = self.db_user.genres
current_genres = self.current_user.genres
high_impact_db = dict()
for (key, value) in db_genres.items():
if value > 3:
high_impact_db[key] = value
high_impact_current = dict()
for (key, value) in current_genres.items():
if value > 3:
high_impact_current[key] = value
genres_intersection = list(set(
high_impact_db.keys()).intersection(
high_impact_current.keys()))
total_genres = min(
len(high_impact_db.keys()),
len(high_impact_current.keys())) or 1
logger.debug(len(genres_intersection))
return (genres_intersection, len(genres_intersection) / total_genres * 100)
async def update_one(
self,
*,
table: str,
criteria: dict,
**new_values: dict,
) -> dict:
try:
update = {"$set": new_values}
logger.debug(f"Update one: {criteria} to {update} -> {table}")
result = await self._db[table].find_one_and_update(
filter=criteria,
update=update,
return_document=ReturnDocument.AFTER,
)
logger.debug(f"Update one result: {result}")
return result
except pymongo.errors.DuplicateKeyError as exp:
duplicate_value = exp.details["keyValue"]
raise exceptions.BaseException_(
status_code=exceptions.DuplicateValue.status_code,
detail=f"Duplicate Value: {duplicate_value}",
)
def _split_long_sentences(self, sentences):
"""Split long sentences.
Args:
sentences (list): list of flair's Sentences
Returns:
list:
"""
extended = sentences.copy()
tokenizer = self.model.embeddings.tokenizer
offset = 0
for i, sentence in enumerate(sentences):
len_bpe = len(tokenizer.tokenize(sentence.to_tokenized_string()))
if len_bpe > self.max_length:
extended.pop(i + offset)
num_pieces = len_bpe // self.max_length + 1
for piece in array_split(sentence, num_pieces):
char_offset = piece[0].start_pos
sentence_piece = Sentence()
for token in piece:
token.start_pos -= char_offset
token.end_pos -= char_offset
sentence_piece.add_token(token)
piece[-1].whitespace_after = False
extended.insert(i + offset, sentence_piece)
offset += 1
# we pop original sentence, so we should decrease offset by one
offset -= 1
logger.debug(f'Lengths before split: {[len(x) for x in sentences]}')
logger.debug(f'Lengths after split: {[len(x) for x in extended]}')
return extended
def wrap(*ags, **kwargs):
logger.debug('START: {}'.format(name))
t = Timer()
rv = func(*ags, **kwargs)
duration = t.stop()
logger.debug('Done: {} sec'.format(duration))
return rv
def static_from_root():
logger.debug('ROBOTS FLASK_CONFIG: %s', app.config['STAGING'])
if app.config['PRODUCTION']:
path = os.path.join('static', 'robots.txt')
return redirect(path, code=302)
else:
path = os.path.join('static', 'block_robots.txt')
return redirect(path, code=302)
async def delete_one(self, *, table: str, **criteria: dict) -> bool:
logger.debug(f"Delete One: {criteria} -> {table}")
result = await self._db[table].delete_one(filter=criteria)
logger.debug(
f"Delete one Result: {result.acknowledged} deleted: {result.deleted_count}"
)
return result.deleted_count == 1
async def read_one(
self,
table: str,
**criteria: dict,
) -> dict:
logger.debug(f"Read One: {criteria} -> {table}")
result = await self._db[table].find_one(filter=criteria)
logger.debug(f"Read one result: {result}")
return result
async def insert_one(self, document: dict, *, table: str) -> str:
logger.debug(f"Insert One: {document} -> {table}")
try:
return str((await
self._db[table].insert_one(document)).inserted_id)
except pymongo.errors.DuplicateKeyError as exp:
duplicate_value = exp.details["keyValue"]
raise exceptions.BaseException_(
status_code=exceptions.DuplicateValue.status_code,
detail=f"Duplicate Value: {duplicate_value}",
)
def response(self, request):
X = request.get_json()['text']
start = time()
result, score = self.predict_paragraph(X)
end = time()
result = result.replace('_', ' ')
logger.debug(f'time - {end - start}s')
logger.debug(result)
return json.dumps({
'label': result,
'confidence': score,
'heading_num': result.split(' ')[0]
}), 200
def search_api(year):
MAX_RESULTS = 300
raw_query = request.args.get('query')
if not raw_query or raw_query == '0':
return jsonify({
'error': 'Invalid Query Param',
'results': [],
'query': raw_query,
'total_results': 0
})
final_query = process_query(raw_query)
final_query_pat = re.compile(final_query, re.IGNORECASE)
logger.debug('Raw Search Query: ' + str(raw_query))
logger.debug('Final Search Query: ' + str(final_query_pat))
results = search_db(pattern=final_query_pat, field='title')
if not results:
return jsonify({
'error': 'No Results',
'results': [],
'target_year': year,
'query': raw_query
})
sorted_results = sorted(results, key=lambda k: k['title'])
prioritized_results = prioritize_match(results=sorted_results,
raw_query=raw_query,
field='title')
total_results = len(prioritized_results)
truncated = False
if total_results > MAX_RESULTS:
prioritized_results = prioritized_results[:MAX_RESULTS]
truncated = True
return jsonify({
'results': prioritized_results,
'target_year': year,
'query': raw_query,
'total_results': total_results,
'max_results': MAX_RESULTS,
'truncated': truncated
})
async def get_current_user(token: str = Depends(oauth2_scheme),
db: Session = Depends(get_db),
spotify_oauth: SpotifyOAuth = Depends(
get_spotipy_oauth),
response: Response = Depends(get_responce)) -> User:
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
try:
payload = jwt.decode(token,
os.getenv('ACCESS_KEY'),
algorithms=[ALGORITHM])
payload_id: str = payload.get("spotify_id")
if payload_id is None:
raise credentials_exception
# token_data = TokenData(spotify_id=payload_id)
except JWTError:
raise credentials_exception
user = get_user(db, payload_id)
if user is None:
raise credentials_exception
payload_expires: str = payload.get("spotify_expires")
is_token_expired = float(payload_expires) - datetime.now().timestamp() < 0
if is_token_expired:
auth_creds = refresh_spotify(user.refresh_token, spotify_oauth)
logger.debug("AUTH", auth_creds)
user_creds = UserBase(access_token=auth_creds["access_token"],
refresh_token=auth_creds["refresh_token"],
token_expires=auth_creds["expires_at"])
user = update_user(db, user.spotify_id, cast(UserUpdate, user_creds))
access_token = create_access_token(
data=TokenData(spotify_id=user.spotify_id,
spotify_expires=user.token_expires - 600).dict(),
expires_delta=ACCESS_TOKEN_EXPIRE_MINUTES)
response.headers['authorization'] = f"Bearer {access_token}"
response.headers['Access-Control-Expose-Headers'] = 'authorization'
return user
def handle_request(request):
"""
Entrypoint of the Alexa requests. Route POST request by request type to appropriate package to handle.
:type request: AlexaRequest
:param request: incoming Alexa request
:return: Generated JSON response answer
"""
logger.debug(f"request intent={request.intent_name()} received: {request.request}")
if request.request_type() == "LaunchRequest":
return handle_launch(request)
elif request.request_type() == "IntentRequest":
return handle_intent(request)
elif request.request_type() == "Dialog.Delegate":
return handle_intent(request)
elif request.request_type() == "SessionEndedRequest":
return handle_end(request)
else:
raise UnknownRequestError(request.request_type())
def prioritize_match(results=None, raw_query=None, field=None):
"""If Search query matches title exactly (no fuzzy or space forgiveness)
result is pushed up to top of list
"""
try:
exact_query = '^{query}$'.format(query=raw_query)
pattern = re.compile(exact_query, re.IGNORECASE)
except Exception as errmsg:
logger.error(
'prioritize: Could not compile raw_query: {}'.format(exact_query))
return results
prioritized_results = []
for member in results:
if re.match(pattern, member.get(field)):
prioritized_results.insert(0, member)
logger.debug('Priority Match Found: {}'.format(pattern))
else:
prioritized_results.append(member)
# import pdb; pdb.set_trace()
return prioritized_results
async def read_many(
self,
table: str,
offset: Optional[int] = None,
limit: Optional[int] = None,
**criteria,
) -> list[dict]:
logger.debug(f"Read many: {criteria} -> {table}")
params = {}
if offset is not None:
params.update({"skip": offset})
if limit is not None:
params.update({"limit": limit})
result = [
doc async for doc in self._db[table].find(criteria, **params)
]
logger.debug(f"Read many result: {result}")
return result
def response(self, request):
X = request.get_json()['X']
start = time()
result = self.predict_paragraph(X)
end = time()
logger.debug("Prediction was made.")
logger.debug(f'time - {end - start}s')
logger.debug(result)
return json.dumps({'y': result, 'time': end - start}), 200
compress = Compress()
flasks3 = FlaskS3()
cache = Cache()
toolbar = DebugToolbarExtension()
flask_config = os.environ['FLASK_CONFIG']
logger.info('** FLASK_CONFIG: {}'.format(flask_config))
app.config.from_object('app.config.{}'.format(flask_config))
compress.init_app(app)
flasks3.init_app(app)
cache.init_app(app)
toolbar.init_app(app)
if bool(int(os.getenv('CACHE_CLEAR', 0))):
cache.clear()
logger.info('** Cached cleared [CLEAR_CACHE] True')
# ASSETS
assets = Environment(app)
assets.register('css_assets', css_assets)
assets.register('js_assets', js_assets)
assets.register('js_api_assets', js_api_assets)
logger.debug('ASSETS DEBUG: {}'.format(assets.debug))
logger.debug('FLASK S3 ACTIVE: {}'.format(app.config['FLASKS3_ACTIVE']))
logger.debug('FLASK S3 ASSETS ACTIVE: {}'.format(app.config['FLASK_ASSETS_USE_S3']))
from app import views, seo_response, errors
from app import assets
# //Init DB session
import uuid
from cassandra.cqlengine.models import Model
from cassandra.cqlengine.management import sync_table
from cassandra.cqlengine import (columns, connection)
from app.utils.logger import logger
from app.config import settings
logger.info('Connecting to database...')
logger.debug('Contact points:')
logger.debug(settings.database.hosts)
"""USER MODELS"""
class User_by_id_Model(Model):
__table_name__ = "user_by_id"
user_id = columns.UUID(primary_key=True, default=uuid.uuid4, required=True)
username = columns.Text(required=True)
srp_salt = columns.Text(required=True)
srp_verifier = columns.Text(required=True)
kek_salt = columns.Text(required=True)
cek = columns.Text(required=True)
class User_by_username_Model(Model):
__table_name__ = "user_by_username"
username = columns.Text(primary_key=True, required=True)
user_id = columns.UUID(required=True)
async def count(self, *, table: str) -> int:
logger.debug(f"Count -> {table}")
return await self._db[table].estimated_document_count()
import os
from fastapi import FastAPI
from app.utils.logger import logger
import app.routers
api = FastAPI()
logger.debug('Initializing routers...')
api.include_router(app.routers.auth.router)
def __init__(self, model=None, lang=True, max_length=None):
self.model = TextClassifier.load(model)
self.tokenizer = tokenizers[lang]
logger.debug(f"Classifier was loaded. {model}")
