def address_book(item_type):
"""Add a person or group to the address book."""
data = json.loads(request.data)
address_book = AddressBook.query.first()
if not address_book:
address_book = AddressBook()
address_book.save()
if item_type == "person":
person_obj = Person(**data)
try:
person_obj.save()
address_book.person_list.append(person_obj)
except MissingValueException as e:
return jsonify({
"saved": False,
"type": "person",
"data": data,
"message": "Missing {}".format(e)
})
except Exception as e:
raise e
elif item_type == "group":
data['persons'] = [Person.query.get(x) for x in data['persons']]
try:
group_obj = Group(**data)
group_obj.save()
address_book.group_list.append(group_obj)
except MissingValueException as e:
return jsonify({
"saved": False,
"type": "person",
"message": "Missing {}".format(e)
})
except BadValueException as e:
return jsonify({
"saved":
False,
"type":
"person",
"message":
"One of the Ids provided is not in Database"
})
except Exception as e:
raise e
else:
return jsonify(
{"message":
"The url has to be address_book/[person|group]"}), 404
address_book.save()
return jsonify({
"message": "saved {} to Address Book".format(item_type),
"data": json.loads(dumps(address_book.wrap()))
})
def collect_data(self):
self.device.shell("screencap -p /sdcard/screen.png")
self.device.pull("/sdcard/screen.png", self.main_image_path)
with Image.open(self.main_image_path) as main_image:
main_image_crop = main_image.crop((
0,
int(self.screen_resolution_height *
(self.crops['main_image'][0])),
self.screen_resolution_width,
int(self.screen_resolution_height *
(self.crops['main_image'][1])),
))
main_image_crop_jpg = main_image_crop.convert('RGB')
main_image_crop_jpg.save(self.crop_image_path)
# scroll down to bio # TINDER SPECIFIC, move to child class
self.get_bio_page_ready()
self.device.shell("screencap -p /sdcard/screen.png")
self.device.pull("/sdcard/screen.png", self.tmp_image_path)
with Image.open(self.tmp_image_path) as tmp_image:
raw_crop = tmp_image.crop((
0,
int(self.screen_resolution_height * (self.crops['raw'][0])),
self.screen_resolution_width,
int(self.screen_resolution_height * (self.crops['raw'][1])),
))
raw_crop.save(self.raw_image_path)
# convert main_image
raw_text = pytesseract.image_to_string(Image.open(self.raw_image_path))
# logger.debug(raw_text)
clean_data = self.cleanse_data(raw_text)
logger.debug(clean_data)
os.remove(self.main_image_path)
os.remove(self.raw_image_path)
os.remove(self.tmp_image_path)
# initing db row for Person
person = Person(
gender='female',
raw=clean_data,
result=True,
source_name=self.source_name,
)
session.add(person)
session.commit()
# adding row for picture
picture = Picture(
person_id=person.id,
_uuid=str(self._uuid),
)
session.add(picture)
session.commit()
def add_some_stuff_logic():
# data = data_manager.load_data(Person)
# print (data)
p1 = Person('james', 'jackson')
p2 = Person('Joan', 'Simpson')
Person.add(p1)
Person.add(p2)
Person.save()
c1 = Car('Ferrari', 'Sedan')
c2 = Car('Peugeot', 'Station')
Car.add(c1)
Car.add(c2)
Car.save()
print(Car.show())
def main() -> None:
"""Main."""
name: str = input('Give name: ')
person: Person = Person(name=name, balance=100)
while person.balance > 0:
res: str = spin_roulette(person=person,
amount=person.ask_bet_amount(),
bet=person.ask_bet_type(bets=BETS))
print(res)
def update(person_id, person):
"""
This function updates an existing person in the people structure
Throws an error if a person with the name we want to update to
already exists in the database.
:param person_id: Id of the person to update in the people structure
:param person: person to update
:return: updated person structure
"""
# Get the person requested from the db into session
update_person = Person.query.filter(
Person.person_id == person_id).one_or_none()
# Try to find an existing person with the same name as the update
fname = person.get("fname")
lname = person.get("lname")
existing_person = (Person.query.filter(Person.fname == fname).filter(
Person.lname == lname).one_or_none())
# Are we trying to find a person that does not exist?
if update_person is None:
abort(
404,
"Person not found for Id: {person_id}".format(person_id=person_id),
)
# Would our update create a duplicate of another person already existing?
elif (existing_person is not None
and existing_person.person_id != person_id):
abort(
409,
"Person {fname} {lname} exists already".format(fname=fname,
lname=lname),
)
# Otherwise go ahead and update!
else:
# turn the passed in person into a db object
schema = PersonSchema()
update = Person(lname=lname, fname=fname)
# Set the id to the person we want to update
update.person_id = update_person.person_id
# merge the new object into the old and commit it to the db
db.session.merge(update)
db.session.commit()
# return updated person in the response
data = schema.dump(update_person)
return data, 200
def post(self):
"""Create new person"""
person = Person()
person.first_name = api.payload["first_name"]
person.last_name = api.payload["last_name"]
person.email = api.payload["email"]
if "student_number" in api.payload:
person.student_number = api.payload["student_number"]
db.session.add(person)
db.session.commit()
return all_persons(include_active_partners=True)
def create_person(person, context):
name = person.name
email = person.email
url = person.url
goblin_person = yield from Person().create(name=name,
email=email,
url=url,
request_id=context.request_id,
pool=context.pool,
future_class=asyncio.Future)
return goblin_to_pb_person(goblin_person)
def conv_add_parse_age(self, update, context):
age = update.message.text
name = context.user_data['name']
logger.info(f'age: {age}')
p = Person(name=name, age=age)
logger.info(f'adding new person: {p}')
crud.add_person(p)
update.message.reply_text(
f'Added new person! name: {name}. age: {age}')
return ConversationHandler.END
def create(self, params):
params["version"] = 1
p = Person(**params)
db.session.add(p)
db.session.flush()
p_archive = PersonArchive(**params)
p_archive.person_id = p.id
db.session.add(p_archive)
db.session.commit()
return {"id": p.id}
def add_member():
# FIXME manage form errors on the list_bills page
form = MemberForm(g.project)
if request.method == "POST":
if form.validate():
member = form.save(g.project, Person())
db.session.commit()
flash(_("%(member)s had been added", member=member.name))
return redirect(url_for(".list_bills"))
return render_template("add_member.html", form=form)
def add():
person = Person()
personForm = PersonForm(obj=person)
if request.method == 'POST':
if personForm.validate_on_submit():
personForm.populate_obj(person)
app.logger.debug(f'Insert Person: {person}')
db.session.add(person)
db.session.commit()
return redirect(url_for('index'))
return render_template('add.html', form=personForm)
def set_dbdata(self, request):
tmp_data = Person(name='LSZ', age=27)
tmp_data.save()
rsp_data = {'data': 'set database data!'}
response = HttpResponse(json.dumps(rsp_data))
response["Access-Control-Allow-Origin"] = "*"
response["Access-Control-Allow-Methods"] = "POST, GET, OPTIONS"
response["Access-Control-Max-Age"] = "1000"
response["Access-Control-Allow-Headers"] = "*"
return response
def test_person_dict_1(self):
"""Test dictionary of a Person"""
person1 = Person("id1", "name1", "summary1", "city1",
"companies1", "role1", "twitter1", "logo_url1")
p1_dict = person1.dictionary()
self.assertIsInstance(p1_dict, dict)
self.assertEqual(p1_dict,
{"person_id": "id1", "name": "name1", "summary": "summary1",
"city": "city1", "companies": "companies1", "role": "role1",
"twitter": "twitter1", "logo_url": "logo_url1"})
def registered():
user = Person.query.filter_by(username=request.form['username']).first()
if user != None:
redirect(url_for("auth_blueprint.login"))
else:
pf = Person(request.form['name'], request.form['username'],
request.form['password'])
db.session.add(pf)
db.session.commit()
print('User Registered')
login_user(pf)
return render_template('registered.html')
def add_person():
db.create_all()
lp = float(request.headers['Lower-Price'])
hp = float(request.headers['Upper-Price'])
if hp < lp:
lp, hp = hp, lp # switch variables if user inputs wrong price bracket.
p = Person(twitter=request.headers['Twitter-Handle'],
lower_price=lp,
upper_price=hp)
db.session.add(p)
db.session.commit()
return jsonify([p.deserialize() for p in Person.query.all()])
def dispatcher(row: Iterable, name: str) -> Optional[dict]:
_dict = {
'genres': (lambda row: [genre.lower() for genre in row]),
'persons_names': (lambda row: [item[1].lower() for item in row]),
'persons':
(lambda row:
[Person(id=item[0], full_name=item[1].lower()) for item in row]),
}
if row:
return _dict[name](row)
else:
return None
def conv_edit_parse_age(self, update, context):
chat_id = update.effective_user.id
age = update.message.text
name = context.user_data['name']
logger.info(f'age: {age}')
new_p = Person(name=name, age=age)
old_person_id = self.conversation_context[chat_id][
self.K_CHOSEN_PERSON_ID]
crud.edit_person(old_person_id, new_p)
update.message.reply_text('Edit succeeded')
logger.info(f'Edit succeeded')
return ConversationHandler.END
def test_queryset_iter_method(self):
query_set = PeopleQuerySet(items=[
Person(name='secondary_actor',
height='100',
films=[1],
species=['species1']),
Person(name='main_actor',
height='90',
films=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
species=['species2']),
Person(name='another_actor',
height='50',
films=[1, 2, 3, 4],
species=['species1'])
])
expected = [
Person(name='secondary_actor',
height='100',
films=[1],
species=['species1']),
Person(name='main_actor',
height='90',
films=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
species=['species2']),
Person(name='another_actor',
height='50',
films=[1, 2, 3, 4],
species=['species1'])
]
for idx, person in enumerate(query_set):
self.assertEqual(expected[idx].name, person.name)
self.assertEqual(expected[idx].height, person.height)
self.assertEqual(expected[idx].films_count, person.films_count)
self.assertEqual(expected[idx].species, person.species)
def test_order_by_films_count(self):
query_set = PeopleQuerySet(items=[
Person(name='secondary_actor',
height='100',
films=[1],
species=['species1']),
Person(name='main_actor',
height='90',
films=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
species=['species2'])
])
ordered_results = query_set.order_by(attribute='films_count')
self.assertEqual(ordered_results.items[0].name, 'main_actor')
self.assertEqual(ordered_results.items[0].films_count, 10)
self.assertEqual(ordered_results.items[0].height, 90)
self.assertEqual(ordered_results.items[0].species, 'species2')
self.assertEqual(ordered_results.items[1].name, 'secondary_actor')
self.assertEqual(ordered_results.items[1].films_count, 1)
self.assertEqual(ordered_results.items[1].height, 100)
self.assertEqual(ordered_results.items[1].species, 'species1')
def put_person():
# get the name first, if no name then fail
name = request.form.get("name")
if not name:
return make_response(jsonify({"code": 403,
"msg": "Cannot put person. Missing mandatory fields."}), 403)
person_id = request.form.get("id")
if not person_id:
p = Person(name=name)
else:
p = Person(id=person_id, name=name)
db.session.add(p)
try:
db.session.commit()
except sqlalchemy.exc.SQLAlchemyError as e:
error = "Cannot put person. "
print(app.config.get("DEBUG"))
if app.config.get("DEBUG"):
error += str(e)
return make_response(jsonify({"code": 404, "msg": error}), 404)
return jsonify({"code": 200, "msg": "success"})
def test_model(self):
quantity = Person.objects.count()
p = Person(name="Name",
surname="Surname",
bio="Biography",
contacts="Contacts",
birth_date="1901-01-01")
p.save()
next_quantity = Person.objects.count()
self.assertTrue(next_quantity - quantity == 1)
p.delete()
next_quantity = Person.objects.count()
self.assertTrue(next_quantity == quantity)
def post(self, user_id):
auth_key = request.args.get('key')
user = User.authenticate(user_id, auth_key)
if user:
supposed_person = request.get_json(force=True)
person = Person()
person.user_id = user_id
person.name = supposed_person['name']
db.session.add(person)
db.session.commit()
if person.person_id:
return json.jsonify(person.as_dict())
return json.jsonify({})
def add_person():
person = Person(
id=-1,
first_name=request.json['firstName'],
last_name=request.json['lastName'],
age=request.json['age'],
height=request.json['height'],
description=request.json['description'],
)
db.add_person(person)
return jsonify({'person': 'true'}), 201
def signup():
form = SignupForm()
if form.validate_on_submit():
newperson = Person(form.firstname.data, form.lastname.data,
form.email.data, form.password.data)
db.session.add(newperson)
db.session.commit()
session['email'] = newperson.email
person = Person.query.filter_by(email=session['email']).first()
name = person.firstname
return redirect(url_for('dashboard', name=name))
return render_template('signup.html', form=form)
def People_agregar():
name = request.json.get("name", None)
color_ojos = request.json.get("color_ojos", None)
color_cabello = request.json.get("color_cabello", None)
gender = request.json.get("gender", None)
person = Person(name=name,
color_ojos=color_ojos,
color_cabello=color_cabello,
gender=gender)
db.session.add(person)
db.session.commit()
#user=json.loads(name, color_ojos, color_cabello,gender)
return jsonify({"people": "ok"})
def add_people(ctx, names):
"""Add new people into the archive"""
dbsession = ctx.obj['dbsession']
for name in names:
if '$' in name:
name, slug = name.split('$')
else:
slug = name.replace(' ', '-').lower()
person = dbsession.query(Person).filter(Person.slug == slug).first()
if not person:
person = Person(slug=slug, title=name, status='unconfirmed')
dbsession.add(person)
dbsession.commit()
def test_member_delete_person(self):
person = Person(firstname='Tiger', lastname='Woods',
handicap='4.2')
person.insert()
person_id = person.id
self.headers.update({'Authorization': 'Bearer ' + MEMBER_TOKEN})
res = self.client.delete(f'/persons/{person_id}', headers=self.headers)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['delete'], str(person_id))
def create_person(token):
body = request.get_json()
(name, age) = (body.get('name'), body.get('age'))
if name is None or age is None:
abort(422)
person = Person(name=name, age=age)
person.insert()
return {'persons': [person.json()], 'success': True}
def test_company_people(self):
c = Company(name="CoolCats")
p = Person(name="Elise")
self.session.add(c)
self.session.add(p)
self.assertTrue(len(c.people) < 1)
c.people.append(p)
self.session.add(c)
result = self.session.query(Company).filter_by(name="CoolCats").first()
p_again = result.people[0]
self.assertEqual(p_again.name, "Elise")
def createPerson():
person = Person()
person.name = request.json.get('name')
person.height = request.json.get('height')
person.mass = request.json.get('mass')
person.hair_color = request.json.get('hair_color')
person.skin_color = request.json.get('skin_color')
person.eye_color = request.json.get('eye_color')
person.birth_year = request.json.get('birth_year')
person.gender = request.json.get('gender')
person.save()
return jsonify(person.to_dict()), 201
