def sign_in():
# Checking the request
data = request.get_json()
if "email" not in data or "pass" not in data:
abort(400, {"message": "Mandatory information missing"})
# Getting the user with the specified email
user = CommonUser.query.filter_by(email=data['email']).first()
if not user or not user.verify_password(data['pass']):
abort(403, {'message': 'User not found'})
# Creating token
token = Token(user.generate_auth_token())
token.user = user
# Deleting previous token
Token.query.filter_by(uid=user.id).delete()
# Inserting token into database
db_session.add(token)
db_session.commit()
# Sending response
return jsonify(token=token.token)
def __init__(self, input_string, literals):
self.literals = dict([(literal.text, literal) for literal in literals])
self.input = input_string
self.index = 0
self.len = len(input_string)
self.prev_token = None
self.first_free_memory = 0
self.symbol_table = [{
'output':
Token('ID', 0, self.literals['ID'], DataType.VOID,
DeclarationType.FUNCTION,
[Token('ID', -1, self.literals['ID'], DataType.INTEGER)])
}]
self.malloc(1) # reserve for output function
def build_groups(normalized_tokens: List[Token], method: Method,
convergence: float) -> Dict[str, Token]:
groups = dict()
while len(normalized_tokens) > 0:
group_key = normalized_tokens.pop(0)
group_variants = [group_key]
for i in range(len(normalized_tokens) - 1, -1, -1):
score = method.score(w1=normalized_tokens[i].term,
w2=group_key.term)
if score >= convergence:
group_token = normalized_tokens.pop(i)
group_token.convergence = score
group_variants.append(group_token)
group_value = sum((x.value for x in group_variants))
group_value = group_value / float(len(group_variants))
groups[group_key.term] = Token(term=group_key.term,
value=group_value)
return groups
def read_file(filename: str, delimiter: str = ';') -> Iterator[Token]:
with open(filename, mode='r') as terms:
reader = csv.reader(terms, delimiter=delimiter)
for row in reader:
token, value = row
yield Token(term=token, value=value)
def return_token(self, text, attr, lexeme):
data_type = None
if self.prev_token is not None:
if self.prev_token.text in ['void', 'int']:
data_type = self.prev_token.text
t = Token(text, attr, self.literals[text], data_type, lexeme=lexeme)
self.prev_token = t
assert isinstance(t, Token)
return t
def search_contexts_in_file(filename: str, token: Token) -> Token:
contexts = []
with open(filename, mode='r') as datafile:
reader = csv.reader(datafile, delimiter='.')
try:
for row in reader:
#print("row: ", row)
if token.term in str(row):
#print("row: ", row)
clean_row = remove_stop_words(row[0])
#print("clean_row: ", clean_row)
contexts.append(clean_row)
except Exception as e:
print("")
#print("Exception read: ",e)
#print("contexts: ", contexts)
return Token(term=token.term,
value=token.value,
convergence=token.convergence,
contexts=contexts)
def token(request, validated={}, *args, **kwargs):
if request.method == 'GET':
tokens = Token.objects.all()
if validated['active'] is not None:
tokens = tokens.filter(is_active=validated['active'])
if not request.user.is_superuser:
tokens = tokens.filter(owner=request.user)
output = []
for t in tokens:
perms = Permission.objects.all(
) if t.is_supertoken else t.permissions
output.append({
'id':
t.id,
'owner':
t.owner.id,
'created_at':
t.created_at,
'active':
t.is_active,
'due':
t.due,
'permissions': [
"{}.{}".format(p.content_type.app_label, p.codename)
for p in perms
]
})
return output
else:
token = Token()
token.is_active = validated['active']
token.due = None
if validated['due']:
token.due = timezone.make_aware(
datetime.datetime.fromtimestamp(validated['due']))
token.owner = request.user
base = Permission.objects.all()\
.annotate(encoded=F('content_type__model') + '.' + F('codename'))\
.filter(encoded__in=request.user.get_all_permissions())\
.order_by('content_type__model')
exceptions = []
perms = []
for perm in validated['permissions']:
perm = perm.split('.')
p = base.filter(content_type__model=perm[0], codename=perm[1])
if not p:
exceptions.append('.'.join(perm))
perms.extend(p)
if exceptions:
return {
'info':
'You are trying to assign permissions you do not have yourself.',
'affects': exceptions
}, 403
token.save()
token.permissions.set(perms)
token.save()
def get_token(self, text, attribute):
for literal in self.all_literals:
if literal.text == text:
return Token(text, attribute, literal)
def normalize(tokens: Iterator[Token]) -> Iterator[Token]:
max_score = max((token.value for token in tokens))
for token in tokens:
yield Token(term=token.term, value=token.value / max_score)
def log_user_out(token):
# Delete the given Session token
token = Token.query(Token.value == token, ancestor=get_blog_key()).get()
if token:
token.key.delete()
def log_user_in():
# Create a Session token and return it's value
new_token = Token(parent=get_blog_key())
new_token.put()
return new_token.value
def valid_auth_cookie(token_value):
# Validate our token, make sure a User exists
token = Token.query(Token.value == token_value, ancestor=get_blog_key()).get()
if token:
token.refresh()
return bool(token)
def clean_session_tokens():
# Remove expired Tokens
ndb.delete_multi(Token.query(Token.expires < int(time.time())).fetch(keys_only=True))