Convert to black formatting

app/widget/__init__.py

@@ -1,9 +1,10 @@
 from .model import Widget  # noqa
 from .schema import WidgetSchema  # noqa
-BASE_ROUTE = 'widget'
+
+BASE_ROUTE = "widget"
 
 
-def register_routes(api, app, root='api'):
+def register_routes(api, app, root="api"):
     from .controller import api as widget_api
 
-    api.add_namespace(widget_api, path=f'/{root}/{BASE_ROUTE}')
+    api.add_namespace(widget_api, path=f"/{root}/{BASE_ROUTE}")

app/widget/controller.py

@@ -9,47 +9,47 @@ from .service import WidgetService
 from .model import Widget
 from .interface import WidgetInterface
 
-api = Namespace('Widget', description='Single namespace, single entity')  # noqa
+api = Namespace("Widget", description="Single namespace, single entity")  # noqa
 
 
-@api.route('/')
+@api.route("/")
 class WidgetResource(Resource):
-    '''Widgets'''
+    """Widgets"""
 
     @responds(schema=WidgetSchema, many=True)
     def get(self) -> List[Widget]:
-        '''Get all Widgets'''
+        """Get all Widgets"""
 
         return WidgetService.get_all()
 
     @accepts(schema=WidgetSchema, api=api)
     @responds(schema=WidgetSchema)
     def post(self) -> Widget:
-        '''Create a Single Widget'''
+        """Create a Single Widget"""
 
         return WidgetService.create(request.parsed_obj)
 
 
-@api.route('/<int:widgetId>')
-@api.param('widgetId', 'Widget database ID')
+@api.route("/<int:widgetId>")
+@api.param("widgetId", "Widget database ID")
 class WidgetIdResource(Resource):
     @responds(schema=WidgetSchema)
     def get(self, widgetId: int) -> Widget:
-        '''Get Single Widget'''
+        """Get Single Widget"""
 
         return WidgetService.get_by_id(widgetId)
 
     def delete(self, widgetId: int) -> Response:
-        '''Delete Single Widget'''
+        """Delete Single Widget"""
         from flask import jsonify
 
         id = WidgetService.delete_by_id(widgetId)
-        return jsonify(dict(status='Success', id=id))
+        return jsonify(dict(status="Success", id=id))
 
     @accepts(schema=WidgetSchema, api=api)
     @responds(schema=WidgetSchema)
     def put(self, widgetId: int) -> Widget:
-        '''Update Single Widget'''
+        """Update Single Widget"""
 
         changes: WidgetInterface = request.parsed_obj
         Widget = WidgetService.get_by_id(widgetId)

app/widget/controller_test.py

@@ -1,4 +1,3 @@
-
 from unittest.mock import patch
 from flask.testing import FlaskClient
 
@@ -10,76 +9,88 @@ from .interface import WidgetInterface
 from . import BASE_ROUTE
 
 
-def make_widget(id: int = 123, name: str = 'Test widget',
-                purpose: str = 'Test purpose') -> Widget:
-    return Widget(
-        widget_id=id, name=name, purpose=purpose
-    )
+def make_widget(
+    id: int = 123, name: str = "Test widget", purpose: str = "Test purpose"
+) -> Widget:
+    return Widget(widget_id=id, name=name, purpose=purpose)
 
 
 class TestWidgetResource:
-    @patch.object(WidgetService, 'get_all',
-                  lambda: [make_widget(123, name='Test Widget 1'),
-                           make_widget(456, name='Test Widget 2')])
+    @patch.object(
+        WidgetService,
+        "get_all",
+        lambda: [
+            make_widget(123, name="Test Widget 1"),
+            make_widget(456, name="Test Widget 2"),
+        ],
+    )
     def test_get(self, client: FlaskClient):  # noqa
         with client:
-            results = client.get(f'/api/{BASE_ROUTE}',
-                                 follow_redirects=True).get_json()
-            expected = WidgetSchema(many=True).dump(
-                [make_widget(123, name='Test Widget 1'),
-                 make_widget(456, name='Test Widget 2')]
-            ).data
+            results = client.get(f"/api/{BASE_ROUTE}", follow_redirects=True).get_json()
+            expected = (
+                WidgetSchema(many=True)
+                .dump(
+                    [
+                        make_widget(123, name="Test Widget 1"),
+                        make_widget(456, name="Test Widget 2"),
+                    ]
+                )
+                .data
+            )
             for r in results:
                 assert r in expected
 
-    @patch.object(WidgetService, 'create',
-                  lambda create_request: Widget(**create_request))
+    @patch.object(
+        WidgetService, "create", lambda create_request: Widget(**create_request)
+    )
     def test_post(self, client: FlaskClient):  # noqa
         with client:
 
-            payload = dict(name='Test widget', purpose='Test purpose')
-            result = client.post(f'/api/{BASE_ROUTE}/', json=payload).get_json()
-            expected = WidgetSchema().dump(Widget(
-                name=payload['name'],
-                purpose=payload['purpose'],
-            )).data
+            payload = dict(name="Test widget", purpose="Test purpose")
+            result = client.post(f"/api/{BASE_ROUTE}/", json=payload).get_json()
+            expected = (
+                WidgetSchema()
+                .dump(Widget(name=payload["name"], purpose=payload["purpose"]))
+                .data
+            )
             assert result == expected
 
 
 def fake_update(widget: Widget, changes: WidgetInterface) -> Widget:
     # To fake an update, just return a new object
-    updated_Widget = Widget(widget_id=widget.widget_id,
-                            name=changes['name'],
-                            purpose=changes['purpose'])
+    updated_Widget = Widget(
+        widget_id=widget.widget_id, name=changes["name"], purpose=changes["purpose"]
+    )
     return updated_Widget
 
 
 class TestWidgetIdResource:
-    @patch.object(WidgetService, 'get_by_id',
-                  lambda id: make_widget(id=id))
+    @patch.object(WidgetService, "get_by_id", lambda id: make_widget(id=id))
     def test_get(self, client: FlaskClient):  # noqa
         with client:
-            result = client.get(f'/api/{BASE_ROUTE}/123').get_json()
+            result = client.get(f"/api/{BASE_ROUTE}/123").get_json()
             expected = make_widget(id=123)
-            print(f'result = ', result)
-            assert result['widgetId'] == expected.widget_id
+            print(f"result = ", result)
+            assert result["widgetId"] == expected.widget_id
 
-    @patch.object(WidgetService, 'delete_by_id',
-                  lambda id: id)
+    @patch.object(WidgetService, "delete_by_id", lambda id: id)
     def test_delete(self, client: FlaskClient):  # noqa
         with client:
-            result = client.delete(f'/api/{BASE_ROUTE}/123').get_json()
-            expected = dict(status='Success', id=123)
+            result = client.delete(f"/api/{BASE_ROUTE}/123").get_json()
+            expected = dict(status="Success", id=123)
             assert result == expected
 
-    @patch.object(WidgetService, 'get_by_id',
-                  lambda id: make_widget(id=id))
-    @patch.object(WidgetService, 'update', fake_update)
+    @patch.object(WidgetService, "get_by_id", lambda id: make_widget(id=id))
+    @patch.object(WidgetService, "update", fake_update)
     def test_put(self, client: FlaskClient):  # noqa
         with client:
-            result = client.put(f'/api/{BASE_ROUTE}/123',
-                                json={'name': 'New Widget',
-                                      'purpose': 'New purpose'}).get_json()
-            expected = WidgetSchema().dump(
-                Widget(widget_id=123, name='New Widget', purpose='New purpose')).data
+            result = client.put(
+                f"/api/{BASE_ROUTE}/123",
+                json={"name": "New Widget", "purpose": "New purpose"},
+            ).get_json()
+            expected = (
+                WidgetSchema()
+                .dump(Widget(widget_id=123, name="New Widget", purpose="New purpose"))
+                .data
+            )
             assert result == expected

app/widget/interface_test.py

@@ -5,9 +5,7 @@ from .interface import WidgetInterface
 
 @fixture
 def interface() -> WidgetInterface:
-    return WidgetInterface(
-        widget_id=1, name='Test widget', purpose='Test purpose'
-    )
+    return WidgetInterface(widget_id=1, name="Test widget", purpose="Test purpose")
 
 
 def test_WidgetInterface_create(interface: WidgetInterface):

app/widget/model.py

@@ -4,9 +4,9 @@ from .interface import WidgetInterface
 
 
 class Widget(db.Model):  # type: ignore
-    '''A snazzy Widget'''
+    """A snazzy Widget"""
 
-    __tablename__ = 'widget'
+    __tablename__ = "widget"
 
     widget_id = Column(Integer(), primary_key=True)
     name = Column(String(255))

app/widget/model_test.py

@@ -6,9 +6,7 @@ from .model import Widget
 
 @fixture
 def widget() -> Widget:
-    return Widget(
-        widget_id=1, name='Test widget', purpose='Test purpose'
-    )
+    return Widget(widget_id=1, name="Test widget", purpose="Test purpose")
 
 
 def test_Widget_create(widget: Widget):

app/widget/schema.py

@@ -2,8 +2,8 @@ from marshmallow import fields, Schema
 
 
 class WidgetSchema(Schema):
-    '''Widget schema'''
+    """Widget schema"""
 
-    widgetId = fields.Number(attribute='widget_id')
-    name = fields.String(attribute='name')
-    purpose = fields.String(attribute='purpose')
+    widgetId = fields.Number(attribute="widget_id")
+    name = fields.String(attribute="name")
+    purpose = fields.String(attribute="purpose")

app/widget/schema_test.py

@@ -15,13 +15,11 @@ def test_WidgetSchema_create(schema: WidgetSchema):
 
 
 def test_WidgetSchema_works(schema: WidgetSchema):
-    params: WidgetInterface = schema.load({
-        'widgetId': '123',
-        'name': 'Test widget',
-        'purpose': 'Test purpose'
-    }).data
+    params: WidgetInterface = schema.load(
+        {"widgetId": "123", "name": "Test widget", "purpose": "Test purpose"}
+    ).data
     widget = Widget(**params)
 
     assert widget.widget_id == 123
-    assert widget.name == 'Test widget'
-    assert widget.purpose == 'Test purpose'
+    assert widget.name == "Test widget"
+    assert widget.purpose == "Test purpose"

app/widget/service.py

@@ -4,7 +4,7 @@ from .model import Widget
 from .interface import WidgetInterface
 
 
-class WidgetService():
+class WidgetService:
     @staticmethod
     def get_all() -> List[Widget]:
         return Widget.query.all()
@@ -30,10 +30,7 @@ class WidgetService():
 
     @staticmethod
     def create(new_attrs: WidgetInterface) -> Widget:
-        new_widget = Widget(
-            name=new_attrs['name'],
-            purpose=new_attrs['purpose']
-        )
+        new_widget = Widget(name=new_attrs["name"], purpose=new_attrs["purpose"])
 
         db.session.add(new_widget)
         db.session.commit()

app/widget/service_test.py

@@ -7,8 +7,8 @@ from .interface import WidgetInterface
 
 
 def test_get_all(db: SQLAlchemy):  # noqa
-    yin: Widget = Widget(widget_id=1, name='Yin', purpose='thing 1')
-    yang: Widget = Widget(widget_id=2, name='Yang', purpose='thing 2')
+    yin: Widget = Widget(widget_id=1, name="Yin", purpose="thing 1")
+    yang: Widget = Widget(widget_id=2, name="Yang", purpose="thing 2")
     db.session.add(yin)
     db.session.add(yang)
     db.session.commit()
@@ -20,21 +20,21 @@ def test_get_all(db: SQLAlchemy):  # noqa
 
 
 def test_update(db: SQLAlchemy):  # noqa
-    yin: Widget = Widget(widget_id=1, name='Yin', purpose='thing 1')
+    yin: Widget = Widget(widget_id=1, name="Yin", purpose="thing 1")
 
     db.session.add(yin)
     db.session.commit()
-    updates: WidgetInterface = dict(name='New Widget name')
+    updates: WidgetInterface = dict(name="New Widget name")
 
     WidgetService.update(yin, updates)
 
     result: Widget = Widget.query.get(yin.widget_id)
-    assert result.name == 'New Widget name'
+    assert result.name == "New Widget name"
 
 
 def test_delete_by_id(db: SQLAlchemy):  # noqa
-    yin: Widget = Widget(widget_id=1, name='Yin', purpose='thing 1')
-    yang: Widget = Widget(widget_id=2, name='Yang', purpose='thing 2')
+    yin: Widget = Widget(widget_id=1, name="Yin", purpose="thing 1")
+    yang: Widget = Widget(widget_id=2, name="Yang", purpose="thing 2")
     db.session.add(yin)
     db.session.add(yang)
     db.session.commit()
@@ -50,7 +50,7 @@ def test_delete_by_id(db: SQLAlchemy):  # noqa
 
 def test_create(db: SQLAlchemy):  # noqa
 
-    yin: WidgetInterface = dict(name='Fancy new widget', purpose='Fancy new purpose')
+    yin: WidgetInterface = dict(name="Fancy new widget", purpose="Fancy new purpose")
     WidgetService.create(yin)
     results: List[Widget] = Widget.query.all()