Use black to refomat the files.

1 files changed, 108 insertions, 78 deletions

diff --git a/ihatemoney/models.py b/ihatemoney/models.py
index 48e16a7..250f009 100644
--- a/ihatemoney/models.py
+++ b/ihatemoney/models.py
@@ -6,8 +6,12 @@ from flask import g, current_app
 
 from debts import settle
 from sqlalchemy import orm
-from itsdangerous import (TimedJSONWebSignatureSerializer, URLSafeSerializer,
-                          BadSignature, SignatureExpired)
+from itsdangerous import (
+    TimedJSONWebSignatureSerializer,
+    URLSafeSerializer,
+    BadSignature,
+    SignatureExpired,
+)
 
 db = SQLAlchemy()
 
@@ -33,8 +37,8 @@ class Project(db.Model):
         balance = self.balance
         for member in self.members:
             member_obj = member._to_serialize
-            member_obj['balance'] = balance.get(member.id, 0)
-            obj['members'].append(member_obj)
+            member_obj["balance"] = balance.get(member.id, 0)
+            obj["members"].append(member_obj)
 
         return obj
 
@@ -45,14 +49,14 @@ class Project(db.Model):
     @property
     def balance(self):
 
-        balances, should_pay, should_receive = (defaultdict(int)
-                                                for time in (1, 2, 3))
+        balances, should_pay, should_receive = (defaultdict(int) for time in (1, 2, 3))
 
         # for each person
         for person in self.members:
             # get the list of bills he has to pay
             bills = Bill.query.options(orm.subqueryload(Bill.owers)).filter(
-                Bill.owers.contains(person))
+                Bill.owers.contains(person)
+            )
             for bill in bills.all():
                 if person != bill.payer:
                     share = bill.pay_each() * person.weight
@@ -72,18 +76,23 @@ class Project(db.Model):
         :return: one stat dict per member
         :rtype list:
         """
-        return [{
-            'member': member,
-            'paid': sum([
-                bill.amount
-                for bill in self.get_member_bills(member.id).all()
-            ]),
-            'spent': sum([
-                bill.pay_each() * member.weight
-                for bill in self.get_bills().all() if member in bill.owers
-            ]),
-            'balance': self.balance[member.id]
-        } for member in self.active_members]
+        return [
+            {
+                "member": member,
+                "paid": sum(
+                    [bill.amount for bill in self.get_member_bills(member.id).all()]
+                ),
+                "spent": sum(
+                    [
+                        bill.pay_each() * member.weight
+                        for bill in self.get_bills().all()
+                        if member in bill.owers
+                    ]
+                ),
+                "balance": self.balance[member.id],
+            }
+            for member in self.active_members
+        ]
 
     @property
     def uses_weights(self):
@@ -99,22 +108,27 @@ class Project(db.Model):
                 return transactions
             pretty_transactions = []
             for transaction in transactions:
-                pretty_transactions.append({
-                    'ower': transaction['ower'].name,
-                    'receiver': transaction['receiver'].name,
-                    'amount': round(transaction['amount'], 2)
-                })
+                pretty_transactions.append(
+                    {
+                        "ower": transaction["ower"].name,
+                        "receiver": transaction["receiver"].name,
+                        "amount": round(transaction["amount"], 2),
+                    }
+                )
             return pretty_transactions
 
         # cache value for better performance
         members = {person.id: person for person in self.members}
         settle_plan = settle(self.balance.items()) or []
 
-        transactions = [{
-            'ower': members[ower_id],
-            'receiver': members[receiver_id],
-            'amount': amount
-        } for ower_id, amount, receiver_id in settle_plan]
+        transactions = [
+            {
+                "ower": members[ower_id],
+                "receiver": members[receiver_id],
+                "amount": amount,
+            }
+            for ower_id, amount, receiver_id in settle_plan
+        ]
 
         return prettify(transactions, pretty_output)
 
@@ -140,23 +154,27 @@ class Project(db.Model):
 
     def get_bills(self):
         """Return the list of bills related to this project"""
-        return Bill.query.join(Person, Project)\
-            .filter(Bill.payer_id == Person.id)\
-            .filter(Person.project_id == Project.id)\
-            .filter(Project.id == self.id)\
-            .order_by(Bill.date.desc())\
-            .order_by(Bill.creation_date.desc())\
+        return (
+            Bill.query.join(Person, Project)
+            .filter(Bill.payer_id == Person.id)
+            .filter(Person.project_id == Project.id)
+            .filter(Project.id == self.id)
+            .order_by(Bill.date.desc())
+            .order_by(Bill.creation_date.desc())
             .order_by(Bill.id.desc())
+        )
 
     def get_member_bills(self, member_id):
         """Return the list of bills related to a specific member"""
-        return Bill.query.join(Person, Project)\
-            .filter(Bill.payer_id == Person.id)\
-            .filter(Person.project_id == Project.id)\
-            .filter(Person.id == member_id)\
-            .filter(Project.id == self.id)\
-            .order_by(Bill.date.desc())\
+        return (
+            Bill.query.join(Person, Project)
+            .filter(Bill.payer_id == Person.id)
+            .filter(Person.project_id == Project.id)
+            .filter(Person.id == member_id)
+            .filter(Project.id == self.id)
+            .order_by(Bill.date.desc())
             .order_by(Bill.id.desc())
+        )
 
     def get_pretty_bills(self, export_format="json"):
         """Return a list of project's bills with pretty formatting"""
@@ -166,16 +184,18 @@ class Project(db.Model):
             if export_format == "json":
                 owers = [ower.name for ower in bill.owers]
             else:
-                owers = ', '.join([ower.name for ower in bill.owers])
-
-            pretty_bills.append({
-                "what": bill.what,
-                "amount": round(bill.amount, 2),
-                "date": str(bill.date),
-                "payer_name": Person.query.get(bill.payer_id).name,
-                "payer_weight": Person.query.get(bill.payer_id).weight,
-                "owers": owers
-            })
+                owers = ", ".join([ower.name for ower in bill.owers])
+
+            pretty_bills.append(
+                {
+                    "what": bill.what,
+                    "amount": round(bill.amount, 2),
+                    "date": str(bill.date),
+                    "payer_name": Person.query.get(bill.payer_id).name,
+                    "payer_weight": Person.query.get(bill.payer_id).weight,
+                    "owers": owers,
+                }
+            )
         return pretty_bills
 
     def remove_member(self, member_id):
@@ -210,12 +230,12 @@ class Project(db.Model):
         """
         if expiration:
             serializer = TimedJSONWebSignatureSerializer(
-                current_app.config['SECRET_KEY'],
-                expiration)
-            token = serializer.dumps({'project_id': self.id}).decode('utf-8')
+                current_app.config["SECRET_KEY"], expiration
+            )
+            token = serializer.dumps({"project_id": self.id}).decode("utf-8")
         else:
-            serializer = URLSafeSerializer(current_app.config['SECRET_KEY'])
-            token = serializer.dumps({'project_id': self.id})
+            serializer = URLSafeSerializer(current_app.config["SECRET_KEY"])
+            token = serializer.dumps({"project_id": self.id})
         return token
 
     @staticmethod
@@ -226,34 +246,40 @@ class Project(db.Model):
         :param token: Serialized TimedJsonWebToken
         """
         if token_type == "timed_token":
-            serializer = TimedJSONWebSignatureSerializer(current_app.config['SECRET_KEY'])
+            serializer = TimedJSONWebSignatureSerializer(
+                current_app.config["SECRET_KEY"]
+            )
         else:
-            serializer = URLSafeSerializer(current_app.config['SECRET_KEY'])
+            serializer = URLSafeSerializer(current_app.config["SECRET_KEY"])
         try:
             data = serializer.loads(token)
         except SignatureExpired:
             return None
         except BadSignature:
             return None
-        return data['project_id']
+        return data["project_id"]
 
     def __repr__(self):
         return "<Project %s>" % self.name
 
 
 class Person(db.Model):
-
     class PersonQuery(BaseQuery):
-
         def get_by_name(self, name, project):
-            return Person.query.filter(Person.name == name)\
-                .filter(Project.id == project.id).one()
+            return (
+                Person.query.filter(Person.name == name)
+                .filter(Project.id == project.id)
+                .one()
+            )
 
         def get(self, id, project=None):
             if not project:
                 project = g.project
-            return Person.query.filter(Person.id == id)\
-                .filter(Project.id == project.id).one()
+            return (
+                Person.query.filter(Person.id == id)
+                .filter(Project.id == project.id)
+                .one()
+            )
 
     query_class = PersonQuery
 
@@ -276,9 +302,11 @@ class Person(db.Model):
 
     def has_bills(self):
         """return if the user do have bills or not"""
-        bills_as_ower_number = db.session.query(billowers)\
-            .filter(billowers.columns.get("person_id") == self.id)\
+        bills_as_ower_number = (
+            db.session.query(billowers)
+            .filter(billowers.columns.get("person_id") == self.id)
             .count()
+        )
         return bills_as_ower_number != 0 or len(self.bills) != 0
 
     def __str__(self):
@@ -290,23 +318,24 @@ class Person(db.Model):
 
 # We need to manually define a join table for m2m relations
 billowers = db.Table(
-    'billowers',
-    db.Column('bill_id', db.Integer, db.ForeignKey('bill.id')),
-    db.Column('person_id', db.Integer, db.ForeignKey('person.id')),
+    "billowers",
+    db.Column("bill_id", db.Integer, db.ForeignKey("bill.id")),
+    db.Column("person_id", db.Integer, db.ForeignKey("person.id")),
 )
 
 
 class Bill(db.Model):
-
     class BillQuery(BaseQuery):
-
         def get(self, project, id):
             try:
-                return (self.join(Person, Project)
-                        .filter(Bill.payer_id == Person.id)
-                        .filter(Person.project_id == Project.id)
-                        .filter(Project.id == project.id)
-                        .filter(Bill.id == id).one())
+                return (
+                    self.join(Person, Project)
+                    .filter(Bill.payer_id == Person.id)
+                    .filter(Person.project_id == Project.id)
+                    .filter(Project.id == project.id)
+                    .filter(Bill.id == id)
+                    .one()
+                )
             except orm.exc.NoResultFound:
                 return None
 
@@ -356,7 +385,8 @@ class Bill(db.Model):
     def __repr__(self):
         return "<Bill of %s from %s for %s>" % (
             self.amount,
-            self.payer, ", ".join([o.name for o in self.owers])
+            self.payer,
+            ", ".join([o.name for o in self.owers]),
         )