def router(path: str, token):
view = _get_view(path)
if view.login_required:
try:
token = Manager(Token).get(token=token)
except DoesNotExistsError:
raise UnauthenticatedError()
customer = Manager(Customer).get(pk=token.customer)
view.customer = customer
return view
def post(self, data):
if not self.customer.has_valid_subscription():
return self.response({"error": "no valid subscription"})
plan = Manager(Plan).get(pk=self.customer.plan)
websites = Manager(Website).filter(customer=self.customer)
if len(websites) >= int(plan.number_of_websites):
return self.response(
{"error": "maximum number of websites for your plan"})
if "url" not in data:
return self.response({"error": "missing website url"})
website = Website(url=data["url"], customer=self.customer.pk)
website.save()
return self.response({"website": website.pk})
def test_success(self):
data = {"name": "name", "password": "******", "email": "email"}
view = RegisterView()
response = view.post(data).decode("utf-8")
response = json.loads(response)
self.assertTrue("uid" in response)
Manager(Customer).get(pk=response["uid"])
def run_adverserial():
voca = load_voca()
manager = Manager(max_sequence=100, word_indice=voca,
batch_size=args.batch_size, num_classes=3,
vocab_size=1000, embedding_size=300, lstm_dim=1024)
# Dev acc=0.6576999819278717 loss=0.8433943867683411
# manager.load("hdrop2/model-41418")
manager.load("hdrop/model-42952")
manager.run_adverserial(voca)
def delete(self):
website = Manager(Website).get(pk=self.kwargs["pk"])
if website.customer.pk != self.customer.pk:
return self.response({"error": "Not allowed"})
website.delete()
return self.response({"deleted": "website deleted"})
def post(self, data):
password = data.get("password", "")
customer: Customer = Manager(Customer).get(email=self.kwargs["email"])
if customer.verify_password(password):
token = Token(customer=customer.pk, token=str(uuid4()))
token.save()
return self.response({"token": token.token})
else:
return self.response({"error": "Invalid password"})
def test_login(self):
password = "******"
self.customer.set_password(password)
self.customer.save()
view = LoginView(email=self.customer.email)
response = view.post({"password": password}).decode("utf-8")
response = json.loads(response)
self.assertTrue("token" in response)
token = Manager(Token).get(token=response["token"])
self.assertEqual(token.customer, self.customer.pk)
def test_filter(self):
self.TestModel(test_field="instance1").save()
self.TestModel(test_field="instance2").save()
self.TestModel(test_field="instance2").save()
results = Manager(self.TestModel).filter(test_field="instance2")
self.assertEqual(2, len(results))
for x in results:
self.assertIsInstance(x, self.TestModel)
def train_cafe():
voca = load_voca()
args.char_vocab_size = load_char_length()
model = Manager(max_sequence=100, word_indice=voca,
batch_size=args.batch_size, num_classes=3, vocab_size=1000,
embedding_size=300, lstm_dim=1024)
data = models.common.load_pickle("train_corpus.pickle")
validate = models.common.load_pickle("dev_corpus")
epochs = 30
model.train(epochs, data, validate)
def view_weights():
voca = load_voca()
manager = Manager(max_sequence=100, word_indice=voca,
batch_size=args.batch_size, num_classes=3,
vocab_size=1000, embedding_size=300, lstm_dim=1024)
# Dev acc=0.6576999819278717 loss=0.8433943867683411
manager.load("wattention/model-12272")
validate = models.common.load_pickle("dev_corpus")
manager.view_weights(validate)
def make_user(type,
name,
surname,
middle_name,
password=None,
worker_type=None,
login=None,
ean13=None):
if type == UserType.MANAGER:
if not login or not password:
return None
user = User()
user.type = UserType.MANAGER
user.name = name
user.surname = surname
user.middle_name = middle_name
user.manager = Manager()
user.manager.login = login
user.manager.password = (hashlib.sha256(
(password +
config['secure']['salt_password']).encode()).hexdigest())
user.manager.save()
user.save()
user.db_session.commit()
print('Created manager {0} {1} with login {2}.'.format(
name, surname, login))
return user
else:
if not ean13 or not worker_type:
return None
user = User()
user.type = UserType.WORKER
user.name = name
user.surname = surname
user.middle_name = middle_name
user.worker = Worker()
user.worker.type = worker_type
user.worker.ean13 = ean13
user.worker.password = Worker.generate_worker_password()
user.worker.save()
user.save()
user.db_session().commit()
print('Created {0} {1} {2} with ean13 {3}.'.format(
worker_type.name.swapcase(), name, surname, ean13))
return user
def lrp_run():
voca = load_voca()
manager = Manager(max_sequence=100, word_indice=voca,
batch_size=args.batch_size, num_classes=3,
vocab_size=1000, embedding_size=300, lstm_dim=1024)
# Dev acc=0.6576999819278717 loss=0.8433943867683411
manager.load("hdrop2/model-41418")
validate = models.common.load_pickle("dev_corpus")
# manager.view_lrp(validate, reverse_index(voca))
# manager.lrp_3way(validate, reverse_index(voca))
manager.lrp_entangle(validate, models.common.reverse_index(voca))
def train_keep_cafe():
voca = load_voca()
manager = Manager(max_sequence=100, word_indice=voca,
batch_size=args.batch_size, num_classes=3,
vocab_size=1000, embedding_size=300, lstm_dim=1024)
# Dev acc=0.6576999819278717 loss=0.8433943867683411
data = models.common.load_pickle("train_corpus.pickle")
validate = models.common.load_pickle("dev_corpus")
manager.load("model-15340")
manager.train(20, data, validate, True)
def patch(self, data):
website = Manager(Website).get(pk=self.kwargs["pk"])
if website.customer.pk != self.customer.pk:
return self.response({"error": "Not allowed"})
if "url" not in data:
return self.response({"error": "missing website url"})
website.url = data["url"]
website.save()
return self.response({"success": "website updated"})
def test_save(self):
with tempfile.TemporaryDirectory() as tmpdir:
settings.data_dir = Path(tmpdir)
value = "test4321"
model = self.TestModel(test_field=value)
model.save()
pk = model.pk
loader.clear_cache()
self.assertEqual(loader.data, {})
loaded_model = Manager(self.TestModel).get(pk=pk)
self.assertEqual(loaded_model.test_field, value)
def test_delete(self):
with tempfile.TemporaryDirectory() as tmpdir:
settings.data_dir = Path(tmpdir)
value = "test4321"
model = self.TestModel(test_field=value)
model.save()
pk = model.pk
model.delete()
loader.clear_cache()
self.assertEqual(loader.data, {})
with self.assertRaises(DoesNotExistsError):
Manager(self.TestModel).get(pk=pk)
def post(self, data):
if verify_payment(data["payment_token"]):
plan_pk = data["plan"]
try:
Manager(Plan).get(pk=plan_pk)
except DoesNotExistsError:
return self.response({"error": "Plan does not exist"})
self.customer.plan = plan_pk
today = dt.date.today()
ends = dt.date(year=today.year + 1,
month=today.month,
day=today.day)
self.customer.subscription = ends.strftime("%Y/%m/%d")
self.customer.save()
return self.response({"success": "subscribed"})
else:
return self.response({"error": "payment failed"})
def save_managerdata(id):
the_document = Employee.query.filter(
Employee.id == id).order_by("id desc").first()
reply = request.form.get('reply')
manager_form = Manager(
reply=reply,
emp_table_id=the_document.id,
IP_addr=request.remote_addr,
Location=request.form.get('location'),
UserAgent=request.user_agent.browser,
OperatingSystem=request.user_agent.platform,
Time=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
)
db.session.add(manager_form)
db.session.commit()
utils.send_manager_link_as_mail(
email=email,
emp_code1=emp_code1,
)
return redirect('/success')
def post(self, data):
try:
name = data["name"]
password = data["password"]
email = data["email"]
subscription = None
plan = None
except KeyError:
return self.response({"error": "Missing required data"})
if any(Manager(Customer).filter(email=email)):
return self.response({"error": "Email already in use"})
customer = Customer(
name=name,
password=password,
email=email,
subscription=subscription,
plan=plan,
)
customer.set_password(password)
customer.save()
return self.response({"uid": customer.pk})
